String

String是Java语言非常重要的类，提供了构造和管理字符串的各种基本逻辑，是 Immutable 类的典型实现，原生的保证了基础线程安全，因为你无法对它内部数据进行任何修改，这种便利甚至体现在拷贝构造函数中，由于不可变，Immutable 对象在拷贝时不需要额外复制数据。String 类被声明成为 final class，所有属性也都是 final 的。也由于它的不可变性，类似拼接、裁剪字符串等动作，都会产生新的 String 对象，相关操作的效率往往对应用性能有明显影响，所以在拼接、裁剪字符串操作一般使用 StringBuffer 、StringBuilder 类。在数据存储方面，从 Java 9 开始引入了 Compact String 设计，将存储方式从原来的 char 数组改变成 byte 数组和一个标识编码 coder ，这样实现了节约空间的目的，因为 char 是两个 bytes 的大小，而一些拉丁系语言的字符不需要太宽的 char ，这样会对空间造成浪费。来看看 String 的部分源码。

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
    @Stable
    private final byte[] value;
    private final byte coder;
    static final boolean COMPACT_STRINGS;

    static {
        COMPACT_STRINGS = true;
    }
    public String() {
        this.value = "".value;
        this.coder = "".coder;
    }
    public String(int[] codePoints, int offset, int count) {
        checkBoundsOffCount(offset, count, codePoints.length);
        if (count == 0) {
            this.value = "".value;
            this.coder = "".coder;
            return;
        }
        // 加入 compact_string 判断
        if (COMPACT_STRINGS) {
            byte[] val = StringLatin1.toBytes(codePoints, offset, count);
            if (val != null) {
                this.coder = LATIN1;
                this.value = val;
                return;
            }
        }
        this.coder = UTF16;
        this.value = StringUTF16.toBytes(codePoints, offset, count);
    }
    ......
}

你可以对比一下 Java 9 与 Java 9 之前的 String 的实现。

不可变对象与可变对象

在面向对象和函数式编程中，一个 immutable 对象（不可变对象）是指一旦创建之后状态不可改变的对象。mutable 对象（可变对象）是指创建之后也可以修改的对象。在有些情况下，对象也被认为是不可变的（immutable），即，一个对象包含的内部使用的属性改变了，但从外部看对象的状态并没有改变。例如，一个使用 memoization 来缓存复杂计算结果的对象仍然被看作是不可变（immutable）对象。
不可变对象（immutable）有几个优点：

提高可读性和运行效率

线程安全

比可变对象有更高的安全性

StringBuffer

StringBuffer 是为解决 String 对象拼接产生太多中间对象的问题而提供的一个类，可以理解为是 String 的补充。StringBuffer 提供了 append 和 add 方法，用于把字符串添加到已有序列的末尾或者指定位置。StringBuffer 继承了 AbstractStringBuilder ，StringBuffer 是一个线程安全的可修改字符序列，它保证了线程安全，也随之带来了额外的性能开销。它在所有的操作方法前面都添加了 synchronized 关键字来实现线程安全。简单粗暴。由于它的目的是修改字符串序列，所以在 StringBuffer 的内部提供了一个数组，那么这个数组是多大呢？目前的实现中，初始构建的字符串长度+ 16 。当操作的字符串长度大于数组长度时，它会自动扩容，重新创建新的数组，抛弃原来的数组，利用 arraycopy 将原来的数组内容复制到新的数组中，每次扩容的大小是原来数组的两倍+ 2 。频繁的扩容会损耗性能，所以在使用时我们要估摸拼接字符串的长度，设置合理的大小。来一起看看 StringBuffer 的部分源码。

 private int newCapacity(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = value.length >> coder;
        // 新数组是老数组大小的两倍+ 2
        int newCapacity = (oldCapacity << 1) + 2;
        if (newCapacity - minCapacity < 0) {
            newCapacity = minCapacity;
        }
        int SAFE_BOUND = MAX_ARRAY_SIZE >> coder;
        return (newCapacity <= 0 || SAFE_BOUND - newCapacity < 0)
            ? hugeCapacity(minCapacity)
            : newCapacity;
    }


 public final class StringBuffer
    extends AbstractStringBuilder
    implements java.io.Serializable, Comparable<StringBuffer>, CharSequence
{
    // 初始化数组的大小
    public StringBuffer(CharSequence seq) {
        this(seq.length() + 16);
        append(seq);
    }
    ......
    // 使用 synchronized 来实现线程安全
    @Override
    public synchronized StringBuffer append(Object obj) {
        toStringCache = null;
        super.append(String.valueOf(obj));
        return this;
    }
    ......
}

StringBuilder

StringBuilder 是 Java 1.5 中新增的，在能力上和 StringBuffer 没有本质区别，但是它去掉了线程安全的部分，有效减小了开销，是绝大部分情况下进行字符串拼接的首选。

    // 和 StringBuffer 的实现一模一样，只是没有保证线程安全，这样提升了使用性能
    @Override
    @HotSpotIntrinsicCandidate
    public StringBuilder append(String str) {
        super.append(str);
        return this;
    }

对比 StringBuffer 与 StringBuilder 的源码，StringBuilder 只是在操作方法上把 synchronized 关键字去掉了，没有其他变化。

总结

String 是不可变类型，不适合字符串的拼接、裁剪
StringBuffer 是对 String 的补充，能在保证线程安全的情况下拼接、裁剪字符串
StringBuilder 是对 StringBuffer 的优化，不能保证线程安全，性能比 StringBuffer 较好，是绝大多数字符串拼接、裁剪的首选类