[pull] master from giantray:master

SUMMARY.md

@@ -0,0 +1 @@
+\# Summary* [前言](README.md)

contents/Eclipse-set-maximun-line-length-for-auto-formatting.md

@@ -0,0 +1,6 @@
+为自动代码调整设置最大的行数？
+问题：我正在学习Java。如果我在Eclipse Helios里使用ctrl+shift+f的组合键，它会自动调整我的代码。一定程度下，它会改变行数。我想增加行数的最大值。应该怎么做？
+
+回答，在偏好设置里，分别点击Java->Code Style->Fomatter->edit,在菜单栏Line Wrapping下会有行的宽度选择（Maximun line width）.你将需要编辑你的代码轮廓。
+
+stackoverflow原址：http://stackoverflow.com/questions/3697287/eclipse-set-maximum-line-length-for-auto-formatting

contents/android-sdk-installation-doesnt-find-jdk.md

@@ -0,0 +1,33 @@
+##安装Android SDK的时候找不到JDK
+
+###问题
+我在我的win7 64位的系统上安装Android SDK时，jdk-6u23-windows-x64.exe已经安装上了，但是Android SDK的安装程序却因为找不到已安装的JDK无法继续下去。
+这个问题出现过吗？有没有办法解决呢？
+
+![](http://ww2.sinaimg.cn/large/0060lm7Tgw1f72ny3m6oaj30ds0a0gmi.jpg)
+
+###回答1：
+当你看到这个提示（找不到jdk）的时候按Back（返回），然后再点Next(下一步)。这个时候，它将会去寻找JDK
+
+###回答2：
+实际安装：
+
+	- 系统：windows 8.1
+	- JDK文件： jdk-8u11-windows-x64.exe
+	- ADT文件：installer_r23.0.2-windows.exe
+安装64位JDK，然后尝试第一个回答中的back-next的方法。然后尝试设置JAVA_HOME 根据错误信息的提示，但是，仍旧对我没有用处，然后，尝试如下解决办法：
+
+按照它说的做，设置JAVA_HOME在你的系统环境变量中，这个路径要使用正斜杠(/)而非反斜杠(\)
+
+**注意：**
+当我把JAVA_HOME设置为C:\Program Files\Java\jdk1.6.0_31的时候还是不行，但是当我设置成C:/Program Files/Java/jdk1.6.0_31的时候就ok了。快把我逼疯了。
+
+如果还不行，就把 %JAVA_HOME%加在环境变量Path的头部。
+
+下面是我的环境变量的配置：
+	- JAVA_HOME=C:/Program Files/Java/jdk1.8.0_11
+	- JRE_HOME=C:/Program Files/Java/jre8
+	- Path=%JAVA_HOME%;C:...
+
+stackoverflow链接：
+http://stackoverflow.com/questions/4382178/android-sdk-installation-doesnt-find-jdk

contents/avoiding-null-statements-in-java.md

@@ -50,7 +50,8 @@ public interface Parser {
 
 我们来改造一下
 
-类定义如下，这样定义findAction方法后，确保无论用户输入什么，都不会返回null对象
+类定义如下，这样定义findAction方法后，确保无论用户输入什么，都不会返回null对象：
+```java
 public class MyParser implements Parser {
   private static Action DO_NOTHING = new Action() {
     public void doSomething() { /* do nothing */ }
@@ -62,7 +63,7 @@ public class MyParser implements Parser {
       return DO_NOTHING;
     }
   }}
-
+```
 
 对比下面两份调用实例
 1. 冗余:  每获取一个对象，就判一次空
@@ -74,7 +75,8 @@ if (parser == null) {
 }
 Action action = parser.findAction(someInput);
 if (action == null) {
-  // do nothing} else {
+  // do nothing} 
+else {
   action.doSomething();}
 ```
 
@@ -90,11 +92,11 @@ ParserFactory.getParser().findAction(someInput).doSomething();
 - 如果要用equal方法，请用object<不可能为空>.equal(object<可能为空>))
 例如：
 使用
-"bar".equals(foo) 
+`"bar".equals(foo) `
 而不是
-foo.equals("bar") 
+`foo.equals("bar") `
 - Java8或者guava lib中，提供了Optional类，这是一个元素容器，通过它来封装对象，可以减少判空。不过代码量还是不少。不爽。
-- 如果你想返回null，请挺下来想一想，这个地方是否更应该抛出一个异常
+- 如果你想返回null，请停下来想一想，这个地方是否更应该抛出一个异常
 
 stackoverflow链接：
-http://stackoverflow.com/questions/271526/avoiding-null-statements-in-java?page=2&tab=votes#tab-top
+http://stackoverflow.com/questions/271526/avoiding-null-statements?page=1&tab=votes#tab-top

contents/comparing-java-enum-members-or-equals.md

@@ -44,10 +44,10 @@ public final boolean equals(Object other) {
 答案是肯定的，因为枚举有着严格的实例化控制，所以你可以用 == 去做比较符，这个用法，在官方文档中也有明确的说明。
 
 >JLS 8.9 Enums
->An enum type has no instances other than those defined by its enum constants.
->It is a compile-time error to attempt to explicitly instantiate an enum type. The final clone method in Enum >ensures that enum constants can never be cloned, and the special treatment by the serialization mechanism ensures >that duplicate instances are never created as a result of deserialization. Reflective instantiation of enum types >is prohibited. Together, these four things ensure that no instances of an enum type exist beyond those defined by >the enum constants.
->Because there is only one instance of each enum constant, it is permissible to use the == operator in place of the >equals method when comparing two object references if it is known that at least one of them refers to an enum ?>constant. (The equals method in Enum is a final method that merely invokes super.equals on its argument and ?>returns the result, thus performing an identity comparison.)
+一个枚举类型除了定义的那些枚举常量外没有其他实例了。
+试图明确地说明一种枚举类型是会导致编译期异常。在枚举中final clone方法确保枚举常量从不会被克隆，而且序列化机制会确保从不会因为反序列化而创造复制的实例。枚举类型的反射实例化也是被禁止的。总之，以上内容确保了除了定义的枚举常量之外，没有枚举类型实例。
 
+因为每个枚举常量只有一个实例，所以如果在比较两个参考值，至少有一个涉及到枚举常量时，允许使用“==”代替equals()。（equals()方法在枚举类中是一个final方法，在参数和返回结果时，很少调用父类的equals()方法，因此是一种恒等的比较。）
 #### 什么时候 == 和 equals 不一样？
 As a reminder, it needs to be said that generally, == is NOT a viable alternative to equals. When it is, however (such as with enum), there are two important differences to consider:
 通常来说 == 不是一个 equals的一个备选方案，无论如何有2个重要的不同处需要考虑：
@@ -73,8 +73,8 @@ if (Color.BLACK == Chiral.LEFT);      // DOESN'T COMPILE!!! Incompatible types!
 Bloch specifically mentions that immutable classes that have proper control over their instances can guarantee to their clients that == is usable. enum is specifically mentioned to exemplify.
 具体来说，那些提供恰当实例控制的不可变类能够保证 == 是可用的，枚举刚好符合这个条件。
 
-> Item 1: Consider static factory methods instead of constructors
-[...] it allows an immutable class to make the guarantee that no two equal instances exist: a.equals(b) if and only if a==b. If a class makes this guarantee, then its clients can use the == operator instead of the equals(Object) method, which may result in improved performance. Enum types provide this guarantee.
+考虑静态工厂方法代替构造器
+它使得不可变的类可以确保不会存在两个相等的实例，即当且仅当a==b的时候才有a.equals(b)为true。如果类保证了这一点，它的客户端可以使用“==”操作符来代替equals（Object）方法，这样可以提升性能。枚举类型保证了这一点
 
 总而言之，在枚举比较上使用 == ， 因为：
 1. 能正常工作

contents/convert-a-string-to-an-enum-in-java.md

@@ -19,6 +19,38 @@ Enum.valueOf()是否能实现以上目的，如果是，那我如何使用？
 
 ### 其他答案
 
+当文本和枚举值不同时，可以采用这种方式：
+```java
+public enum Blah {
+  A("text1"),
+  B("text2"),
+  C("text3"),
+  D("text4");
+
+  private String text;
+
+  Blah(String text) {
+    this.text = text;
+  }
+
+  public String getText() {
+    return this.text;
+  }
+
+  public static Blah fromString(String text) {
+    for (Blah b : Blah.values()) {
+      if (b.text.equalsIgnoreCase(text)) {
+        return b;
+      }
+    }
+    return null;
+  }
+}
+```
+fromString方法中，throw new IllegalArgumentException("No constant with text " + text + " found") 会比直接返回null更优秀.
+
+### 其他答案
+
 我有一个挺赞的工具方法：
 ```java
 /**
@@ -47,4 +79,4 @@ public static MyEnum fromString(String name) {
 }
 ```
 
-stackoverflow链接：http://stackoverflow.com/questions/604424/convert-a-string-to-an-enum-in-java
+stackoverflow链接：http://stackoverflow.com/questions/604424/convert-a-string-to-an-enum-in-java

contents/efficiency-of-java-double-brace-initialization.md

@@ -0,0 +1,202 @@
+## "Double Brace Initialization"的效率问题
+
+#### 问题
+
+`Double Brace Initialization`是java的隐藏特性，它有着如下诱人的语法：
+
+```java
+Set<String> flavors = new HashSet<String>() {{
+    add("vanilla");
+    add("strawberry");
+    add("chocolate");
+    add("butter pecan");
+}};
+```
+
+但是，这个特性听说不是很高效率，是否要限制一次性使用？
+
+#### 回答
+
+当我使用匿名内部类时出现了如下的问题：
+
+```Auto
+2009/05/27  16:35             1,602 DemoApp2$1.class
+2009/05/27  16:35             1,976 DemoApp2$10.class
+2009/05/27  16:35             1,919 DemoApp2$11.class
+2009/05/27  16:35             2,404 DemoApp2$12.class
+2009/05/27  16:35             1,197 DemoApp2$13.class
+
+/* snip */
+
+2009/05/27  16:35             1,953 DemoApp2$30.class
+2009/05/27  16:35             1,910 DemoApp2$31.class
+2009/05/27  16:35             2,007 DemoApp2$32.class
+2009/05/27  16:35               926 DemoApp2$33$1$1.class
+2009/05/27  16:35             4,104 DemoApp2$33$1.class
+2009/05/27  16:35             2,849 DemoApp2$33.class
+2009/05/27  16:35               926 DemoApp2$34$1$1.class
+2009/05/27  16:35             4,234 DemoApp2$34$1.class
+2009/05/27  16:35             2,849 DemoApp2$34.class
+
+/* snip */
+
+2009/05/27  16:35               614 DemoApp2$40.class
+2009/05/27  16:35             2,344 DemoApp2$5.class
+2009/05/27  16:35             1,551 DemoApp2$6.class
+2009/05/27  16:35             1,604 DemoApp2$7.class
+2009/05/27  16:35             1,809 DemoApp2$8.class
+2009/05/27  16:35             2,022 DemoApp2$9.class
+```
+
+这是在我的一个简单应用中所产生的类信息。在这个应用中，使用了大量的匿名内部类，这些类会被单独地编译成`class`文件。
+
+`Double Brace Initialization`是一个带有实例初始化块的匿名内部类。这就意味着每一个新的类的产生都会执行一次实例块，这样的目的通常是为了创建一个简单的对象。
+
+java虚拟机在使用类之前需要去读取其classes信息，然后执行字节码校验等流程。所以为了保存这些`class`文件，所需要的磁盘空间会增大。
+
+这个可以说是`Double Brace Initialization`的开销。所以尽量不要过分使用。
+
+---
+
+在java的介绍中，`Double Brace Initialization`有着如下的写法：
+
+```java
+List<String> list = new ArrayList<String>() {{
+    add("Hello");
+    add("World!");
+}};
+```
+
+看起来像是java的隐藏特性，其实它只是下面代码的一个重写：
+
+```java
+List<String> list = new ArrayList<String>() {
+
+    // 实例初始化块
+    {
+        add("Hello");
+        add("World!");
+    }
+};
+```
+
+所以，它只是在匿名内部类中加上了实例初始化块而已。
+
+---
+
+Joshua Bloch希望以后的集合代码能够像这样简介：
+
+```java
+List<Integer> intList = [1, 2, 3, 4];
+
+Set<String> strSet = {"Apple", "Banana", "Cactus"};
+
+Map<String, Integer> truthMap = { "answer" : 42 };
+```
+
+但目前还没有这样的语法。
+
+---
+
+<strong>实践</strong>
+
+做一个简单的试验：创建1000个带着`"Hello"`和`"World!"`元素的`ArrayList`
+
+* 方法1：Double Brace Initialization
+
+```
+List<String> l = new ArrayList<String>() {{
+  add("Hello");
+  add("World!");
+}};
+```
+
+* 方法2：初始化`ArrayList`并调用`add`方法
+
+```java
+List<String> l = new ArrayList<String>();
+l.add("Hello");
+l.add("World!");
+```
+
+我修改了java的源文件使之能够为每种上述方法分别创建出1000个实例
+
+* 方法1的测试
+
+```java
+class Test1 {
+  public static void main(String[] s) {
+    long st = System.currentTimeMillis();
+
+    List<String> l0 = new ArrayList<String>() {{
+      add("Hello");
+      add("World!");
+    }};
+
+    List<String> l1 = new ArrayList<String>() {{
+      add("Hello");
+      add("World!");
+    }};
+
+    /* snip */
+
+    List<String> l999 = new ArrayList<String>() {{
+      add("Hello");
+      add("World!");
+    }};
+
+    System.out.println(System.currentTimeMillis() - st);
+  }
+```
+
+* 方法2的测试
+
+```java
+class Test2 {
+  public static void main(String[] s) {
+    long st = System.currentTimeMillis();
+
+    List<String> l0 = new ArrayList<String>();
+    l0.add("Hello");
+    l0.add("World!");
+
+    List<String> l1 = new ArrayList<String>();
+    l1.add("Hello");
+    l1.add("World!");
+
+    /* snip */
+
+    List<String> l999 = new ArrayList<String>();
+    l999.add("Hello");
+    l999.add("World!");
+
+    System.out.println(System.currentTimeMillis() - st);
+  }
+}
+```
+
+然后得出了下面的测试时间：
+
+```Auto
+Test1 Times (ms)           Test2 Times (ms)
+----------------           ----------------
+           187                          0
+           203                          0
+           203                          0
+           188                          0
+           188                          0
+           187                          0
+           203                          0
+           188                          0
+           188                          0
+           203                          0
+```
+
+从上面我们可以看到，`Double Brace Initialization`平均时间花费了190ms左右。
+同时，另外一种方法平均只用了0ms。
+
+所以，在第一个方法测试程序中，即`Double Brace Initialization`产生了1000个`class`文件。
+
+## StackOverflow地址
+
+[http://stackoverflow.com/questions/924285/efficiency-of-java-double-brace-initialization](http://stackoverflow.com/questions/924285/efficiency-of-java-double-brace-initialization)

contents/examples-of-gof-design-patterns-in-javas-core-libraries.md

@@ -54,7 +54,7 @@
 
 ### [装饰模式](http://en.wikipedia.org/wiki/Decorator_pattern)
 
-- [java.io.InputStream](http://docs.oracle.com/javase/6/docs/api/java/io/InputStream.html),[OutputStream](http://docs.oracle.com/javase/6/docs/api/java/io/OutputStream.html),[Reader](http://docs.oracle.com/javase/6/docs/api/java/io/Reader.html) 和 [Writer](http://docs.oracle.com/javase/6/docs/api/java/io/Writer.html) 的所有资料都有一个使用 InputStream,OutputStream,Reader,Writer 的构造器
+- [java.io.InputStream](http://docs.oracle.com/javase/6/docs/api/java/io/InputStream.html), [OutputStream](http://docs.oracle.com/javase/6/docs/api/java/io/OutputStream.html), [Reader](http://docs.oracle.com/javase/6/docs/api/java/io/Reader.html) 和 [Writer](http://docs.oracle.com/javase/6/docs/api/java/io/Writer.html) 的所有子类都有一个使用 InputStream, OutputStream, Reader, Writer 的构造器
 - [java.util.Collections](http://docs.oracle.com/javase/6/docs/api/java/util/Collections.html) 中的 [checkedXXX()](http://docs.oracle.com/javase/6/docs/api/java/util/Collections.html#checkedCollection%28java.util.Collection,%20java.lang.Class%29), [synchronizedXXX()](http://docs.oracle.com/javase/6/docs/api/java/util/Collections.html#synchronizedCollection%28java.util.Collection%29) 和 [unmodifiableXXX()](http://docs.oracle.com/javase/6/docs/api/java/util/Collections.html#unmodifiableCollection%28java.util.Collection%29) 方法
 - [javax.servlet.http.HttpServletRequestWrapper](http://docs.oracle.com/javaee/6/api/javax/servlet/http/HttpServletRequestWrapper.html) 和 [HttpServletResponseWrapper](http://docs.oracle.com/javaee/6/api/javax/servlet/http/HttpServletResponseWrapper.html)
 
@@ -148,4 +148,4 @@
 
 
 - stackoverflow原址:
-http://stackoverflow.com/questions/1673841/examples-of-gof-design-patterns-in-javas-core-libraries
+http://stackoverflow.com/questions/1673841/examples-of-gof-design-patterns-in-javas-core-libraries