浅谈关于String，StringBuilder，StringBuffer的区别

由上一篇我们知道，String是不能被继承，且char[] value也是被final修饰的，那也就意味着value是不可变数组，长度定义多少就是多少，不能扩容，只能初始化一次，但实际工作中难免有对字符串进行必要的操作，每次对字符串的操作并不是对原字符串的操作，而是在常量池中创建了新的字符串对象，再把原来的地址引用到该字符串上，不仅操作繁琐，且严重占用内存。

以String中substring()方法为例：

如果beginIndex=0则返回原串，否则创建一个新的字符串返回。

StringBuilder：

内部可变数组，存在初始化StringBuilder对象中字符数组容量为16，存在扩容。

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

1.无参构造方法：

public StringBuilder() {
    super(capacity:16);        //调用父类的构造方法，默认数组的大小为16
}

父类的构造方法：

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

2.自定义初始容量 - - 构造函数

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

3.以字符串String 作为参数的构造：

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

在参数Str 数组长度的基础上再增加16个字符长度，作为StringBuilder实例的初始数组容量，并将str字符串 append到StringBuilder的数组中。

@Override
public StringBuilder append(String str) {
    super.append(str);   //调用的是父类的append()方法
    return this;
}

父类的append方法：

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;
}

其中的getChars()方法：

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);   // System的arraycopy方法
}

ensureCapacityInternal方法是确保这次append 的时候StringBuilder的内部数组容量是满足的：

private void ensureCapacityInternal(int minimumCapacity) {
    // overflow-conscious code
    if (minimumCapacity - value.length > 0)  //超过当前数组容量了，就扩容
        expandCapacity(minimumCapacity);
}

void expandCapacity(int minimumCapacity) {   
    int newCapacity = value.length * 2 + 2;    //在原来的数组的基础上进行扩容
    if (newCapacity - minimumCapacity < 0)
        newCapacity = minimumCapacity;
    if (newCapacity < 0) {
        if (minimumCapacity < 0) // overflow
            throw new OutOfMemoryError();
        newCapacity = Integer.MAX_VALUE;
    }
    value = Arrays.copyOf(value, newCapacity);
}

以上就是StringBuilder的拼接字符串的原理分析，可以发现没有像String一样去重新创建 对象，所以在频繁的拼接字符上，StringBuilder的效率远远高于String类。
StringBuilder 类内部维护可变长度char[] ， 初始化数组容量为16，存在扩容， 其append拼接字符串方法内部调用System的arraycopy方法，进行数组的拷贝，不会重新生成新的StringBuilder对象。

StringBuffer：

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

跟StringBuilder继承的一样；

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

这里就是在append方法上加了同步锁，来实现多线程下操作数据的安全。其他的和StringBuilder一致。

欢迎留言讨论，感谢你的关注！