JavaSE-String、StringBuilder和StringBuffer源码分析

目录

简介

String

继承关系

成员变量及构造方法

StringBuilder和StringBuffer

继承关系

AbstractStringBuilder

成员变量及构造方法

扩容方法

append()方法

StringBuilder

构造方法

append()方法

toString()方法

StringBuffer

成员变量及构造方法

append()方法

toString()方法

总结

---

简介

---

在JDK1.8下，String、StringBuilder和StringBuffer是常用于操作字符串。String是不可变的字符序列，StringBuilder和StringBuffer是可变的字符序列。StringBuilder是线程不安全的，String和StringBuilder是线程安全的。下面分析它们的内部实现。

String

---

继承关系

---

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

可以看到，String实现了Serializable、Comparable和CharSequence接口。Serializable是可序列化的标志。Comparable接口包含compareTo()方法。CharSequence接口包含了charAt()、length()、subSequence()和toString()这几个方法。

成员变量及构造方法

---

private final char value[];

private int hash; // Default to 0

public String() {
    this.value = "".value;
}

public String(String original) {
    this.value = original.value;
    this.hash = original.hash;
}

public String(char value[]) {
    this.value = Arrays.copyOf(value, value.length);
}

public String(char value[], int offset, int count) {
    if (offset < 0) {
        throw new StringIndexOutOfBoundsException(offset);
    }
    if (count <= 0) {
        if (count < 0) {
            throw new StringIndexOutOfBoundsException(count);
        }
        if (offset <= value.length) {
            this.value = "".value;
            return;
        }
    }
    // Note: offset or count might be near -1>>>1.
    if (offset > value.length - count) {
        throw new StringIndexOutOfBoundsException(offset + count);
    }
    this.value = Arrays.copyOfRange(value, offset, offset+count);
}

String用一个常量的char[]数组保存字符串，是不可变的。char[]数组转成String类型，是通过Arrays的copyOff()方法进行深拷贝，将局部char[]数组复制，赋值给常量的char[]数组。

StringBuilder和StringBuffer

---

继承关系

---

public final class StringBuilder
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence

 

public final class StringBuffer
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence

可见，StringBuilder和StringBuffer继承的类和实现的接口都一模一样，和String一样实现了Serializable和CharSquence接口。最重要的是，继承的AbstractStringBuilder抽象类，封装了StringBuilder和StringBuffer的大部分方法。

AbstractStringBuilder

---

成员变量及构造方法

---

char[] value;

int count;

AbstractStringBuilder() {
}

AbstractStringBuilder(int capacity) {
    value = new char[capacity];
}

AbstractStringBuilder也定义了char[]数组保存字符串，但不是用final修饰的，所以字符串是可变的。同时，还定义一个int类型的全局变量cout。构造时，可以指定初始容量capacity，为了获得更好的性能。

扩容方法

---

public void ensureCapacity(int minimumCapacity) {
    if (minimumCapacity > 0)
        ensureCapacityInternal(minimumCapacity);
}

private void ensureCapacityInternal(int minimumCapacity) {
    // overflow-conscious code
    if (minimumCapacity - value.length > 0) {
        value = Arrays.copyOf(value,
            newCapacity(minimumCapacity));
    }
}

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

private int newCapacity(int minCapacity) {
    // overflow-conscious code
    int newCapacity = (value.length << 1) + 2;
    if (newCapacity - minCapacity < 0) {
        newCapacity = minCapacity;
    }
    return (newCapacity <= 0 || MAX_ARRAY_SIZE - newCapacity < 0)
        ? hugeCapacity(minCapacity)
        : newCapacity;
}

private int hugeCapacity(int minCapacity) {
    if (Integer.MAX_VALUE - minCapacity < 0) { // overflow
        throw new OutOfMemoryError();
    }
    return (minCapacity > MAX_ARRAY_SIZE)
        ? minCapacity : MAX_ARRAY_SIZE;
}

AbstractStringBuilder的扩容方法是由newCapacity()实现的。这个方法中，将容量扩大到原始容量的两倍（使用了移位操作代替了*），再加上2。如果扩大的容量小于指定的容量，就将minCapacity设为最新的容量。如果Integer的最大值（0x7fffffff）减去8小于最新的容量，就调用hugeCapacity()方法。判断是否溢出，如果溢出，则抛异常OutOfMemoryError，否则，如果新的容量大于Integer的最大值减去8，则把容量设为minCapacity，否则设为Integer的最大值减去8。如果Integer的最大值（0x7fffffff）减去8大于最新的容量，否则容量设为newCapacity。

