package final_test;
//缓存,对应理解包装类Integer
public class CacheImmutate {
private static int MAX_SIZE=3;
//使用数组来缓存已有的实例
private static CacheImmutate[] cache=new CacheImmutate[MAX_SIZE];
//记录缓存实例在缓存中的位置,cache[pos-1]是最新缓存的实例
private static int pos=0;
private final String name;
private CacheImmutate(String name) {
this.name=name;
}
public String getName() {
return this.name;
}
//静态方法 返回值是该对象 传参:字符串name
public static CacheImmutate valueOf(String name) {
//遍历已经缓存的对象
for(int i=0;i < cache.length;i++) {
//如果缓存中已有相同的实例,则直接返回该缓存的实例
if(cache[i] != null && cache[i].getName().equals(name)) {
return cache[i];
}
}
//下面是缓存中没有,就添加到缓存中,缓存满了就将最新的替换掉最旧的,最新的是cache[pos-1]
//如果缓存池已满,清空
if(pos == MAX_SIZE) {
//把缓存的第一个对象覆盖,即把刚刚生成的对象放在缓存池的最开始位置
cache[0] = new CacheImmutate(name);
pos=1;
System.out.println("缓存已满覆盖");
}
else {
cache[pos++] = new CacheImmutate(name);
System.out.println("缓存没有满,存入");
}
return cache[pos-1];
}
//重写equals方法
public boolean equals(Object obj) {
if(this == obj) {
return true;
}
if(obj != null && obj.getClass() == CacheImmutate.class) {
CacheImmutate ci=(CacheImmutate)obj;
return (name.equals(ci.getName()));
}
return false;
}
//重写hashcode方法
public int hashCode() {
return name.hashCode();
}
public static void main(String[] args) {
CacheImmutate c1=CacheImmutate.valueOf("hello1");
System.out.println(c1.getName());
CacheImmutate c2=CacheImmutate.valueOf("hello2");
System.out.println(c2.getName());
//这里缓存里面有,取得到,由于缓存也没有满,也没有清空,所以这里就是直接在缓存中取得的
CacheImmutate c7=CacheImmutate.valueOf("hello2");
System.out.println(c2 == c7);
CacheImmutate c3=CacheImmutate.valueOf("hello3");
System.out.println(c3.getName());
CacheImmutate c4=CacheImmutate.valueOf("hello4");
System.out.println(c4.getName());
CacheImmutate c5=CacheImmutate.valueOf("hello5");
System.out.println(c5.getName());
//由于缓存已经被清空,所以这里就不会从缓存中取得,取也取不到,就只能新建,与第一个地址就不同了
CacheImmutate c6=CacheImmutate.valueOf("hello1");
System.out.println(c1 == c6);
}
}
