Java里面提供了String，StringBuffer和StringBuilder三个类来封装字符串，为加深理解我们将通过以下几个知识点从源码的角度分析这三个类；(JDK1.8版本)
1、长度是否可变(扩容机制)；
2、线程是否安全；
3、使用场景；
String 部分源码
public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
private final char value[];
private int hash; // Default to 0
private static final long serialVersionUID = -6849794470754667710L;
private static final ObjectStreamField[] serialPersistentFields =
new ObjectStreamField[0];
public String() {
this.value = "".value;
}
public String(String original) {
this.value = original.value;
this.hash = original.hash;
}
public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
if (srcBegin < 0) {
throw new StringIndexOutOfBoundsException(srcBegin);
}
if (srcEnd > value.length) {
throw new StringIndexOutOfBoundsException(srcEnd);
}
if (srcBegin > srcEnd) {
throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);
}
System.arraycopy(value, srcBegin, dst, dstBegin, srcEnd - srcBegin);
}
//省略其它代码......
}
StringBuffer 部分源码
public final class StringBuffer extends AbstractStringBuilderimplements java.io.Serializable, CharSequence{
private transient char[] toStringCache;
static final long serialVersionUID = 3388685877147921107L;
public StringBuffer() {
super(16);
}
public StringBuffer(String str) {
super(str.length() + 16);
append(str);
}
@Override
public synchronized StringBuffer append(Object obj) {
toStringCache = null;
super.append(String.valueOf(obj));
return this;
}
//省略其它代码......
}
StringBuilder 部分源码
public final class StringBuilder extends AbstractStringBuilder implements java.io.Serializable, CharSequence{
static final long serialVersionUID = 4383685877147921099L;
public StringBuilder() {
super(16);
}
public StringBuilder(String str) {
super(str.length() + 16);
append(str);
}
@Override
public StringBuilder append(Object obj) {
return append(String.valueOf(obj));
}
//省略其它代码......
}
AbstractStringBuilder 部分源码
abstract class AbstractStringBuilder implements Appendable, CharSequence {
char[] value;
int count;
AbstractStringBuilder() {
}
AbstractStringBuilder(int capacity) {
value = new char[capacity];
}
public AbstractStringBuilder append(Object obj) {
return append(String.valueOf(obj));
}
public AbstractStringBuilder append(String str) {
if (str == null)
return appendNull();
int len = str.length();
//调用 ensureCapacityInternal()扩容
ensureCapacityInternal(count + len);
//见String类中调用System.arraycopy实现数组之间的复制
str.getChars(0, len, value, count);
count += len;
return this;
}
private void ensureCapacityInternal(int minimumCapacity) {
// overflow-conscious code
if (minimumCapacity - value.length > 0) {
value = Arrays.copyOf(value,
newCapacity(minimumCapacity));
}
}
private int newCapacity(int minCapacity) {
// overflow-conscious code
//原有长度向左移1位之后+2 (length * 2) + 2
int newCapacity = (value.length << 1) + 2;
if (newCapacity - minCapacity < 0) {
newCapacity = minCapacity;
}
//返回的时候判断如果比 Integer.MAX_VALUE - 8大 则抛出异常
return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)
? hugeCapacity(minCapacity)
: newCapacity;
}
//省略其它代码......
}
//数组工具类
public class Arrays {
public static char[] copyOf(char[] original, int newLength) {
//创建长度为newLength的char数组，亦newCapacity（）扩容之后的长度
char[] copy = new char[newLength];
//System中提供了一个native静态方法arraycopy(),可以使用这个方法来实现数组之间的复制
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
//省略其它代码....
}
对源码的理解
通过String的构造函数创建出String对象，从源码中可以看出String类定义了一个用final修饰(不可变)的char[]数组，每次通过构造函数创建对象都会在堆内存中开辟一块新的空间;
故：String的长度不可变，也就可以理解为常量，线程安全;
StringBuffer 与 StringBuilder 都继承 AbstractStringBuilder 这个抽象类，在AbstractStringBuilder的源码中也定义了char[] value 这样一个成员变量，与String不同的是在这里并未用final修饰，并且在有参构造函数中创建一个长度为capacity的数组;
AbstractStringBuilder的append()方法中先调用ensureCapacityInternal()扩容然后通过String类提供的getChars()进行数组的复制;
同理：在AbstractStringBuilder中的deleteCharAt()、replace()、insert()等CRUD的方法在此就不做过多的描述，在这些方法底层实现大多数也是调用了 ensureCapacityInternal()与 System.arraycopy()，、substring()方法底层是通过重新new String(value, start, end - start)的方式来达到目的; StringBuffer 与 StringBuilder中实现对字符串处理的方法基本都是来自于AbstractStringBuilder类,但是在StringBuffer类中的方法添加了synchronized关键字,故 StringBuffer 是线程安全的,但是效率低;
总结：
1.1、可变性
- String 类中使用final关键字修饰字符数组来保存字符串，所以 String 对象是不可变的。
- StringBuffer与StringBuilder都继承自AbstractStringBuilder类,在 AbstractStringBuilder 中也是使用字符数组保存字符串char[]但是没有用 final 关键字修饰,所以这两种对象都是可变的。
1.2、线程安全性
- String 中的对象是不可变的，也就可以理解为常量，线程安全。
- StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。
- StringBuilder 并没有对方法进行加同步锁，所以是线程不安全的。
1.3、性能
- 每次对 String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象。
- StringBuffer与StringBuilder每次都会对对象本身进行操作，而不是生成新的对象并改变对象引用。
- 相同情况下使用 StringBuilder 相比使用 StringBuffer 仅能获得 10%-20% 左右的性能提升，但却要冒多线程不安全的风险。
1.4、使用总结：
- 操作少量的数据: 适用String;
- 单线程操作字符串缓冲区下操作大量数据: 适用StringBuilder;
- 多线程操作字符串缓冲区下操作大量数据: 适用StringBuffer;
- StringBuilder 与 StringBuffer 中的append()、insert()、delete()方法最根本上都是调用System.arraycopy()这个方法来达到目的;
- substring()方法底层是通过重新new String(value, start, end-start)的方式来达到目的。故在执行substring操作时，StringBuilder和String基本上没什么区别;
1.5、扩容机制
- StringBuilder 与 StringBuffer 的构造方法都是调用父类构造方法也就是 AbstractStringBuilder实现，且初始化容量为16，扩容机制为 (lenght * 2) + 2;
鄙人不才,在您面前献丑只愿与您结伴而行,文章若有不当之处,望大佬指点一二;如果我对您有帮助的话,还希望您能点赞分享,成长是一场苦涩的独自修行,我很需要您的陪伴与支持,这也是鄙人不断前行的根本动力,让我们在互相陪伴见证彼此生长的同时能够感染身边最亲近的人一同成长,鄙人在此叩谢！
