String的不可变性及StringBuilder原理

一、String的不可变性

关于String类型的具体分析，可以参考我另一篇博客第三小节的补充内容，有很详细的叙述。
String 对象的两种创建方式

 		  String str1 = "str";
		  String str2 = "ing";
		  
		  String str3 = "str" + "ing";//常量池中的对象
		  String str4 = str1 + str2; //在堆上创建的新的对象	  
		  String str5 = "string";//常量池中的对象
		  System.out.println(str3 == str4);    //false
		  System.out.println(str3 == str5);   //true
		  System.out.println(str4 == str5);   //false

拿过来其中的例子，可以简单看一下。

为什么将String设计成不可变类？

（1）字符串常量池的需要

字符串常量池(String pool, String intern pool, String保留池) 是Java堆内存中一个特殊的存储区域, 当创建一个String对象时,假如此字符串值已经存在于常量池中,则不会创建一个新的对象,而是引用已经存在的对象。
如下面的代码所示,将会在堆内存中只创建一个实际String对象.

String s1 = "abcd";  
String s2 = "abcd"; 

假若字符串对象允许改变,那么将会导致各种逻辑错误,比如改变一个对象会影响到另一个独立对象. 严格来说，这种常量池的思想,是一种优化手段.

（2）允许String对象缓存HashCode

Java中String对象的哈希码被频繁地使用, 比如在hashMap 等容器中。
字符串不变性保证了hash码的唯一性,因此可以放心地进行缓存.这也是一种性能优化手段,意味着不必每次都去计算新的哈希码. 在String类的定义中有如下代码:

private int hash;//用来缓存HashCode  

（3）安全性

String被许多的Java类(库)用来当做参数,例如 网络连接地址URL,文件路径path,还有反射机制所需要的String参数等, 假若String不是固定不变的,将会引起各种安全隐患。例如你想加载java.sql.Connection类，而这个值被改成了myhacked.Connection，那么会对你的数据库造成不可知的破坏。

String类设置为不可变类的好处：

（1）提高Java字符串池（String Pool）的效率和安全性。当知道一个对象是不可变的，那么拷贝这个对象的内容时，就不用赋值它的本身而只是复制它的地址，复制地址需要很小的内存，效率也很高。
（2）不可变对象对于多线程是安全的，因为多线程的情况下，一个可变对象的值可能被其他进程改变，这样会造成不可预期的结果，而使用不可变对象就可以避免这种情况。

二、StringBuilder的实现原理

原理

StringBuilder类也封装了一个字符数组，定义如下：

char[] value;

与String不同，它不是final的，可以修改。另外，与String不同，字符数组中不一定所有位置都已经被使用，它有一个实例变量，表示数组中已经使用的字符个数，定义如下：

int count;

StringBuilder继承自AbstractStringBuilder，它的默认构造方法是：

public StringBuilder() {
    super(16);
}

调用父类的构造方法，父类对应的构造方法是：

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

也就是说，new StringBuilder()这句代码，内部会创建一个长度为16的字符数组，count的默认值为0。

append的实现

public AbstractStringBuilder append(String str) {
    if (str == null) str = "null";
    int len = str.length();
    ensureCapacityInternal(count + len);
    str.getChars(0, len, value, count);
    count += len;
    return this;
}

append会直接拷贝字符到内部的字符数组中，如果字符数组长度不够，会进行扩展，实际使用的长度用count体现。具体来说，ensureCapacityInternal(count+len)会确保数组的长度足以容纳新添加的字符，str.getChars会拷贝新添加的字符到字符数组中，count+=len会增加实际使用的长度。

ensureCapacityInternal的代码如下：

private void ensureCapacityInternal(int minimumCapacity) {
    // overflow-conscious code
    if (minimumCapacity - value.length > 0)
        expandCapacity(minimumCapacity);
}

如果字符数组的长度小于需要的长度，则调用expandCapacity进行扩展，expandCapacity的代码是：

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

扩展的逻辑是，分配一个足够长度的新数组，然后将原内容拷贝到这个新数组中，最后让内部的字符数组指向这个新数组，这个逻辑主要靠下面这句代码实现：

value = Arrays.copyOf(value, newCapacity);

toString实现

字符串构建完后，我们来看toString代码：

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

基于内部数组新建了一个String，注意，这个String构造方法不会直接用value数组，而会新建一个，以保证String的不可变性。