1、不可变类的实例状态不可改变，可以被多个对象很方便的共享
2、如果程序经常使用某个不可变类的实例，那么把该实例保存近缓存是一个好的选择，不用每次都生成新的实例对象，消耗系统开销
如下代码实例：将创建的不可变类实例进行缓存
import static java.lang.System.*;
import java.util.Arrays;
class CacheImmutable{
//-定义缓存数组的长度，私有的，静态的，不可更改的
private static final int MAX_SIZE=3;
//-定义缓存数组，来缓存已有的实例，静态的，不可更改的，不变类的要素之一
private static final CacheImmutable[] cache = new CacheImmutable[MAX_SIZE];
//-记录缓存实例在缓存中的位置，cache[pos-1]是最新缓存进来的实例
private static int pos=0;
//-记录当前实例的name,不可更改的，每个实例的name都不同，所以不能是static修饰
private final String name;
//-获取当前实例的name,只设置获取getter方法，不设置设置setter方法，不变类的要素之一
public String getName(){
return this.name;
}
//-带参数的构造器，name赋值的唯一路径，private修饰，不能外部new新的实例，不变类的要素之一
private CacheImmutable(String name){
this.name=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];
}
}
//-如果缓存数组已经存满，新的实例覆盖第一个旧实例，并把位置标为 1，如果缓存没满，保存进缓存，位标+1，并返回该实例
if(pos==MAX_SIZE){
cache[0] = new CacheImmutable(name);
pos=1;
}else{
cache[pos++] = new CacheImmutable(name);
}
return cache[pos-1];
}
//-重写Object类的equals()方法
public boolean equals(Object obj){
if(this==obj){
return true;
}
if(obj!=null&&obj.getClass()==CacheImmutable.class){
CacheImmutable ci = (CacheImmutable)obj;
if(this.getName().equals(ci.getName())){
return true;
}
}
return false;
}
//-重写Object类的hashCode()方法
public int hashCode(){
return name.hashCode();
}
//-获取当前实例在缓存中是第几个
public int getPos(){
return pos;
}
//-获取整个缓存数组
public CacheImmutable[] getArray(){
return cache;
}
}
public class CacheImmutableTest{
public static void main(String[] args){
//-定义一个 CacheImmutable类实例：cache1，name为：ImmutableClass，并保存进缓存
CacheImmutable cache1 = CacheImmutable.valueOf("ImmutableClass");
//-输出当前实例在缓存中的位置
out.println(cache1.getPos());
//-遍历整个缓存，输出缓存中每个实例的name值
for(int i=0;i<cache1.getPos();i++){
out.println(cache1.getArray()[i].getName());
}
//-输出整个缓存数组
out.println(Arrays.toString(cache1.getArray()));
out.println();
//-新定义的实例：cache2 与 已经保存进缓存的实例：cache1的name值相等，所以视为已存在实例，不会再次进缓存
CacheImmutable cache2 = CacheImmutable.valueOf("ImmutableClass");
out.println(cache2.getPos());
for(int i=0;i<cache2.getPos();i++){
out.println(cache2.getArray()[i].getName());
}
out.println(Arrays.toString(cache2.getArray()));
out.println();
CacheImmutable cache3 = CacheImmutable.valueOf("ImmutableClass_a");
out.println(cache3.getPos());
for(int i=0;i<cache3.getPos();i++){
out.println(cache3.getArray()[i].getName());
}
out.println(Arrays.toString(cache3.getArray()));
out.println();
CacheImmutable cache4 = CacheImmutable.valueOf("ImmutableClass_b");
out.println(cache4.getPos());
for(int i=0;i<cache4.getPos();i++){
out.println(cache4.getArray()[i].getName());
}
out.println(Arrays.toString(cache4.getArray()));
out.println();
out.println(cache1.equals(cache2));
out.println(cache1.equals(cache3));
out.println();
//-新定义的实例：cache5，会覆盖缓存数组中的第一个实例（因为缓存已满），
CacheImmutable cache5 = CacheImmutable.valueOf("ImmutableClass_c");
out.println(cache5.getPos());
for(int i=0;i<cache5.getPos();i++){
out.println(cache5.getArray()[i].getName());
}
out.println(Arrays.toString(cache5.getArray()));
}
}
运行效果：
总结：
1、是否需要隐藏类的构造器，完全取决于系统需求
2、盲目乱用缓存可能导致系统性能下降
3、缓存的对象会占用内存，如果对象只用一次，重复使用的概率不大，缓存该实例就弊大于利
4、如果某个对象需要频繁的调用，缓存该实例就利大于弊
Java提供的Integer类，就采用了上面CacheImmutable类相同的缓存策略：
1、如果采用 new 构造器来创建 Integer 对象，返回的是全新的 Integer 对象
2、如果采用 valueOf() 方法来创建 Integer 对象，则在创建该对象的同时，会缓存该方法创建的对象
3、Integer 只缓存 -128-127之间的 Integer 对象，超过该范围的对象不会缓存
如下代码示例：
public class IntegerCache{
public static void main(String[] args){
//-生成新的Integer对象实例：a
Integer a = new Integer(5);
//-生成新的Integer对象实例：b，并缓存
Integer b = Integer.valueOf(5);
//-直接从缓存里获取对象，因为缓存里相同对象已经存在
Integer c = Integer.valueOf(5);
//-false
System.out.println(a==b);
//-true
System.out.println(b==c);
//-Integer只缓存-128-127之间的值，200对应的Integer对象没有被缓存
Integer d = Integer.valueOf(200);
Integer e = Integer.valueOf(200);
//-因为没缓存，所以是两个不同的对象，返回false
System.out.println(d==e);
}
}
运行结果：
