一、字符串的创建：
字符串创建有两种方式，分别来看看这两种方式有何区别：
1. 字面量赋值创建：
String str1 = "hello";String str2 = "hello";String str3 = "world";
这样创建字符串，首先会去常量池里找有没有这个字符串，有就直接指向常量池的该字符串，没有就先往常量池中添加一个，再指向它。图解：
image
2. 用new创建：
String str1 = new String("hello");String str2 = new String("hello");String str3 = new String("world");
new一个字符串时，做了两件事。首先在堆中生成了该字符串对象，然后去看常量池中有没有该字符串，如果有就不管了，没有就往常量池中添加一个。图解：
所以当问到“执行上面那三行代码创建了几个对象”这样的问题就很简单了，堆中三个常量池中两个，总共是5个。
小结：这两种方式创建出来的，一个在堆中，一个在常量池中，所以它们之间用 == 比较肯定是false。
二、字符串的拼接：
字符串可以直接用加号进行拼接，但是也有几种不同的情况。
1. 常量拼接
String str = "hello" + "world";
对于这种加号两边都是常量的，在编译阶段就会自动拼接，变成
String str = "helloworld";
所以就会去常量池找"helloworld"，有就直接指向它，没有就在常量池创建再指向。
2. 有final的拼接：
final String str1 = "hello";final String str2 = "world";String str3 = str1 + str2;
因为final修饰的变量就是常量，所以在编译期直接会变成
String str3 = "hello" + "world";
再根据常量拼接规则可知最终就变成
String str3 = "helloworld";
3. 变量和常量拼接：
变量和常量拼接的时候，底层会调用StringBuilder的append方法生成新对象。
情况一：
String str1 = "hello";String str2 = str1 + "world";
str1显然是在常量池中的，world也是在常量池中的，然后调用append方法在堆中生成新对象"helloworld"，str2就指向堆中的"helloworld"对象。所以这两条语句总共生成了3个对象，常量池中有"hello"和"world"，堆中有"helloword"。
情况二：
String str1 = new String("hello");String str2 = str1 + "world";
首先会在堆中创建一个"hello"，再把"hello"添加到常量池；然后会把"world"添加到常量池，拼接的时候，会在堆中创建一个"helloworld"。所以这两条语句总共创建了4个对象，堆中的"hello"、"helloworld"和常量池中的"hello"、"world"。
4. 变量和变量拼接：
变量和变量拼接，底层也会调用StringBuilder的append方法生成新对象。
情况一：
String str1 = "hello";String str2 = "world";String str3 = str1 + str2;
这段代码，首先会有一个"hello"在常量池中，然后有个"world"在常量池，第三行代码会调用append方法，在堆中生成一个"helloworld"。所以总共有3个对象。
情况二：
String str1 = "hello";String str2 = new String("world");String str3 = str1 + str2;
这段代码，首先在常量池中搞一个"hello"，然后在堆中new一个"world"，同时把"world"也搞到常量池中去，第三步拼接就会在堆中生成一个"helloworld"。所以总共有4个对象。
情况三：
String str1 = new String("hello");String str2 = new String("world");String str3 = str1 + str2;
第一行代码创建了两个对象，堆中一个常量池一个，第二行代码也是一样，第三行代码就在堆中创建了一个"helloworld"。所以总共创建了5个对象。
三、intern方法：
1、Java 1.7以前：*
JDK 1.7以前，intern方法会把对象拷贝到常量池。看下面例子：
例一：
String str1 = new String("str")+new String("01"); str1.intern(); String str2 = "str01"; System.out.println(str2==str1);
图解上述代码：
首先new String("str")会在堆中创建str，同时添加到常量池；new String("01")也是一样的，在堆中创建01，同时添加到常量池；然后两者拼接，底层用的append方法，在堆中生成一个str01；然后str1.intern()，就把str01拷贝到常量池了；此时运行到String str2 = "str01"，发现常量池中有了，所以直接指向常量池中的str01。最终str1指向堆中的str01对象，str2指向常量池的str01对象，所以结果是false。
例二：
String str1 = new String("str")+new String("01"); String str2 = "str01"; str1.intern(); System.out.println(str2==str1);
我们将第二三行代码调换顺序，看看情况有什么不同：
换一下顺序，区别就在于执行到第二行代码的时候，常量池中就已经有str01了，所以再执行str1.intern()的时候，就没有再进行拷贝了。最终还是str1指向堆中的str01，str2指向常量池的str01，所以结果还是false。
2、JDK1.7以后(包括1.7)：
从JDK 1.7开始，intern方法做了些改变，进行拷贝的时候不是拷贝对象，而是拷贝地址值。看下面的例子：
例一：
String str1 = new String("str")+new String("01");str1.intern();String str2 = "str01";System.out.println(str2==str1);
图解上述代码：
第一步和JDK 1.7之前是一样的，现在堆中创建一个str，同时搞到常量池，再创建一个01，同时搞到常量池，然后拼接，在堆中生成对象str01；不同的就是str1.intern()，这次拷贝的不是str01这个对象，而是把它的地址值搞到常量池中去了；然后执行String str2 = str01的时候，去常量池找str01，发现常量池中有x001地址值，刚好该地址值对应的就是要找的str01，就直接拿过来用。最终就是str1指向地址值为x001的对象，str2也是指向地址值为x001的对象，所以结果是true。
例二：
String str1 = new String("str")+new String("01");String str2 = "str01";str1.intern();System.out.println(str2==str1);
同样将二三行代码换一下位置，看看是什么情况：
第一步就不多说了，执行第二步时，往常量池中找str01，发现没有，那就添加一个；再执行str1.intern()时，发现常量池中有str01了，就不进行地址值的拷贝了。最终str1指向堆中的str01，str2指向常量池的str01，所以结果是false。
例三：
String str1 = new String("str")+new String("01");String str2 = "str01";str1 = str1.intern();System.out.println(str2==str1);
就是把例二的str1.intern()改成str1 = str1.intern()，看看会有什么变化：
本来str1是指向堆中的str01的，然后重新将str1.intern()赋给str1，str1.intern()是指向常量池的，赋给str1后，所以此时str1也是指向常量池。所以结果就是true。
四、String、StringBuilder和StringBuffer：
String和后两者的区别就是String是不可变的，后两者可变。StringBuilder是JDK 1.5以后提供的，以前用StringBuffer。StringBuffer和StringBuilder的功能基本一样，只是StringBuffer是线程安全的，而StringBuilder不是线程安全的。
因此，StringBuilder的效率会更高。
上面字符串拼接部分的案例都是用加号拼接的，然后也提到了StringBuilder的append方法。其实就算是加号拼接，底层还是用的StringBuilder的append方法。看下面代码：
String s = "abc"; String ss = "ok" + s + "xyz" + 5;
这就用加号拼接的例子，利用反编译工具看看这段代码到底编译成了啥：
String s = "abc";String ss = (new StringBuilder("ok")).append(s).append("xyz").append(5).toString();
可看到，编译后是用StringBuilder的append方法进行拼接的。那么使用加号和使用append方法到底有什么区别呢？看一下以下代码：
String s = ""; Random rand = new Random(); for (int i = 0; i < 10; i++){ s = s + rand.nextInt(1000) + " "; } System.out.println(s);
这个例子很简单，就是在循环里面用加号进行字符串的拼接，看一下反编译后是什么样子的：
String s = ""; Random rand = new Random(); for(int i = 0; i < 10; i++) { s = (new StringBuilder(String.valueOf(s))).append(rand.nextInt(1000)).append(" ").toString(); }System.out.println(s);
可以看到，它是在循环里面new了StringBuilder对象，然后用其append方法进行拼接。这里是i从0到9，也就是说要new十次，会创建十个对象，这样就会占用大量的资源。所以要让其编译后创建StringBuilder对象的过程在循环外面，代码就该这样写：
String s = ""; Random rand = new Random();StringBuilder result = new StringBuilder();for (int i = 0; i < 10; i++){ result.append(rand.nextInt(1000)); result.append(" ");} System.out.println(result.toString());
那么编译后就是这样的：
String s = ""; Random rand = new Random(); StringBuilder result = new StringBuilder(); for(int i = 0; i < 10; i++) { result.append(rand.nextInt(1000)); result.append(" "); }System.out.println(result.toString());
这样就没有在循环里面new对象了。
小结：当要在循环里面进行字符串拼接的时候，就该先在循环外面new一个StringBuilder，然后在循环里面用append进行拼接；其他情况就可以使用加号进行拼接更加简单。
网友评论