String、StringBuffer 和 StringBuilder

Java String 类（字符串常量）

字符串广泛应用 在Java 编程中，在 Java 中字符串属于对象，Java 提供了 String 类来创建和操作字符串。

需要注意的是，String的值是不可变的，这就导致每次对String的操作都会生成新的String对象，这样不仅效率低下，而且大量浪费有限的内存空间。我们来看一下这张对String操作时内存变化的图：

我们可以看到，初始String值为“hello”，然后在这个字符串后面加上新的字符串“world”，这个过程是需要重新在栈堆内存中开辟内存空间的，最终得到了“hello world”字符串也相应的需要开辟内存空间，这样短短的两个字符串，却需要开辟三次内存空间，不得不说这是对内存空间的极大浪费。为了应对经常性的字符串相关的操作，谷歌引入了两个新的类——StringBuffer类和StringBuild类来对此种变化字符串进行处理。

Java StringBuffer 和 StringBuilder 类（字符串变量）

和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。

由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。

小结

（1）如果要操作少量的数据用 String；

（2）多线程操作字符串缓冲区下操作大量数据 StringBuffer；

（3）单线程操作字符串缓冲区下操作大量数据 StringBuilder。

StringBuffer 和 StringBuilder 的 3 个区别

StringBuffer 和 StringBuilder 的类结构：

其实很简单，就是继承了一个抽象的字符串父类：AbstractStringBuilder。下面我们再来看看它们的三个区别。

区别1：线程安全
StringBuffer：线程安全，StringBuilder：线程不安全。因为 StringBuffer 的所有公开方法都是 synchronized 修饰的，而 StringBuilder 并没有 StringBuilder 修饰。

StringBuffer 代码片段：

@Override
public synchronized StringBuffer append(String str) {
    toStringCache = null;
    super.append(str);
    return this;
}

区别2：缓冲区
StringBuffer 代码片段：

private transient char[] toStringCache;

@Override
public synchronized String toString() {
    if (toStringCache == null) {
        toStringCache = Arrays.copyOfRange(value, 0, count);
    }
    return new String(toStringCache, true);
}

StringBuilder 代码片段：

@Override
public String toString() {
    // Create a copy, don't share the array
    return new String(value, 0, count);
}

可以看出，StringBuffer 每次获取 toString 都会直接使用缓存区的 toStringCache 值来构造一个字符串。

而 StringBuilder 则每次都需要复制一次字符数组，再构造一个字符串。

所以，缓存冲这也是对 StringBuffer 的一个优化吧，不过 StringBuffer 的这个toString 方法仍然是同步的。

区别3：性能
既然 StringBuffer 是线程安全的，它的所有公开方法都是同步的，StringBuilder 是没有对方法加锁同步的，所以毫无疑问，StringBuilder 的性能要远大于 StringBuffer。

String s = “abc” 和 String s = new String(“abc”) 的区别

用以下几种情况的代码及分析大致讲解 String s = “abc” 和 String s = new String(“abc”) 的区别。

情况1：

String str1 = "abc"; 
System.out.println(str1 == "abc"); 

步骤：

1、栈中开辟一块空间存放引用str1；
2、String池中开辟一块空间，存放String常量"abc"；
3、引用str1指向池中String常量"abc"；
4、str1所指代的地址即常量"abc"所在地址，输出为true；

情况2：

String str2 = new String("abc"); 
System.out.println(str2 == "abc");

步骤：

1、栈中开辟一块空间存放引用str2；
2、堆中开辟一块空间存放一个新建的String对象"abc"；
3、引用str2指向堆中的新建的String对象"abc"；
4、str2所指代的对象地址为堆中地址，而常量"abc"地址在池中，输出为false；

注意：对于通过 new 产生的对象，会先去常量池检查有没有 “abc”，如果没有，先在常量池创建一个 “abc” 对象，然后在堆中创建一个常量池中此 “abc” 对象的拷贝对象。

有道面试题： String s = new String(“xyz”); 产生几个对象？

答：一个或两个。如果常量池中原来没有 ”xyz”, 就是两个。如果原来的常量池中存在“xyz”时，就是一个。

对于基础类型的变量和常量：变量和引用存储在栈中，常量存储在常量池中。

情况3：

String str1 = "a"；
String str2 = "b"；
String str3 = str1 + "b"；
//str1 和 str2 是字符串常量，所以在编译期就确定了。
//str3 中有个 str1 是引用，所以不会在编译期确定。
//又因为String是 final 类型的，所以在 str1 + "b" 的时候实际上是创建了一个新的对象，在把新对象的引用传给str3。

情况4：

final String str1 = "a"；
String str2 = "b"；
String str3 = str1 + "b"；
//这里和(3)的不同就是给 str1 加上了一个final，这样str1就变成了一个常量。
//这样 str3 就可以在编译期中就确定了

情况5：

intern()方法：当调用 intern 方法时，如果常量池已经包含一个等于此 String 对象的字符串（该对象由 equals(Object) 方法确定），则返回常量池中的字符串。否则，将此 String 对象添加到池中，并且返回此 String 对象的引用。

String str1 = "ab"；
String str2 = new String("ab");
System.out.println(str1== str2);//false
System.out.println(str2.intern() == str1);//true

System.out.println(str1== str2);//false
str2 = str2.intern();
System.out.println(str1== str2);//true

讲解：
str1 指向的是常量池对象 “ab”；str2 指向的是堆中的对象 “ab”；
调用了 str2 = str2.intern() 后，str2.intern()判断常量池中是否有 "ab"对象，如果有就返回，没有就创建并返回，此时就返回的 str1 所指向的那个对象 “ab” ，所以 str1 == str2。

参考
1、String s = “abc” 和 String s = new String(“abc”) 的区别
2、StringBuffer 和 StringBuilder 的 3 个区别
3、String,StringBuffer与StringBuilder的区别