append()方法

---

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(count + len);
	str.getChars(0, len, value, count);
	count += len;
	return this;
}

private AbstractStringBuilder appendNull() {
	int c = count;
	ensureCapacityInternal(c + 4);
	final char[] value = this.value;
	value[c++] = 'n';
	value[c++] = 'u';
	value[c++] = 'l';
	value[c++] = 'l';
	count = c;
	return this;
}

append()方法是StringBuilder和StringBuffer最常用的方法，重载了许多种方法，用于追加字符串。第一个append()方法，通过String的valueOf()方法将obj对象转成String类型再追加。第二个append()方法，如果str是null，则调用appendNull()方法，首先扩容（原始容量加上4），再追加'n'，'u'，'l'，'l'这四个字符。如果str不是null，首先扩容（原始容量加上字符串长度），然后调用String的getChars()方法，将str追加到char[]数组value的末尾，最后将容量设为原始容量+字符串长度，返回对象本身，这样就可以连续调用append()方法。

StringBuilder

---

构造方法

---

public StringBuilder() {
	super(16);
}

public StringBuilder(int capacity) {
	super(capacity);
}

public StringBuilder(String str) {
	super(str.length() + 16);
	append(str);
}

可见，StringBuilder的默认容量大小为16，也可以指定它的初始容量。如果以一个字符串给StringBuilder对象赋值时，StringBuiler此时的容量大小为当前字符串的长度加上16。

append()方法

---

@Override
public StringBuilder append(Object obj) {
	return append(String.valueOf(obj));
}

@Override
public StringBuilder append(String str) {
	super.append(str);
	return this;
}

StringBuilder中append()方法都是重写父类AbstractStringBuilder的方法，重载了许多append()方法。其方法的实现都是调用父类AbstractStringBuilder的append()方法。当多个线程访问这个方法时，由于count是全局变量，当多个线程执行到count += len的时候，count的值就会出现问题，导致实际跟真实不一致，所以StringBuilder线程不安全。

toString()方法

---

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

StringBuilder重写了Object的toString()方法，new Stirng()内部调用了Arrays的copyOfRange()方法（深拷贝），返回一个新的String对象，没有与原来的对象共享一个内存空间。

StringBuffer

---

成员变量及构造方法

---

private transient char[] toStringCache;

public StringBuffer() {
	super(16);
}

public StringBuffer(int capacity) {
	super(capacity);
}

public StringBuffer(String str) {
	super(str.length() + 16);
	append(str);
}

在构造的时候，StringBuffer和StringBuilder一样，默认容量大小为16，可以指定初始容量。唯一不同的是，StringBuffer定义了一个用transient修饰的char[]数组toStringCache。transient关键字，修饰变量时，该变量不可以被序列化。

append()方法

---

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

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

可见，StringBuffer和StringBuilder一样，重写AbstractStringBuilder父类的append()方法，内部实现调用父类的append()方法，并重载了许多append()方法。唯一不同的是，StringBuffer每次修改数据，char[]数组toStringCache都会设置为空，而且，StringBuffer每个方法前面都加上synchronized关键字。当多个线程访问这个方法时，一个线程在访问这个方法，其它线程就会被锁住，无法访问这个方法，只有当这个线程执行完这个方法，释放锁，其它线程才能访问这个方法，所以StringBuffer是线程安全。

toString()方法

---

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

String(char[] value, boolean share) {
	// assert share : "unshared not supported";
	this.value = value;
}

StringBuffer的toString()方法和StringBuilder也是不一样的。如果toStringCache为null，则先缓存，最终返回一个String对象。StringBuffer的new String()内部没有调用Arrays的copyOfRange()方法，只是简单的数组赋值（浅拷贝），节省复制元素的时间。

总结

---

• String是不可变的字符串，StringBuffer和StringBuilder是可变的字符串。
• StringBuilder是线程不安全，速度快，StringBuffer是线程安全，速度慢。
• StringBuilder和StringBuffer的大部分方法均调用父类AbstractStringBuilder的实现。其扩容机制首先是把容量变为原来容量的2倍加2。最大容量是Integer的最大值（0x7fffffff）减去8。
• StringBuilder和StringBuffer的默认容量都是16，可以在创建StringBuffer和StringBuilder的时候指定大小，这样就避免了在容量不够的时候自动增长，以提高性能。