对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, 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;
}
编译器间报错，编译器不允许我把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引用始终指向同一个对象，在反射前后，这个对象被改变了，也就是通过反射可以修改所谓的“不可变”对象。