Java中String不可变性以及通过反射进行修改

Java中 String 类时不可变的。但刚开始一直不清楚不可变是什么意思。看到这篇文章

区分对象和对象引用

String s = "abc";  
System.out.println("s = " + s);  

s = "123";  
System.out.println("s = " + s);  

输出结果是:

s=abc;
s=123;

其实这里 s 只是String 对象的引用，并不是对象本身。”abc” 的值是不可以改变的。无法像 StringBuilder 那样通过append 来改变本身的内容。
而在 String 中的一些方法内，replace，toLowerCase等等方法返回的也是一个新的对象。
比较这两段代码：
1，

String a = "abc";  
System.out.print("a = " + a);  
a = a.replace('a', 'b');  
System.out.print("a = " + a);  

2，

String a = "abc";  
System.out.print("a = " + a);  
a.replace('a', 'b');  
System.out.print("a = " + a);  

第一段输出a="abc" a="bbc" 第二段输出a="abc" a="abc" 因为修改的并不是原来的对象。

为什么String对象是不可变的

jdk1.6 中 String 类中的成员变量：

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

    /** The offset is the first index of the storage that is used. */  
    private final int offset;  

    /** The count is the number of characters in the String. */  
    private final int count;  

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

jdk1.7 中去掉了offset 和 count 。
由以上的代码可以看出， 在Java中String类其实就是对字符数组的封装。value[] 是String封装的数组。

jdk1.6 中，value，offset和count这三个变量都是 private 的 ，并且没有提供setValue， setOffset和setCount等公共方法来修改这些值，所以在String类的外部无法修改 String 。也就是说一旦初始化就不能修改， 并且在String类的外部不能访问这三个成员。此外，value，offset和count这三个变量都是 final 的 ， 也就是说在String类内部，一旦这三个值初始化了， 也不能被改变。所以可以认为String对象是不可变的了。

通过反射改变String 对象

String s1 = "Hello World";  
String s2 = "Hello World";  
String s3 = s1.substring(6);  
System.out.println(s1); // Hello World  
System.out.println(s2); // Hello World  
System.out.println(s3); // World  

//获取String 类中的value字段
Field field = String.class.getDeclaredField("value");  
//改变 value 的访问属性
field.setAccessible(true);  
//获取s1对象上的value属性的值
char[] value = (char[])field.get(s1);  
value[6] = 'J';  
value[7] = 'a';  
value[8] = 'v';  
value[9] = 'a';  
value[10] = '!';  

System.out.println(s1); // Hello Java!  
System.out.println(s2); // Hello Java!  
System.out.println(s3); // World 

上面输出可以看到，虽然无法通过调用公有方法访问到value引用，更不能通过这个引用去修改数组，改变String的值。但是利用反射机制，反射出String对象中的value属性，进而改变通过获得的 value 引用改变数组的结构。

s1,s2 指向的是常量池中同一个对象，String 的 subString() 方法:

 public String substring(int beginIndex) {
        if (beginIndex < 0) {
            throw new StringIndexOutOfBoundsException(beginIndex);
        }
        int subLen = value.length - beginIndex;
        if (subLen < 0) {
            throw new StringIndexOutOfBoundsException(subLen);
        }
        return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
    }

可以看到起始位置不是 0 的时候，返回的是重新 new一个String ，因此 s3 指向的与s1,s2不同（JDK6 中的话还是指向同一个value 数组，应该输出的是java!）。修改 s1 不会影响到 s3

这里 Reflection Madness 的例子：

    public static void main(String[] args) throws Exception {
        Field field = String.class.getDeclaredField("value");
        field.setAccessible(true);
        field.set("hello!", "cheers".toCharArray());
        System.out.println("hello!");
    }
    //cheers

一旦你获取了Field对象的引用，你可以像这样通过Field.get()方法和Field.set()方法get/set字段的值：

Class  aClass = MyObject.class
Field field = aClass.getField("someField");
MyObject objectInstance = new MyObject();
Object value = field.get(objectInstance);
field.set(objetInstance, value);

因此 field.set(“hello!”, “cheers”.toCharArray()) 和 System.out.println(“hello!”)中字符串”hello!”其实是同一个对象，利用反射机制改变这个对象的value值，因此此时字符串”hello!”对应的value其实已经变成了”cheers”。

Java 中Integer 自动装箱时[-128,127] 数值引用的是缓存池中的对象。因此通过反射机制也可以修改他们的值。

             Field field = Integer.class.getDeclaredField("value");
             field.setAccessible(true);
             field.set(42, 43);
             field.set(190, 120);
             //自动装箱
             System.out.println(Integer.valueOf(42));
             System.out.println(Integer.valueOf(190));
             //这里 42 是数值，不是Integer 包装对象，不会被修改
             System.out.println(42);
             //43
             //190
             //42

参考：
http://blog.youkuaiyun.com/zhangjg_blog/article/details/18319521#comments；
http://www.javaspecialists.eu/talks/oslo09/ReflectionMadness.pdf；
http://krystism.is-programmer.com/posts/42918.html；
http://stackoverflow.com/questions/20945049/is-a-java-string-really-immutable