深入不可变类——谈谈String与包装类的底层实现

一、走进不可变类
不可变类是指在创建实例后该例变量不可以改变的类。比如String类和包装类。定义不可变类需要遵守：

成员变量设置为priavte ,final修饰
提供带参构造器对成员变量进行初始化
只提供getter，不提供setter
如有必要，重写equals()和hashcode()，使成员变量值一样的实例equals()运算返回true且hashcode值相同。

下面简单实现了一个不可变类。

1public class Address {
2    private final String detail;
3    private final String postCode;
4    public Address() {
5        detail="";
6        postCode="";
7    }
8    public Address(String detail, String postCode) {
9        super();
10        this.detail = detail;
11        this.postCode = postCode;
12    }
13    public String getDetail() {
14        return detail;
15    }
16    public String getPostCode() {
17        return postCode;
18    }
19
20    public boolean equals(Object obj){
21        if(this==obj) return true;
22        if(obj!=null&&(obj.getClass()==Address.class)){
23            Address ad=(Address)obj;
24            if(ad.getDetail().equals(this.getDetail())&&ad.getPostCode().equals(this.getPostCode())){
25                return true;
26            }
27        }
28        return false;
29    }
30
31    public int hashcode(){
32        return detail.hashCode()+postCode.hashCode()\*31;
33    }
34}

二、含有引用类型成员变量的不可变类
对于Address类，它的成员变量都是基本数据类型，但是如果是引用数据类型的成员变量，把引用成员变量定义成为final类型只是代表引用地址不会发生改变，如果这个引用成员变量是可变类型的对象，其值仍然可能发生改变，这种情况一旦出现，设计不可变类的需求就会失败。比如下面这个例子。

1class Name {
2    private String firstName;
3    private String lastName;
4
5    public Name() {
6    }
7
8    public Name(String firstName, String lastName) {
9        super();
10        this.firstName = firstName;
11        this.lastName = lastName;
12    }
13
14    public String getFirstName() {
15        return firstName;
16    }
17
18    public void setFirstName(String firstName) {
19        this.firstName = firstName;
20    }
21
22    public String getLastName() {
23        return lastName;
24    }
25
26    public void setLastName(String lastName) {
27        this.lastName = lastName;
28    }
29
30}
31
32public class Person {
33    private final Name name;
34
35    public Name getName() {
36        return name;
37    }
38
39    public Person(Name name) {
40        super();
41        this.name = name;
42    }
43
44    public static void main(String\[\] args) {
45        Name name = new Name("悟空", "孙");
46        Person p = new Person(name);
47        // 输出悟空
48        System.out.println(p.getName().getFirstName());
49        name.setFirstName("八戒");
50        // 输出八戒
51        System.out.println(p.getName().getFirstName());
52    }
53}
54

我们可以对Person类进行下修改，实现不可变类的设计需求。

1public class Person {
2    private final Name name;
3
4    public Name getName() {
5        // 返回一个成员变量name的副本
6        return new Name(name.getFirstName(), name.getFirstName());
7    }
8
9    public Person(Name name) {
10        super();
11        // 创建一个新的name副本，使其与形参name的FirstName,lastName值相同
12        this.name = new Name(name.getFirstName(), name.getFirstName());
13    }
14}

三、带缓冲池的不可变类
不可变类的实例状态不会发生改变，可以方便地被多个对象所共享，如果需要频繁使用实例对象，可以进行缓存，毕竟创建相同的对象没有意义，还会加大系统的内存开销。下面我们通过一个数组来作为缓存池，实现一个缓存实例的不可变类。

1ublic class CacheImmutale {
2    private static int MAX_SIZE = 10;
3    private static CacheImmutale[] Cache = new CacheImmutale[MAX_SIZE];
4    // 用来记录实例在缓存中的位置，CacheImmutale[pos-1]为最新的缓存实例
5    private static int pos = 0;
6    private final String name;
7
8    public String getName() {
9        return name;
10    }
11
12    private CacheImmutale(String name) {
13        super();
14        this.name = name;
15    }
16
17    public static CacheImmutale valueof(String name) {
18        // 如果存在该实例，则返回该实例
19        for (int i = 0; i < MAX_SIZE; i++) {
20            if (Cache[i] != null && Cache[i].getName().equals(name)) {
21                return Cache[i];
22            }
23        }
24        // 如果缓冲池满了，则把实例放入缓冲池数组最开始,pos置1
25        if (pos == MAX_SIZE) {
26            Cache[0] = new CacheImmutale(name);
27            pos = 1;
28        }
29        // 创建实例加入缓冲池,pos加1
30        else {
31            Cache[pos++] = new CacheImmutale(name);
32        }
33        return Cache[pos - 1];
34    }
35    @Override
36    public int hashCode() {
37        return name.hashCode();
38    }
39
40    @Override
41    public boolean equals(Object obj) {
42        if (this == obj)
43            return true;
44        if (obj != null && (obj.getClass() == CacheImmutale.class)) {
45            CacheImmutale cache = (CacheImmutale) obj;
46            if (cache.getName().equals(this.getName())) {
47                return true;
48            }
49        }
50        return false;
51    }
52
53    public static void main(String[] args) {
54        CacheImmutale c1 = CacheImmutale.valueof("张三");
55        CacheImmutale c2 = CacheImmutale.valueof("张三");
56        //输出true
57        System.out.println(c1 == c2);
58    }
59}
60

包装类Integer就采取了类似的缓冲机制，当使用Integer.valueof()创建实例时，-128~127的Integer对象都可以直接在缓冲池中引用。下面看看这道常考的笔试题，有没有感到豁然开朗。

1public class WrapClassCompare {
2    public static void main(String[] args) {
3        Integer it1 = new Integer(5);
4        // 基本数据类型和包装类型进行比较,比较值,顺利进行,true
5        System.out.println(it1 == 5);
6
7        Integer it2 = new Integer(5);
8        // 两个引用类型数据,比较的是地址，false
9        System.out.println(it1 == it2);
10
11        // 通过自动装箱把基本类型数据赋值给引用类型数据
12        Integer it3 = 5;
13        Integer it4 = 5;
14        // 输出true，这是因为-128~127的Integer类型数据自动装箱数据时，会直接引用Integer\[\]类型的cache数组中元素
15        System.out.println(it3 == it4);
16
17        Integer it5 = 128;
18        Integer it6 = 128;
19        //输出false,Integer的cache数组存放容量有限，只存放-128~127
20        System.out.println(it5 == it6);
21    }
22}

带缓存的不可变类并不是在任何场合都适用，如果一个对象使用的频率不高，不要用缓存来存放，这样会浪费系统内存资源。

深入不可变类 -- 谈谈Java String与包装类的底层实现

深入不可变类——谈谈String与包装类的底层实现

评论区

相关推荐