一、字符串拼接问题
由于 String 类的对象内容不可改变，所以每当进行字符串拼接时，总是会在内存中创建一个新的对象。
Demo：
1 public class StringDemo {
2 public static void main(String[] args) {
3 String s = "Hello";
4 s += "World";
5 System.out.println(s);
6 }
7 }
上面这段代码，总共产生了三个字符串，即“Hello”，“world” 和 “HelloWorld”。引用变量 s 首先执行 Hello 对象，最终指向拼接出来的新字符串对象，即 HelloWorld。
由此可见，如果对字符串进行拼接操作，每次拼接，都会构建一个新的 String 对象，既耗时，又浪费空间。为了解决这一问题，可以使用 java.lang.StringBuilder 类。
String类有这样的描述：字符串是常量，它们的值在创建后不能被更改。
由于 String 类不可变，对于频繁操作字符串的操作不方便，JDK为我们提供了可变的字符序列。
二、StringBuffer 类
1、概述
（1）java.lang.StringBuffer 代表可变的字符序列，JDK1.0中声明，可以对字符串内容进行增删，此时不会产生新的对象。
（2）StringBuffer 类中有很多方法与 String 相同；
（3）作为参数传递时，方法内部可以改变值；
（4）类结构：
（5）AbstractStringBuilder 类
2、构造方法
StringBuffer 类不同于 String，其对象必须使用构造器生成。该类有四个构造器：
1 public StringBuffer() {
2 super(16); //char[] value = new char[16]; 初始容量为16的字符串缓冲区
3 }
4
5 public StringBuffer(int capacity) {
6 super(capacity); //构造指定容量的字符串缓冲区
7 }
8
9 public StringBuffer(String str) {
10 super(str.length() + 16); //将内容初始化为指定字符串内容
11 append(str);
12 }
13
14 public StringBuffer(CharSequence seq) {
15 this(seq.length() + 16);
16 append(seq);
17 }
3、常用方法
StringBuffer append(xxx)：提供了很多的append()方法，用于进行字符串拼接
StringBuffer delete(int start,int end)：删除指定位置的内容
StringBuffer replace(int start, int end, String str)：把[start,end)位置替换为str
StringBuffer insert(int offset, xxx)：在指定位置插入xxx
StringBuffer reverse() ：把当前字符序列逆转
public int indexOf(String str)：返回字符串的第一次出现的顺序
public String substring(int start,int end):返回一个从start开始到end索引结束的左闭右开区间的子字符串
public int length()：返回字符序列的长度
public char charAt(int n )：获取指定索引位置的字符串
public void setCharAt(int n ,char ch)：为某个指定索引设置元素
这些方法可以理解为对一个该字符串的增删改查，遍历操作：
增：append(xxx)
删：delete(int start,int end)
改：setCharAt(int n ,char ch) / replace(int start, int end, String str)
查：charAt(int n )
插：insert(int offset, xxx)
长度：length();
遍历：for() + charAt() / toString()
Demo：
1 @Test
2 public void test(){
3 StringBuffer s1 = new StringBuffer("abc");
4 s1.append(1);
5 s1.append('1');
6 System.out.println(s1);
7 // s1.delete(2,4);
8 // s1.replace(2,4,"hello");
9 // s1.insert(2,false);
10 // s1.reverse();
11 String s2 = s1.substring(1, 3);
12 System.out.println(s1);
13 System.out.println(s1.length());
14 System.out.println(s2);
15 }
注意：上面的这些方法都是加了 synchronized 关键字的，所以操作起来效率较低，但是能够保证线程安全。
4、方法链（链式编程）
StringBuffer 类的这些方法支持方法链操作。
方法链的原理：
可以看到，每次操作完之后都会把此对象返回，进而可以接着调用其他本类中其他方法。
Demo：
1 @Test
2 public void test4() {
3 StringBuffer buffer = new StringBuffer("abc");
4
5 StringBuffer bufferChange = buffer.append("a").append(1).append(false).reverse();
6
7 System.out.println(bufferChange);
8 }
append方法具有多种重载形式，可以接收任意类型的参数。任何数据作为参数都会将对应的字符串内容添加到StringBuilder中。
5、扩容原理
在此之前，我们先来看一个小案例：
1 StringBuffer sb2 = new StringBuffer("abc");//char[] value = new char["abc".length() + 16];
2
3 System.out.println(sb2.length());//3
扩容问题：如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组。
我们从 append() 方法来看一下源码：
（1）当调用 append() 方法时，会调用父类的 append() 方法；
（2）父类的 append() 方法中，如果传来的为 null，则手动拼接一个 “null”放进去；如果不是 null，则获取字符串的长度，然后来校验是否需要扩容，以来保证能够放下所有的元素；
（3）ensureCapacityInternal() 方法参数为已经占用的位置 count+len，如果最小容量（count+len）比当前整个数组的长度还要大，则需要进行扩容，使用 Arrays.copyOf() 方法创建一个数组；
（4）newCapacity(minimumCapacity) 就是用于计算需要的新数组的容量；
（5）在 newCapacity 中重新计算新容量 newCapacity 为 原来容量的2倍 + 2，如果这时能放下，同时将原有数组中的元素复制到新的数组中；如果还是放不下，就会计算更大的容量，当所需容量大于扩容容量，就会直接返回所需容量。
（6）在 hugeCapcaity （计算巨大的容量）中，如果所需容量超出 Integer 最大值，抛出异常；如果并为超出，但超出了 MAX_ARRAY_SIZE（Integer.MAX_VALUE - 8），直接返回 minCapacity。
小结：
① 数组底层进行扩容是，默认情况下，扩容为原来容量的2倍 + 2，同时将原有数组中的元素复制到新的数组中；
② 如果扩容完之后不能满足所需容量则直接扩容到所需的容量。
③ 开发中建议大家使用：StringBuffer(int capacity) 或 StringBuilder(int capacity)
三、StringBuilder 类
1、概述
（1）StringBuilder 也是一个可变字符序列，是JDK1.5引入的，线程不安全的可变字符串。
（2）它是一个类似于 String 的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容。
（3）类结构
可以看到 StringBuilder 和 StringBuffer 的继承结构是一样的，这也就表示，这两个类的构造，存储，以及常用的大部分方法都是相似的。
（4）与StringBuffer
2、扩容机制（同StringBuffer）
StringBuilder是个字符串的缓冲区，即它是一个容器，容器中可以装很多字符串。并且能够对其中的字符串进行各种操作。
它的内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容。StringBuilder会自动维护数组的扩容。(默认char[]数组16字符空间，如果不够了扩容为原来的 2 倍+2)
3、可变的字符序列
4、线程不安全
StringBuilder 类中的方法都是没有使用 synchronized 修饰的，所以使用起来效率高，但是线程不安全。
四、String、StringBuffer 和 StringBuilder 的异同
1、相同点
2、不同点
String（JDK1.0）：不可变字符序列，底层使用 char[] 存储
StringBuffer（JDK1.0）：可变字符序列、效率低，线程安全，底层使用char[]存储
StringBuilder（JDK5.0）：可变字符序列、效率高、线程不安全，底层使用char[]存储
注意：作为参数传递的话，方法内部 String 不会改变其值，StringBuffer 和 StringBuilder 会改变其值。
一个类似于 String 的字符串缓冲区，但能被修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容，所有对 StringBuffer 或 StringBuilder 对象的字符序列的修改不会产生新的 StringBuffer 或 StringBuilder 对象，这点和String很大的不同。
value没有final声明,value可以不断扩容，count记录有效字符的个数。
3、三者效率问题
对比String、StringBuffer、StringBuilder三者的效率：
从高到低排列：StringBuilder > StringBuffer > String
Demo：
1 @Test
2 public void test3(){
3 //初始设置
4 long startTime = 0L;
5 long endTime = 0L;
6 String text = "";
7 StringBuffer buffer = new StringBuffer("");
8 StringBuilder builder = new StringBuilder("");
9 //开始对比
10 startTime = System.currentTimeMillis();
11 for (int i = 0; i < 20000; i++) {
12 buffer.append(String.valueOf(i));
13 }
14 endTime = System.currentTimeMillis();
15 System.out.println("StringBuffer的执行时间：" + (endTime - startTime));
16
17 startTime = System.currentTimeMillis();
18 for (int i = 0; i < 20000; i++) {
19 builder.append(String.valueOf(i));
20 }
21 endTime = System.currentTimeMillis();
22 System.out.println("StringBuilder的执行时间：" + (endTime - startTime));
23
24 startTime = System.currentTimeMillis();
25 for (int i = 0; i < 20000; i++) {
26 text = text + i;
27 }
28 endTime = System.currentTimeMillis();
29 System.out.println("String的执行时间：" + (endTime - startTime));
30
31 }
五、常见的坑
测试：
1 @Test
2 public void test() {
3 String str = null;
4 StringBuffer stringBuffer = new StringBuffer();
5 stringBuffer.append(str);
6
7 System.out.println(stringBuffer.length()); //4
8
9 System.out.println(stringBuffer); //null
10
11 StringBuffer stringBuffer1 = new StringBuffer(str); //NPE
12 System.out.println("stringBuffer1 = " + stringBuffer1);
13 }
为什么会出现上面的情况呢？让我们来看一下源码：
append方法：
可以看到调用 append() 方法，如果传入的为 null，会自动给我们传入字符串 “null”。
再看构造方法：
由于传进来的是 String 一个引用对象，且它的值为 null，在这里会调用 str.length() 所以会报 NPE。