不可变类
- 不可变类就是创建该类的实例后,该实例的实例变量是不可改变的。
- Java提供的8个包装类和java.lang.String类都是不可变类。
创建自定义的不可变类,可遵循如下规则:
- 使用private和final修饰成员变量
- 提供带参数的构造器,根据参数来初始化成员变量
- 仅提供getter方法,不提供setter方法
- 如果有必要,重写hashCode和equals方法(equals方法有根据成员变量来作为判断两个对象是否相等的标准)
- 创建不可变类时,该类的成员变量的类型也必须是不可变的。
- 不可变类的实例状态不可改变,可以很方便地被多个对象所共享,
- 如果程序经常使用相同的不可变类实例,则应当将创建的不可变类的实例进行缓存。见CacheImmutableTest类
Java提供的java.lang.Integer类采用了与CacheImmutable类相同的处理策略。如果new构造器来创建Integer
对象,则每次返回全新的Integer对象;如果采用valueOf方法来创建Integer对象,则会缓存该方法创建的对象。
public class IntegerCacheTest {
public static void main(String[] args) {
// 生成新的Integer对象
Integer in1 = new Integer(6);
// 生成新的Integer对象,并缓存该对象
Integer in2 = Integer.valueOf(6);
// 直接从缓存中取出Ineger对象
Integer in3 = Integer.valueOf(6);
System.out.println(in1 == in2); // 输出false
System.out.println(in2 == in3); // 输出true
// 由于Integer只缓存-128~127之间的值,
// 因此200对应的Integer对象没有被缓存。
Integer in4 = Integer.valueOf(200);
Integer in5 = Integer.valueOf(200);
System.out.println(in4 == in5); //输出false
}
}
- 两次通过valueOf方法生成的Integer是同一个对象,由于Integer只缓存-128~127之间的Integer对象,因此两次通过valueOf(200)方法生成的Integer对象不是同一个对象。
附:CacheImmutableTest类
class CacheImmutale {
private static int MAX_SIZE = 10;
// 使用数组来缓存已有的实例
private static CacheImmutale[] cache = new CacheImmutale[MAX_SIZE];
// 记录缓存实例在缓存中的位置,cache[pos-1]是最新缓存的实例
private static int pos = 0;
private final String name;
private CacheImmutale(String name) {
this.name = name;
}
public String getName() {
return name;
}
public static CacheImmutale valueOf(String name) {
// 遍历已缓存的对象,
for (int i = 0; i < MAX_SIZE; i++) {
// 如果已有相同实例,直接返回该缓存的实例
if (cache[i] != null && cache[i].getName().equals(name)) {
return cache[i];
}
}
// 如果缓存池已满
if (pos == MAX_SIZE) {
// 把缓存的第一个对象覆盖,即把刚刚生成的对象放在缓存池的最开始位置。
cache[0] = new CacheImmutale(name);
// 把pos设为1
pos = 1;
} else {
// 把新创建的对象缓存起来,pos加1
cache[pos++] = new CacheImmutale(name);
}
return cache[pos - 1];
}
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj != null && obj.getClass() == CacheImmutale.class) {
CacheImmutale ci = (CacheImmutale) obj;
return name.equals(ci.getName());
}
return false;
}
public int hashCode() {
return name.hashCode();
}
}
/**
* CacheImmutable类采用一个数组来缓存该类的对象,数组长度为MAX_SIZE,即该类可以缓存这么多个CacheImmutable
* 对象,当缓存池已满时,缓存池采用“先进先出”规则来决定哪个对象被移出缓存池。CacheImmutable类能控制系统生成
* CacheImmutable对象的个数,需要程序使用该类的valueOf方法来得到其对象,而且程序使用private修饰符隐藏该类的
* 构造器,因此程序只能通过该类提供的valueOf方法来获取实例。
*/
public class CacheImmutaleTest {
public static void main(String[] args) {
CacheImmutale c1 = CacheImmutale.valueOf("hello");
CacheImmutale c2 = CacheImmutale.valueOf("hello");
// 下面代码将输出true
System.out.println(c1 == c2);
}
}