String s = a+b+c+d+e;创建了几个对象的详细分析?

问题1： String s = "a" + "b" + "c" + "d" + "e"; 
问此语句共创建了几个对象， 

答案是 
就创建了一个 
String s = "a" + "b" + "c" + "d" + "e"; 
赋值符号右边的"a"、"b"、"c"、"d"、"e"都是常量 
对于常量，编译时就直接存储它们的字面值而不是它们的引用 
在编译时就直接讲它们连接的结果提取出来变成了"abcde" 
该语句在class文件中就相当于String s = "abcde" 
然后当JVM执行到这一句的时候， 就在String pool里找 
如果没有这个字符串，就会产生一个 


问题2：但是如果改成 String s = a+b+c+d+e; 
呢 又是几个了。 

就是说上面是一个是因为 "a"、"b"、"c"、"d"、"e"都是常量 
但如果是变量呢？ 
我的答案是3个对象，但只有一个String对象：

由于编译器的优化，最终代码为通过StringBuilder完成：

1. StringBuilder builder = new StringBuilder(); 
2. builder.append(a); 
3. builder.append(b); 
4. builder.append(c); 
5. builder.append(d); 
6. builder.append(e); 
7. String s = builder.toString(); 

我们先看看StringBuilder的构造器

1.     public StringBuilder() {
2.      super(16);
3.     }

看下去

1.     AbstractStringBuilder(int capacity) {
2.         value = new char[capacity];
3.     }

可见，分配了一个16自己长度的char数组 我们看看append的整个过程 (注意，源代码我从各个类进行了整合，他们实际上不在一个类里面的)

2.   public StringBuilder append(String str) {
3.     super.append(str);
4.     return this;
5.   }
7.   public AbstractStringBuilder append(String str) {
8.     if (str == null)
9.       str = "null";
10.     int len = str.length();
11.     if (len == 0)
12.       return this;
13.     int newCount = count + len;
14.     if (newCount > value.length)
15.       expandCapacity(newCount);
16.     str.getChars(0, len, value, count);
17.     count = newCount;
18.     return this;
19.   }
21.   public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
22.     if (srcBegin < 0) {
23.       throw new StringIndexOutOfBoundsException(srcBegin);
24.     }
25.     if (srcEnd > count) {
26.       throw new StringIndexOutOfBoundsException(srcEnd);
27.     }
28.     if (srcBegin > srcEnd) {
29.       throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);
30.     }
31.     System
32.         .arraycopy(value, offset + srcBegin, dst, dstBegin, srcEnd - srcBegin);
33.   }

可见，我们的代码不会超过16个，所以不会出现扩展value的情况。 而append里面使用了arraycopy的复制方式，也没有产生新的对象。 最后，我们再看StringBuilder的 toString()方法：

1. public String toString() {
2.     // Create a copy, don't share the array
3.     return new String(value, 0, count);
4.   }

这里通过前面的数组生成了一个新的String。 大家注意那个默认的16容量，如果题目出现了总长度超过16，则会出现如下的再次分配的情况

1.   void expandCapacity(int minimumCapacity) {
2.     int newCapacity = (value.length + 1) * 2;
3.     if (newCapacity < 0) {
4.       newCapacity = Integer.MAX_VALUE;
5.     } else if (minimumCapacity > newCapacity) {
6.       newCapacity = minimumCapacity;
7.     }
8.     value = Arrays.copyOf(value, newCapacity);
9.   }
10. 
    
11.   public static char[] copyOf(char[] original, int newLength) {
12.     char[] copy = new char[newLength];
13.     System
14.         .arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
15.     return copy;
16.   }

可见，expand容量时，增加为当前(长度+1)*2。
注意这里用了Arrays的方法，注意不是前面的 System.arraycopy方法哦。这里产生了一个新的
copy的char数组，长度为新的长度

总结：三个对象分别为
1 StringBuilder
2 new char[capacity]
3 new String(value,0,count);

如果说String对象，则为1个。

参考：http://blog.csdn.net/java2000_net/article/details/3681385