一、走进不可变类
不可变类是指在创建实例后该例变量不可以改变的类。比如String类和包装类。定义不可变类需要遵守：1.成员变量设置为priavte ,final修饰 2.提供带参构造器对成员变量进行初始化 3.只提供getter，不提供setter 4.如有必要，重写equals()和hashcode()，使成员变量值一样的实例equals()运算返回true且hashcode值相同。下面简单实现了一个不可变类。
public class Address { private final String detail; private final String postCode; public Address() { detail=""; postCode=""; } public Address(String detail, String postCode) { super(); this.detail = detail; this.postCode = postCode; } public String getDetail() { return detail; } public String getPostCode() { return postCode; } public boolean equals(Object obj){ if(this==obj) return true; if(obj!=null&&(obj.getClass()==Address.class)){ Address ad=(Address)obj; if(ad.getDetail().equals(this.getDetail())&&ad.getPostCode().equals(this.getPostCode())){ return true; } } return false; } public int hashcode(){ return detail.hashCode()+postCode.hashCode()*31; } }
二、含有引用类型成员变量的不可变类
对于Address类，它的成员变量都是基本数据类型，但是如果是引用数据类型的成员变量，把引用成员变量定义成为final类型只是代表引用地址不会发生改变，如果这个引用成员变量是可变类型的对象，其值仍然可能发生改变，这种情况一旦出现，设计不可变类的需求就会失败。比如下面这个例子。
class Name { private String firstName; private String lastName; public Name() { } public Name(String firstName, String lastName) { super(); this.firstName = firstName; this.lastName = lastName; } public String getFirstName() { return firstName; } public void setFirstName(String firstName) { this.firstName = firstName; } public String getLastName() { return lastName; } public void setLastName(String lastName) { this.lastName = lastName; } } public class Person { private final Name name; public Name getName() { return name; } public Person(Name name) { super(); this.name = name; } public static void main(String[] args) { Name name = new Name("悟空", "孙"); Person p = new Person(name); // 输出悟空 System.out.println(p.getName().getFirstName()); name.setFirstName("八戒"); // 输出八戒 System.out.println(p.getName().getFirstName()); } }
我们可以对Person类进行下修改，实现不可变类的设计需求。
public class Person { private final Name name; public Name getName() { // 返回一个成员变量name的副本 return new Name(name.getFirstName(), name.getFirstName()); } public Person(Name name) { super(); // 创建一个新的name副本，使其与形参name的FirstName,lastName值相同 this.name = new Name(name.getFirstName(), name.getFirstName()); } }
三、带缓冲池的不可变类
不可变类的实例状态不会发生改变，可以方便地被多个对象所共享，如果需要频繁使用实例对象，可以进行缓存，毕竟创建相同的对象没有意义，还会加大系统的内存开销。下面我们通过一个数组来作为缓存池，实现一个缓存实例的不可变类。
ublic class CacheImmutale { private static int MAX_SIZE = 10; private static CacheImmutale[] Cache = new CacheImmutale[MAX_SIZE]; // 用来记录实例在缓存中的位置，CacheImmutale[pos-1]为最新的缓存实例 private static int pos = 0; private final String name; public String getName() { return name; } private CacheImmutale(String name) { super(); this.name = name; } public static CacheImmutale valueof(String name) { // 如果存在该实例，则返回该实例 for (int i = 0; i < MAX_SIZE; i++) { if (Cache[i] != null && Cache[i].getName().equals(name)) { return Cache[i]; } } // 如果缓冲池满了，则把实例放入缓冲池数组最开始,pos置1 if (pos == MAX_SIZE) { Cache[0] = new CacheImmutale(name); pos = 1; } // 创建实例加入缓冲池,pos加1 else { Cache[pos++] = new CacheImmutale(name); } return Cache[pos - 1]; } @Override public int hashCode() { return name.hashCode(); } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj != null && (obj.getClass() == CacheImmutale.class)) { CacheImmutale cache = (CacheImmutale) obj; if (cache.getName().equals(this.getName())) { return true; } } return false; } public static void main(String[] args) { CacheImmutale c1 = CacheImmutale.valueof("张三"); CacheImmutale c2 = CacheImmutale.valueof("张三"); //输出true System.out.println(c1 == c2); } }
包装类Integer就采取了类似的缓冲机制，当使用Integer.valueof()创建实例时，-128~127的Integer对象都可以直接在缓冲池中引用。下面看看这道常考的笔试题，有没有感到豁然开朗。
public class WrapClassCompare { public static void main(String[] args) { Integer it1 = new Integer(5); // 基本数据类型和包装类型进行比较,比较值,顺利进行,true System.out.println(it1 == 5); Integer it2 = new Integer(5); // 两个引用类型数据,比较的是地址，false System.out.println(it1 == it2); // 通过自动装箱把基本类型数据赋值给引用类型数据 Integer it3 = 5; Integer it4 = 5; // 输出true，这是因为-128~127的Integer类型数据自动装箱数据时，会直接引用Integer[]类型的cache数组中元素 System.out.println(it3 == it4); Integer it5 = 128; Integer it6 = 128; //输出false,Integer的cache数组存放容量有限，只存放-128~127 System.out.println(it5 == it6); } }
带缓存的不可变类并不是在任何场合都适用，如果一个对象使用的频率不高，不要用缓存来存放，这样会浪费系统内存资源。
