Java的不可变类（缓存实例）

不可变类

不可变类的意思是在创建该类的实例后，该实例的实例变量是不可以改变的。Java提java.lang.String类都是不可变类，当创建它们的实例后，实例的实例变量也是不可改变的。

如：

Double d = new Double(2.2);
String str = new String("cuzz");

如果需要创建一个自定义的不可变类，应具备以下几个规则

• 使用private和final修饰符来修饰该类的成员变量
• 提供带参数的构造器，用于根据传入参数来初始化类里的成员变量
• 提供getter方法，不需要setter方法

下面定义一个不可变Adress类，程序把Address类的detail和postCode成员变量都使用private隐藏起来，并使用final修饰这两个成员变量，不允许其他方法修改这两个成员变量的值

public class Address {
    private final String detail;
    private final String postCode;
    // 在构造器里初始化两个实例变量
    public Address() {
        this.detail = "";
        this.postCode = "";
    }
    
    public Address(String detail, String postCode) {
        this.detail = detail;
        this.postCode = postCode;
    }
    
    // 仅为两个实例变量提供getter方法
    public String getDetail() {
        return this.detail;
    }
    
    public String getPostCode() {
        return this.postCode;
    }
    
    // 重新equeal方法
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        
        if (obj != null && obj.getClass() == Address.class) {
            Address address = (Address) obj;
            // 当detail和postCode同时相等时
            if (address.detail == detail && address.postCode == postCode) {
                return true;
            }
        }
        return false;
    }
    
    public int hashCode() {
        return detail.hashCode() + postCode.hashCode() * 31;
    }
}

缓存实例的不可变类

不可变类的实例状态不可以改变，可以很方便的被多个对象所共享，如果程序经常需要使用相同的不可变实例，可以考虑缓存这种不可变的实例。

public class CacheImmutable {
    private static int MAX_SIZE = 10;
    // 使用数组来缓存已有的实例
    private static CacheImmutable[] cache = new CacheImmutable[MAX_SIZE];
    // 记录缓存实例在缓存的位置   cache[pos-1]是最新的实例
    private static int pos = 0;
    private final String name;
    
    private CacheImmutable(String name) {
        this.name = name;
    }
    
    private String getName() {
        return name;
    }
    
    public static CacheImmutable 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) {
            // 把缓存的第一个对象覆盖  把刚刚生成的对象放在缓存池最开始
            pos = 0;
            cache[pos++] = new CacheImmutable(name);
        }else {
            cache[pos++] = new CacheImmutable(name);
        }
        return cache[pos-1];
        

    }
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj != null && obj.getClass() == CacheImmutable.class) {
            CacheImmutable ci = (CacheImmutable) obj;
            return name.equals(ci.getName());
        }
        return false;
    }
}

测试类：

public class CacheImmutableTest {
    public static void main(String[] args) {
        CacheImmutable c1 = CacheImmutable.valueOf("cuzz");
        CacheImmutable c2 = CacheImmutable.valueOf("cuzz");
        System.out.println(c1 == c2 );   // 输出true
    }
}

与Java提供的java.lang.Integer类采用的相同的策略

public class IntegerCacheTest {
    public static void main(String[] args) {
        // 生成新的Integer对象
        Integer in1 = new Integer(6);
        // 生成新的Integer对象  并缓存该对象
        Integer in2 = Integer.valueOf(6);
        // 直接从缓存中取出Integer对象
        Integer in3 = Integer.valueOf(6);
        System.out.println(in1 == in2);  // false
        System.out.println(in2 == in3);  // true
        // 由于Integer只缓存-128~127之间
        Integer in4 = Integer.valueOf(200);
        Integer in5 = Integer.valueOf(200);
        System.out.println(in4 == in5);   // false
    }
}