利用数组作为缓存池实现对象的缓存

首先在此介绍不可变类的概念，不可变类是指创建了该类的实例以后，该实例的实例变量是不可改变的。在Java中，常见的不可变类有8个基本类型的包装类，以及String类。不可变类的实例状态不可改变，可以很方便地被多个对象所共享。

在日常的工作，如果我们需要使用相同的不可变类实例，那么反复的创建将会加大系统的开销，因此我们可以缓存需要经常用到的对象，以此来节省因重复创建而带来的系统开销。缓存是软件中经常用到的一个模式，缓存的方式有很多种，不同的实现方式可能会存在比较大的性能差别，本次将以数组作为缓存池，实现一个缓存实例的不可变类。

看下面的例子：

/**
 * 利用数组作为缓存池实现对象的缓存
 * Created by Administrator on 2015/1/31 0031.
 */
class CacheImmutale {
    private static final int MAX_SIZE = 10;
    private static CacheImmutale[] cacheImmutales = new CacheImmutale[MAX_SIZE];
    private static int pos = 0;
    private final String name;
    public CacheImmutale(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }

    /**
     * 从该方法中得到对象，并且使用数组作为缓存池，
     * 缓存之前生成的对象，假如有相同的对象，
     * 那么直接从数组中获取该对象并返回
     * @param name
     * @return
     */
    public static CacheImmutale valueOf(String name){
        //如果数组中有缓存好的对象，那么直接在缓存池中取出并返回
        for(int i =0;i<MAX_SIZE;i++){
            if(cacheImmutales[i] != null && cacheImmutales[i].getName().equals(name)){
                return cacheImmutales[i];
            }
        }
        /*
        如果缓存池存满，把最初存进来的对象替换掉
        把pos设置为1，下次的存储从1开始，并且在取对象的时候可以pos-1找到下标
         */
        if(pos == MAX_SIZE){
            cacheImmutales[0] = new CacheImmutale(name);
            pos = 1;
        }else{
            cacheImmutales[pos++] = new CacheImmutale(name);
        }
        return cacheImmutales[pos – 1];
    }

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

    @Override
    public int hashCode() {
        return name.hashCode();
    }
}

public class CacheImmutaleTest{
    public static void main(String[] args){
        CacheImmutale c1 = CacheImmutale.valueOf(“hello”);
        CacheImmutale c2 = CacheImmutale.valueOf(“hello”);
        CacheImmutale c3 = new CacheImmutale(“hello”);
        CacheImmutale c4 = new CacheImmutale(“hello”);
        //c1和c2是缓存池中的同一个对象，因此相等
        System.out.println(c1 == c2);
        //重写了equals方法，因此c3和c4的equals方法对比也相等
        System.out.println(c3.equals(c4));
        //但是c3和c4指向的不是同一个对象，因此返回false
        System.out.println(c3 == c4);
    }
}

输出结果是：
true
true
false

摘自《疯狂Java讲义》