String作为java中最基本的类，担负着承载字符信息的作用。String具有不可变的final属性 , 这也决定了它对于在程序中传递信息的不可或缺性 。开发中，我们常常要对字符串进行拼接，这时我们会用到String对象重载的“+”操作符或concat(str)方法，也可以用StringBuilder、StringBuffer对象的append(str)方法来实现。
那么，String、StringBuilder、StringBuffer之间到底有什么联系和区别？
什么情况下分别适合使用这三个不同的类？
使用中需要注意哪些问题呢？
一 、String
1 . String对象是不可变的 ：String是个final类，所以它不可以被继承，它的值是不可改变的
2 . Sting对象不同的创建方式的区别：
.class字节码文件在被JVM加载时，常量（符号引用、字符串字面量等）会在方法区的常量池中存放。其中，源码中出现过的字符串字面常量会保存在CONSTANT_STRING_INFO常量表中，根据不同创建方式，会有不同的内容分配
1）字面常量方式创建的String变量
1 String str1 = "abcd"; 2 String str2 = "abcd"; 3 System.out.println(str1==str2);//true
可见上面创建的两个String的引用str1和str2都指向了CONSTANT_STRING_INFO常量表中的（同一个拘留字符串）同一地址值，所以str1==str2返回true。这是因为该类在加载时，字符串常量被存放在CONSTANT_STRING_INFO常量表中，并且同一字面值的字符串常量只会保存一次（称为拘留字符串）。注意：这里并没有创建String对象，因为没有在堆中分配内存。
2)通过new关键字创建String对象
1 String str1 = new String("string");
2 String str2 = new String("string");
3 System.out.println(str1==str2);//false
此时，str1==str2返回false。首先，字节码在加载时，将“string”字符串常量存放到CONSTANT_STRING_INFO常量表中，所以上面语句中出现的“String”被放在常量表的同一位置；然后，在执行上面两条语句是，通过关键字new，分别在堆中创建了两个对象，并且两对象在堆中保存的值均为“string”；也就是说，内存中共有三处存有同一字符串值：常量表中的拘留字符串、str1指向的堆空间、str2指向的堆空间。
3)通过intern()方法创建的String“对象”
1 String str1 = new String("string");
2 String str2 = new String("string").intern();
3 System.out.pringln(str1==str2);//true
intern()方法的作用：1.当常量池中的字符串常量表中存在与“string”拘留字符串内容相同的字符串时，则直接返回这个拘留字符串地址值，赋值给str2，此时并没有创建新的对象；2.当常量池中的字符创常量表中没有“string”拘留字符串时，则把“string”添加到常量池并保存到字符串常量表中，成为拘留字符串，然后在堆中创建String对象并将对象的引用返回，此时有新的对象创建。此方法主要是为了避免重复创建字符串对象。
3 . String中重载 + 操作符的原理
我们都知道，在String重载的+操作符前后可以拼接其他内容，包括基本数据类型和引用数据类型，并且其他数据类型都会转化成String类型。
其实，重载+操作符实际上，都是创建了一个StringBuilder或StringBuffer对象，用append方法对字符串进行拼接，最后调用toString方法返回字符串。
需要注意 + 拼接字符串的两种情况 ：
1 String str1 = "str"; 2 String str2 = "ing"; 3 String str = str1 + str2; 4 String str1_2 = "string"; 5 System.out.pringln(str == str1_2);//false
这里 + 拼接的str1、str2是两个字符串变量，所以首先创建StringBuilder/StringBuffer对象，append(str1).append(str2)把str1和str2拼接起来，最后通过toString()生成一个新的String对象并把引用返回，赋值给str。这里创建了新的对象，所以会返回false;
1 String str1 = "str" + "ing"; 2 String str2 = "string"; 3 System.out.pringln(str1 == str2);//true
使用 + 操作符拼接两个字符串字面量时，JVM会自动将这两部分字符串合并成完整的字符串常量值，保存到常量池的字符串常量表中成为拘留字符串。所以，这里只是将拘留字符串返回了而已，并没有创建新的对象。
4 . String类的concat(str)方法拼接字符串
只能将String类型的内容拼接到调用者后面，并不能像重载的+ 操作符那样拼接其他数据类型的内容。
1 public String concat(String str) {
2 int otherLen = str.length();
3 if (otherLen == 0) {
4 return this;
5 }
6 char buf[] = new char[count + otherLen];
7 getChars(0, count, buf, 0);
8 str.getChars(0, otherLen, buf, count);
9 return new String(0, count + otherLen, buf);
10}
可以看到，concat(str)方法拼接字符串的原理是创建一个新的char[]字符数组，把两个字符串转化成char类型之后存放到数组中，最后用char[]数组创建一个新的String对象。
二 、StringBuilder
1 . StringBuilder是一个非线程安全的final类，不能被继承
2 . append(str)方法的原理
1 public StringBuilder append(String str) {
2 super.append(str);
3 return this;
4 }
调用了父类的append(str)方法：
1 public AbstractStringBuilder append(String str) {
2 if (str == null) {
3 str = "null";
4 }
5 int len = str.length();
6 if (len == 0) {
7 return this;
8 }
9
10 int newCount = count + len;//统计拼接后字符串长度
11 if (newCount > value.length) {
12 expandCapacity(newCount);//如果拼接结果大于所用的char[]，则扩容
13 }
14 //getChars将拼接字符串赋值到char[]中
15 str.getChars(0, len, value, count);
16 count = newCount;//更新char[]所保存的字符串长度
17 return this;
18 }
可知，用StringBuilder拼接字符串时，其实是在底层创建了一个char[]数组，然后通过char[]把要拼接的字符串添加到char[]而已。最后通过toString()生成最终拼接结果时就是通过 return new String(char[]) 实现的。
三 、StringBuffer
1 . StringBuffer是线程安全的final类，不能被继承
2 . append(str)方法
1 public synchronized StringBuffer append(String str) {
2 super.append(str);
3 return this;
4 }
可以看到，StringBuffer的append也是调用父类AbstractStringBuilder的append方法实现的，原理同StringBuilder。其唯一不同的地方在于，加了一个syncrhoized关键字修饰append（）方法，保证了线程同步。
四 、String、StringBuilder和StringBuffer性能比较与选用
1 . 性能：StringBuilder > StringBuffer > String
从上面四种（其实应该说是五种，+ 分为字符串常量的拼接和变量的拼接两种）的字符串拼接来看，除了字符串常量的拼接是返回拘留字符串的地址外，其他四种（str1+str2、str1.concat(str2)、builder.append(str1).append(str2)、buffer.append(str1).append(str2)）都是使用了StringBuilder，或者说是StringBuilder的父类的拼接方法来做的——创建一个char数组，把需要拼接的内容先存进char数组，最后通过char数组创建新的String对象返回。
造成三者性能差别的主要原因是：
用String的 + 累加拼接字符串变量时，每拼接一个就会创建一个StringBuilder，并通过append()方法拼接，然后返回一个新的String对象。然后再继续拼接下一个变量。这样就会导致重复创建StringBuilder对象，性能低下。用 concat() 累计拼接时，则每两个字符串拼接都会创建一个 char[] 进行内容拼接并返回一个新的String对象作为结果，重复调用concat()会导致重复创建char[]和新String对象，性能低下。
StringBuilder在调用toString()之前都不会创建拼接结果，并且底层的char数组会自动扩容，一直到拼接字符串全部存入char数组后，调用toString()时才创建新的String对象并返回，这样就避免了重复创建，效率提高。
StringBuffer则因为使用了syncrhoized对append()进行了加锁，所以导致性能稍微低于StringBuilder。
2 . 不同情境下的选用
拼接两个字符串字面量，用 + 操作符；
单线程下拼接两个字符串变量，用StringBuilder；
多线程下拼接两个字符串变量，用StringBuffer 。
原文地址：https://www.cnblogs.com/dingm/p/10505691.html