String StringBuffer StringBuilder介绍

JDK9

字符串常量池

String字符串特点

• 字符串内容不可变
• 因为字符串内容不可变，所有字符串可以共享
• 在JDK8中，String类型的字符串用char[]数组存储；在JDK9中，用byte[]数组存储

JDK8中，String类的部分源码：

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    
    // 可以看到这里是一个final类型的char数组
    private final char value[];
    	
	//...
}

JDK9中，String类的部分源码：

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {

	// 可以看到这里是一个final类型的byte数组
    @Stable
    private final byte[] value;
	
	//...
}

创建String字符串的方式

构造方法：

• public String()
  String s1 = new String()); //空字符串
• public String(char[] array)
  char[] arr = {'a', 'b', 'c'}; String s2 = new String(arr);
• public String(byte[] array)
  byte[] arr = {97, 98, 99}; String s3 = new String(arr);

直接创建：
String s = "abc";

字符串常量池

先通过下面的例子引出字符串常量池：

public static void main(String[] args) {
    String str1 = "abc";
    String str2 = "abc";

    char[] arr = {'a', 'b', 'c'};
    String str3 = new String(arr);

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

对于基本数据类型，== 比较的是数值
对于引用类型，== 比较的是地址值

图解：
也就是说JVM创建字符串的时候，是在堆中创建了一个字节数组，然后把字节数组的首地址保存在了字符串常量池中的字符串对象中，然后把字符串对象的首地址保存在栈中的str1变量中。
但是通过new String()的方式创建字符串，是直接在堆上开辟内存。

String类型的变量不可变，即String a = “hello”；a = a + " world"；实际上是新创建栈空间存储"hello world"，a的地址值由指向"hello"变为指向"hello world"，"hello"字符串被丢弃。试想一下，如果进行大量的String类型变量的修改操作，就产生了很多未使用的对象，很浪费内存空间。

String a = "abc";
String a = new String("abc");
String d = new String("abc");
char[] arr = {'a', 'b', 'c'};
String str3 = new String(arr);
String str4 = new String(arr);

StringBuffer和StringBuilder

和String一样，在JDK8中，底层用char数组存储字符串，在JDK9中，底层使用byte数组存储字符串

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

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

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

三者的继承结构：

StringBuffer和StringBuilder的线程安全问题

StringBuffer sbuf = new StringBuffer();
sbuf.append(1);

StringBuilder sbui = new StringBuilder();
sbui.append(1);

sbuf的append方法会调用：

@Override
@HotSpotIntrinsicCandidate
public synchronized StringBuffer append(int i) {
    toStringCache = null;
    super.append(i);
    return this;
}

sbui的append方法会调用：

@Override
@HotSpotIntrinsicCandidate
public StringBuilder append(int i) {
    super.append(i);
    return this;
}

可以看到，StringBuffer类的append方法前加上了synchronized关键字保证了线程安全。但是这两个append方法最终调用的都是父类AbstractStringBuilder中的append方法：

public AbstractStringBuilder append(String str) {
    if (str == null) {
        return appendNull();
    }
    int len = str.length();
    ensureCapacityInternal(count + len);
    putStringAt(count, str);
    count += len;
    return this;
}

下面通过Java多线程编程测试下StringBuffer和StringBuilder的线程安全问题：

public class RunnableTest implements Runnable {
    public StringBuilder str = new StringBuilder("");
//    public StringBuffer str = new StringBuffer("");
    @Override
    public void run() {
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        str.append(Thread.currentThread().getName());
        System.out.println(str+"--"+str.length());
    }
}

public class StringTest {
    public static void main(String[] args) {
        RunnableTest rt = new RunnableTest();

        new Thread(rt, "aa").start();
        new Thread(rt, "bb").start();
        new Thread(rt, "cc").start();
        new Thread(rt, "dd").start();
        new Thread(rt, "ee").start();
        new Thread(rt, "ff").start();
    }
}

使用线程不安全的StringBuilder类时的结果，可以看到字符串的长度计算是有问题的，这就是因为字符串拼接和长度计算的代码块没有保障线程安全：

使用线程安全的StringBuffer类时的结果：

一个小案例

StringBuffer sbuf = new StringBuffer();
String s = null;
sbuf.append(s);
System.out.println(sbuf.length());

结果：

4

看源码：

public AbstractStringBuilder append(String str) {
    if (str == null) {
        return appendNull();
    }
    int len = str.length();
    ensureCapacityInternal(count + len);
    putStringAt(count, str);
    count += len;
    return this;
}

private AbstractStringBuilder appendNull() {
    ensureCapacityInternal(count + 4);
    int count = this.count;
    byte[] val = this.value;
    if (isLatin1()) {
        val[count++] = 'n';
        val[count++] = 'u';
        val[count++] = 'l';
        val[count++] = 'l';
    } else {
        count = StringUTF16.putCharsAt(val, count, 'n', 'u', 'l', 'l');
    }
    this.count = count;
    return this;
}

小结

三者的区别：

• StringBuffer和StringBuilder类型的字符串可以改变，且不会产生新的未使用字符串对象
• String类型的字符串不能在原字符串上做修改
• StringBuffer效率低，线程安全
• StringBuilder（JDK5提出）效率高，非线程安全

如何选择：

• 如果程序运行过程中不需要对字符串进行改变则使用String
• 多线程操作字符串缓冲区下操作大量数据则使用StringBuffer
• 单线程操作字符串缓冲区下操作大量数据则使用StringBuilder