对String不可变的理解

一直有写博客的打算，由于种种原因没有开始，今天在公司正好讨论到了String这个特殊的类，准备开启自己的博客之旅。
作为Java语言中应用最广泛的String类，也可以算得上是最特殊的一个类，我们非常有必要深入了解它。
在《Thinking in java》第四版中有提到，“String类中每一个看起来会修改String值的方法，实际上都是创建了一个全新的String对象，以包含修改后的字符串内容。而最初的String对象则丝毫未动。”
我们来看一下最常见的String方法replace（char oldChar， char newChar）。

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

在源码中我们可以很明显的看到replace方法调用之后返回的是一个新的String对象，也就是原来的String对象根本没有改变。
我们可以做一个小测试。

public static void main(String[] args) {

    String a = "abc";

    StringBuilder sb = new StringBuilder("ccc");

    System.out.println(new Test1().test(a));

    System.out.println(a);

    System.out.println(new Test1().test2(sb));

    System.out.println(sb);
}

//不可变的String
public String test(String a) {
    a += "bb";
    return a;
}

//可变的StringBuilder
public StringBuilder test2(StringBuilder sb) {

    return sb.append("xx");
}/* Output
abcbb
abc
cccxx
cccxx
*/

通过对比我们可以发现原来的String对象并没有发生改变，返回的是一个新的String对象，而可变的StringBuilder在进行方法调用之后，原来的对象已经发生了改变。
翻开JDK源码。

public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
/** The value is used for character storage. */
private final char value[];

/** Cache the hash code for the string */
private int hash; // Default to 0
...
}

首先Strng类用final修饰，说明无法继承String。再看下面String类的主成员字段是一个value字符数组，用final修饰，不可改变。不过虽然不能改变，也只是无法改变value这个引用地址。指向的内容依然是可以改变的。除此之外还有一个hash变量，是该String对象的哈希值缓存。看一下例子，

public static void main(String[] args) {

    final char value[] = { 'a', 'b', 'c' };

    char another[] = { 'e', 'f', 'g' };

    value = another;
} /*The final local variable value cannot be assigned. It must be blank and not using a compound assignment*/

编译器间报错，编译器不允许我把value的引用指向heap内存中另外的地址。不过只要改变数组元素，就可以搞定。

public static void main(String[] args) {

    final char value[] = { 'a', 'b', 'c' };

    value[0] = 'b';

    System.out.println(value);
}/* Output：
bbc
*/

value字符数组内容已经被改变了。
所以String不可变，其实是因为String方法没有动value数组的元素，没有暴露内部成员字段。String被final修饰，也导致整个String无法被继承，不被破坏。
其实研究到这里，脑海中已经有了一个大胆的想法，虽然value数组引用没有暴露，通过一般途径无法获取到，不过我们大可以用反射来访问私有成员。

public static void testReflection() throws Exception {

    //创建字符串"Hello World"， 并赋给引用s
    String s = "Hello World"; 

    System.out.println("s = " + s); //Hello World

    //获取String类中的value字段
    Field valueFieldOfString = String.class.getDeclaredField("value");

    //改变value属性的访问权限
    valueFieldOfString.setAccessible(true);

    //获取s对象上的value属性的值
    char[] value = (char[])valueFieldOfString.get(s);

    //改变value所引用的数组中的第5个字符
    value[5] = '_';

    System.out.println("s = " + s);  //Hello_World
}

在这个过程中s引用始终指向同一个对象，在反射前后，这个对象被改变了，也就是通过反射可以修改所谓的“不可变”对象。