String，StringBuilder，StringBuffer区别

一、String，StringBuilder，StringBuffer的大概了解

大家知道String，StringBuilder，StringBuffer三个的基本应用场景。

• String会一直创建新对象，因此频繁创建对象的场景不适合用。
• StringBuilder则可以避免这个情况，因此频繁对字符串操作的场景使用StringBuilder比较合适。
• 但是StringBuilder并不是线程安全的，如果要线程安全，需要使用StringBuffer。

二、为什么String会一直创建新对象？

    private final char value[];

• String代码中，字符是存在一个 final 的 char value[]里面的。
• 由于final指定了存储的内从是固定的，因此如果有append之类的操作的话要重新开辟新的内存。
• 要注意的是即使 value[]是final的，它也是可以改变里面的内容的。

下面这写法是正确的。不会报错。

final char[] ss = {'a', 'b', 'c'};
ss[0] = 'b';
ss[1] = 'c';

但是String类并没有提供这么一个接口能直接修改value数组。其中的replace是返回了一个新的String 对象。并不是在原先的数组上进行修改。

public String replace(char oldChar, char newChar) {
        if (oldChar != newChar) {
            int len = value.length;
            int i = -1;
            char[] val = value; /* avoid getfield opcode */

            while (++i < len) {
                if (val[i] == oldChar) {
                    break;
                }
            }
            if (i < len) {
                char buf[] = new char[len];
                for (int j = 0; j < i; j++) {
                    buf[j] = val[j];
                }
                while (i < len) {
                    char c = val[i];
                    buf[i] = (c == oldChar) ? newChar : c;
                    i++;
                }
                return new String(buf, true);
            }
        }
        return this;
    }

三、StringBuilder中的主要内容

这个类继承了AbstractStringBuilder。AbstractStringBuilder里面封装了大部分内容。初始化大小为16个字符。

1、相比较String中的value，这个不是final 类型的。

char[] value;

2、newCapacity方法。

• 将原始的capacity*2+2
• 判断新的容量是不是合法
• 最大容量不会超过MAX_ARRAY_SIZE。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;
    }

3、append方法

其实最终调用了System.arrayCopy将append中的String value copy到了StringBuilder 中的 value。

public AbstractStringBuilder append(StringBuffer sb) {
        if (sb == null)
            return appendNull();
        int len = sb.length();
        ensureCapacityInternal(count + len);
        sb.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);
    }

四、StringBuffer中的主要内容

这个类同样继承了AbstractStringBuilder。

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

但是几乎所有的方法都加了同步。因此是线程安全的。

1、append

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

2、chartAt

@Override
    public synchronized char charAt(int index) {
        if ((index < 0) || (index >= count))
            throw new StringIndexOutOfBoundsException(index);
        return value[index];
    }

其中StringBuffer里面有个 char [] toStringCache。当调用toString的时候，这个就会缓存StringBuffer的内容。当对StringBuffer有修改的时候，这个数组就会设定为null。

    private transient char[] toStringCache;