Java中的不可变类

什么叫不可变类？

《Effective Java》将不可变类定义如下：

An immutable class is simply a class whose instances cannot be modified. All of the information contained in each instance is provided when it is created and is fixed for the lifetime of the object.

翻译过来就是：

不可变类只是其实例不能被修改的类，每个实例中包含的所有信息都必须在创建该实例的时候就提供，并在对象的整个生命周期内固定不变。

如何创建一个不可变类？

要创建不可变类，只要遵循下面几条规则：

1. 不要提供任何会修改对象状态的方法。

2. 保证类不会被拓展（一般声明为final即可）。

3. 使所有的域都是 private final的。

4. 确保对于任何可变组件的互斥访问（可以理解如果中存在可变对象的域，得确保客户端无法获得其引用，并且不要使用客户端提供的对象来初始化这样的域）。

Java出于安全性等因素考虑将某些类如：String、基本类型的包装类、BigInteger、BigDecimal设计成为不可变类。

不可变类真的不能改变吗？

Java中的这些不可变类真的不能改变吗？我们不妨看下面的例子：

import java.lang.reflect.Field;

public class ChangeDemo {
public static void change(String str) {
if (null == str)
return;
try {
Field f = String.class.getDeclaredField("value");
f.setAccessible(true);
char[] value_str = (char[]) f.get(str);
value_str[0] = 'h';
} catch (Exception e) {
e.printStackTrace();
}
}

public static void change(Integer num) {
if (null == num)
return;
try {
Field f = Integer.class.getDeclaredField("value");
f.setAccessible(true);
int value = (int) f.get(num);
f.set(num, value * 10);
} catch (Exception e) {
e.printStackTrace();
}
}

public static void main(String[] args) {
String a = "cat";
System.out.println("before:a=" + a);
change(a);
System.out.println("after   :a=" + a);
Integer num = 12;
System.out.println("before:num=" + num);
change(num);
System.out.println("after   :num=" + num);
}
}

输出：

before:a=cat

after :a=hat

before:num=12

after :num=120

我们看到String、Integer这些不可变类都被改变了。但是不推荐大家这么干，这样会带来极大的安全隐患。

暴力反射修改不可变类带来的安全隐患

例如：

import java.lang.reflect.Field;

public class ChangeDemo {
public static void change(String str) {
if (null == str)
return;
try {
Field f = String.class.getDeclaredField("value");
f.setAccessible(true);
char[] value_str = (char[]) f.get(str);
value_str[0] = 'h';
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
String a = "cat";
String b = "cat";
System.out.println("before:a=" + a + ",b=" + b);
change(a);
System.out.println("after   :a=" + a + ",b=" + b);
}
}

运行结果如下：

before:a=cat,b=cat

after :a=hat,b=hat

我们惊奇地发现虽然我们只希望改变a的值，但是b的值居然也被改变了。了解Java运行时内存结构的朋友应该知道，main方法中的a,b本身保存在main方法对应的栈帧的局部变量表中，它们是方法区常量池中”cat”的引用，change方法中的局部变量通过引用使用暴力反射改变了常量池中“cat”的内容，这直接导致了“cat”所有的引用的都带来了安全隐患。

当然，这个例子比较明显，那下面的例子您能够看出问题吗？

import java.lang.reflect.Field;

public class UnsafeChangeDemo {

public static void main(String[] args)
throws Exception {
Integer a = 1;
Integer b = 2;
System.out.println("before:a = " + a + ", b = " + b);
swap(a, b);
System.out.println(" after  :a = " + a + ", b = " + b);
}

public static void swap(Integer a, Integer b) throws Exception {
Field valueField = Integer.class.getDeclaredField("value");
valueField.setAccessible(true);
int aValue = (int) valueField.get(a);
int bValue = (int) valueField.get(b);
valueField.set(a, bValue);
valueField.set(b, aValue);
}

}

咋一看，这很简单啊，不过就是通过暴力反射修交换Integer的值而言啊，真的这么简单吗？请看运行结果

before:a = 1, b = 2

after :a = 2, b = 2

嗯？有没有搞错，怎么交换后a,b全部变成2了？问题在哪里？

我们来分析一下：

我们都知道，JDK1.5后提供了自动装拆箱的功能，其中Integer的自动装箱是通过调用Integer.valueOf(int)方法来实现的，我们不妨看一下源码：

public static Integer valueOf(int i) {
assert IntegerCache.high >= 127;
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];//即为 IntegerCache.cache[i + 128 ];
return new Integer(i);
}

在swap方法中，先通过Field的 get(Object)方法获取了a,b的值，然后通set(Object,Object)方法交叉赋值以达到交换a,b的目的。

但是set方法的参数是两个Object，所以这里将会触发自动装箱，了解Integer的朋友都知道（如果不清楚可以参考博主的博客Java基本数据类型及其封装器的一些千丝万缕的纠葛 ）Integer内部默认提供了一个缓存数组static final Integer cache[256];来缓存-128~127的Integer对象。所以swap方法其中语句其实是这样的：

public static void swap(Integer a, Integer b) throws Exception {
Field valueField = Integer.class.getDeclaredField("value");
valueField.setAccessible(true);
int aValue = (int) valueField.get(a);//1
int bValue = (int) valueField.get(b);//2
// 自动装箱  valueField.set(a, Integer.valueOf(2) );
//即 valueField.set(a, IntegerCache.cache[130] );
valueField.set(a, bValue);
// 自动装箱 valueField.set(b, Integer.valueOf(1));
//即valueField.set(b, IntegerCache.cache[129] );
valueField.set(b, aValue);
}

调用valueField.set(a, bValue);方法，将2赋给了a,由于a是IntegerCache.cache[129]的一个引用，所以实际上是将2赋值给了IntegerCache.cache[129]。因此经过这个方法调用后，a由1变成了2，同时，IntegerCache.cache[129]也由1变成了2 ！！

在调用valueField.set(b, aValue)时，本希望将1赋给b，但由于自动装箱，其实上是将IntegerCache.cache[129] 的值赋值给b,然而IntegerCache.cache[129] 的值已经由1变成了2，所以，b仍然等于2！！！交换失败！！

好吧，一图胜千言，程序的运行时内存结构图如下：



完整的解析如下：

public static void main(String[] args) throws Exception {
Integer a = 1;// 自动装箱  Integer.valueOf(1);
//即 IntegerCache.cache[129]
Integer b = 2;// 自动装箱 Integer.valueOf(2);
//即 IntegerCache.cache[130]
swap(a, b);
System.out.println(a + "," + b);
}
public static void swap(Integer a, Integer b) throws Exception {
Field valueField = Integer.class.getDeclaredField("value");
valueField.setAccessible(true);
int aValue = (int) valueField.get(a);//1
int bValue = (int) valueField.get(b);//2
// 自动装箱  valueField.set(a, Integer.valueOf(2) );
// 即 valueField.set(a, IntegerCache.cache[130]）;
valueField.set(a, bValue);
//a 的值被修改为 2 实际上是 IntegerCache.cache[129]的值被修改为 2
// 再次自动装箱 valueField.set(b, Integer.valueOf(1));
// 即valueField.set(b, IntegerCache.cache[129] );
valueField.set(b, aValue);
//注意，这里的 IntegerCache.cache[129] 已经被修改为 2了！！
//所以 valueField.set(b, aValue); 相当于是 valueField.set(b, new Integer(2));
//所以最后a,b都为2！！
}

我的天，是不是感觉很绕呢？所以不到万不得已，一定不要通过暴力反射来修改不可变类的状态！！