初始Java简单缓存实例

初始Java简单缓存实例

​ 缓存在很多场景下都是需要使用的。比如在需要一个值的过程和代价特别高的情况下，而且对这个值的需要不止一次的情况下，我们可能就需要考虑使用缓存了。

代码展示

​ 接下来让我们简单用数组实现缓存实例对象。

package Test;
class Student{                        //声明Student类
    private String name;
    private int age;
    Student(String name,int age){       //Student类的构造器
        this.name=name;
        this.age=age;
    }
    public String getName(){           //用于访问类属性的访问器
        return name;
    }
    @Override
    public String toString(){            //重写Object类的toString方法
        return this.name+"的年龄是:"+this.age;
    }
    @Override
  public boolean equals(Object obj){ //重写Object类的equals方法，用于判断两个Student对象是否相等
        if(obj==this)
            return true;
        if(obj!=null && obj.getClass()==Student.class){
            Student student = (Student) obj;
            if(this.getName().equals(student.getName())){
                return true;
            }
        }
        return false;
    }
}
class StudentCache{              //用于缓存Student的类
    private static int MAX_VALUE=10;    //数组的最大空间
    private static StudentCache[] cache = new StudentCache[MAX_VALUE];  //用于缓存的数组
    private static int pos = 0;
    private final Student stu;
    private StudentCache(Student stu){     //定义缓存类的构造器
        this.stu=stu;
    }
    public Student getStudent(){
        return stu;
    }
    public static StudentCache valueof(Student stu){   //用于查找与存储Student的实例对象
        for(int i =0;i<MAX_VALUE;i++){
         if(cache[i]!=null&&cache[i].getStudent().equals(stu)){ //判断数组中是否已存在同一对象
                return cache[i];
            }
        }
        if(pos==MAX_VALUE){    //判断缓存的实例对象是否已经超过了缓存最大值
            cache[0]=new StudentCache(stu);
            pos=1;
        }
        else{
            cache[pos++]=new StudentCache(stu);  //往缓存数组中添加数据
        }
        return cache[pos-1];
    }
}
public class Demo1 {        //测试类
    public static void main(String[] args) {
        Student s1 = new Student("张三",12);
        Student s2 = new Student("张三",20);
        StudentCache v1 = StudentCache.valueof(s1);
        StudentCache v2 = StudentCache.valueof(s2);
        System.out.println(v1==v2);
        System.out.println(v1.getStudent().toString());
        System.out.println(v2.getStudent().toString());
    }
}
/*
输出结果：
true
张三的年龄是:12
张三的年龄是:12
*/

结果分析

• 问：为什么“==”判断时会输出true
• 答：当“==”作用于两个引用类型数据，只有他们引用同一对象时，才会返回true。
• 问：为什么v1与v2会引用同一对象呢
• 答：当v1存储时，缓存数组中还没有元素，所以会把数据保存在cache[0]中，当v2存储时，会检查缓存数组，这时发现数组中存有v1，而这两个对象“姓名”相同，“年龄”不同，而我们重写了equals方法，并且规定当“姓名”时，就可以认为这两个数组相同，所以，直接将v2引用变量指向v1指向的内容。

Integer中的缓存

在Integer中同样存在缓存机制。

package Test;

public class Demo2 {
    public static void main(String[] args) {
        Integer i1 = new Integer(6);
        Integer i2 = new Integer(6);
        Integer j1 = Integer.valueOf(6);
        Integer j2 = Integer.valueOf(6);
        System.out.println(i1==i2);
        System.out.println(j1==j2);
    }
}
/*
结果输出：
false
true
*/

结果发现：

当采用valueof()方法创建对象时，会采用缓存的方法创建对象。