不可变类

不可变类

• 不可变类就是创建该类的实例后，该实例的实例变量是不可改变的。
• Java提供的8个包装类和java.lang.String类都是不可变类。

创建自定义的不可变类，可遵循如下规则：

1. 使用private和final修饰成员变量
2. 提供带参数的构造器，根据参数来初始化成员变量
3. 仅提供getter方法，不提供setter方法
4. 如果有必要，重写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);
    }
}