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 较好，是绝大多数字符串拼接、裁剪的首选类
