Java不可变对象

最新推荐文章于 2024-06-25 08:00:00 发布

chang_ge

最新推荐文章于 2024-06-25 08:00:00 发布

阅读量684

点赞数 1

分类专栏： java

java 专栏收录该内容

136 篇文章 1 订阅

订阅专栏

一、不可变类简介

不可变类：所谓的不可变类是指这个类的实例一旦创建完成后，就不能改变其成员变量值。如JDK内部自带的很多不可变类：Interger、Long和String等。
可变类：相对于不可变类，可变类创建实例后可以改变其成员变量值，开发中创建的大部分类都属于可变类。

下面的理解可能会易懂一些：

{概念：不可变类的意思是创建该类的实例后，该实例的属性是不可改变的。Java中的8个包装类和String类都是不可变类。所以不可变类并不是指该类是被final修饰的，而是指该类的属性是被final修饰的。

自定义不可变类遵守如下原则：

1、使用private和final修饰符来修饰该类的属性。

2、提供带参数的构造器，用于根据传入的参数来初始化属性。

3、仅为该类属性提供getter方法，不要提供setter方法。

4、如果有必要，重写hashCode和equals方法，同时应保证两个用equals方法判断为相等的对象，其hashCode也应相等。}

二、不可变类的优点

说完可变类和不可变类的区别，我们需要进一步了解为什么要有不可变类？这样的特性对JAVA来说带来怎样的好处？

线程安全
不可变对象是线程安全的，在线程之间可以相互共享，不需要利用特殊机制来保证同步问题，因为对象的值无法改变。可以降低并发错误的可能性，因为不需要用一些锁机制等保证内存一致性问题也减少了同步开销。
易于构造、使用和测试
...

三、不可变类的设计方法

对于设计不可变类，个人总结出以下原则：

1. 类添加final修饰符，保证类不被继承。
如果类可以被继承会破坏类的不可变性机制，只要继承类覆盖父类的方法并且继承类可以改变成员变量值，那么一旦子类以父类的形式出现时，不能保证当前类是否可变。

2. 保证所有成员变量必须私有，并且加上final修饰
通过这种方式保证成员变量不可改变。但只做到这一步还不够，因为如果是对象成员变量有可能再外部改变其值。所以第4点弥补这个不足。

3. 不提供改变成员变量的方法，包括setter
避免通过其他接口改变成员变量的值，破坏不可变特性。

4.通过构造器初始化所有成员，进行深拷贝(deep copy)

如果构造器传入的对象直接赋值给成员变量，还是可以通过对传入对象的修改进而导致改变内部变量的值。例如：

public final class ImmutableDemo {  
    private final int[] myArray;  
    public ImmutableDemo(int[] array) {  
        this.myArray = array; // wrong  
    }  
}

这种方式不能保证不可变性，myArray和array指向同一块内存地址，用户可以在ImmutableDemo之外通过修改array对象的值来改变myArray内部的值。
为了保证内部的值不被修改，可以采用深度copy来创建一个新内存保存传入的值。正确做法：

public final class MyImmutableDemo {  
    private final int[] myArray;  
    public MyImmutableDemo(int[] array) {  
        this.myArray = array.clone();   
    }   
}

5. 在getter方法中，不要直接返回对象本身，而是克隆对象，并返回对象的拷贝
这种做法也是防止对象外泄，防止通过getter获得内部可变成员对象后对成员变量直接操作，导致成员变量发生改变。

四、String对象的不可变性

string对象在内存创建后就不可改变，不可变对象的创建一般满足以上5个原则，我们看看String代码是如何实现的。

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence
{
    /** The value is used for character storage. */
    private final char value[];
    /** The offset is the first index of the storage that is used. */
    private final int offset;
    /** The count is the number of characters in the String. */
    private final int count;
    /** Cache the hash code for the string */
    private int hash; // Default to 0
    ....
    public String(char value[]) {
         this.value = Arrays.copyOf(value, value.length); // deep copy操作
     }
    ...
     public char[] toCharArray() {
     // Cannot use Arrays.copyOf because of class initialization order issues
        char result[] = new char[value.length];
        System.arraycopy(value, 0, result, 0, value.length);
        return result;
    }
    ...
}

如上代码所示，可以观察到以下设计细节:

String类被final修饰，不可继承
string内部所有成员都设置为私有变量
不存在value的setter
并将value和offset设置为final。
当传入可变数组value[]时，进行copy而不是直接将value[]复制给内部变量.
获取value时不是直接返回对象引用，而是返回对象的copy.

这都符合上面总结的不变类型的特性，也保证了String类型是不可变的类。

五、String对象的不可变性的优缺点

从上一节分析，String数据不可变类，那设置这样的特性有什么好处呢？我总结为以下几点：

1.字符串常量池的需要.
字符串常量池可以将一些字符常量放在常量池中重复使用，避免每次都重新创建相同的对象、节省存储空间。但如果字符串是可变的，此时相同内容的String还指向常量池的同一个内存空间，当某个变量改变了该内存的值时，其他遍历的值也会发生改变。所以不符合常量池设计的初衷。

2. 线程安全考虑。
同一个字符串实例可以被多个线程共享。这样便不用因为线程安全问题而使用同步。字符串自己便是线程安全的。

3. 类加载器要用到字符串，不可变性提供了安全性，以便正确的类被加载。譬如你想加载java.sql.Connection类，而这个值被改成了myhacked.Connection，那么会对你的数据库造成不可知的破坏。

4. 支持hash映射和缓存。
因为字符串是不可变的，所以在它创建的时候hashcode就被缓存了，不需要重新计算。这就使得字符串很适合作为Map中的键，字符串的处理速度要快过其它的键对象。这就是HashMap中的键往往都使用字符串。

缺点：

如果有对String对象值改变的需求，那么会创建大量的String对象。

六、String对象的是否真的不可变

虽然String对象将value设置为final,并且还通过各种机制保证其成员变量不可改变。但是还是可以通过反射机制的手段改变其值。例如：

    //创建字符串"Hello World"， 并赋给引用s
    String s = "Hello World"; 
    System.out.println("s = " + s); //Hello World

    //获取String类中的value字段
    Field valueFieldOfString = String.class.getDeclaredField("value");
    //改变value属性的访问权限
    valueFieldOfString.setAccessible(true);

    //获取s对象上的value属性的值
    char[] value = (char[]) valueFieldOfString.get(s);
    //改变value所引用的数组中的第5个字符
    value[5] = '_';
    System.out.println("s = " + s);  //Hello_World

打印结果为：

s = Hello World
s = Hello_World

发现String的值已经发生了改变。也就是说，通过反射是可以修改所谓的“不可变”对象的

总结

不可变类是实例创建后就不可以改变成员遍历的值。这种特性使得不可变类提供了线程安全的特性但同时也带来了对象创建的开销，每更改一个属性都是重新创建一个新的对象。JDK内部也提供了很多不可变类如Integer、Double、String等。String的不可变特性主要为了满足常量池、线程安全、类加载的需求。合理使用不可变类可以带来极大的好处。

具体实例

构造一个不可变类非常容易，下面举一个简单例子：

[java] view plain copy
package com.home;  
  
public class Address {  
    private final String detail;  
  
    public Address() {  
        this.detail = "";  
    }  
  
    public Address(String detail) {  
        this.detail = detail;  
    }  
  
    public String getDetail() {  
        return detail;  
    }  
  
    @Override  
    public int hashCode() {  
        return detail.hashCode();  
    }  
  
    @Override  
    public boolean equals(Object obj) {  
        if (obj instanceof Address) {  
            Address address = (Address) obj;  
            if (this.getDetail().equals(address.getDetail())) {  
                return true;  
            }  
        }  
        return false;  
    }  
  
}  

但是值得注意的是，该类的属性虽然是被final修饰的，但若属性是非String的其他引用类型的话，那么虽然该属性的内容（所指对象的地址）不会改变，但其指向的对象却有可能会改变，这样的类当然并不能成为不可变类。比如下面的Person类中有一个Name类型的属性：

[java] view plain copy
package com.home;  
  
public class Person {  
    private final Name name;  
  
    public Person(Name name) {  
        super();  
        this.name = name;  
    }  
  
    public Name getName() {  
        return name;  
    }  
  
    public static void main(String[] args) {  
        Name n = new Name("三", "张");  
        Person p = new Person(n);  
        System.out.println(p.getName().getFirstName());  
        // 改变Person对象Name属性的firstName属性值  
        n.setFirstName("无忌");  
        System.out.println(p.getName().getFirstName());  
    }  
}  

Name：

[java] view plain copy
package com.home;  
  
public class Name {  
    private String firstName;  
    private String lastName;  
  
    public Name() {  
        super();  
    }  
  
    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;  
    }  
}  

运行上面程序可以看到，Person对象的Name属性的firstName属性已经被改变，这就违背了不可变类设计的初衷。我们可以采取如下办法来解决，修改Person类如下：

[java] view plain copy
package com.home;  
  
public class Person {  
    private final Name name;  
  
    public Person(Name name) {  
        super();  
        // 设置name属性为临时创建的Name对象，该对象的firstName属性和lastName属性  
        // 与传入的name对象的firstName属性和lastName属性相同  
        this.name = new Name(name.getFirstName(), name.getLastName());  
    }  
  
    public Name getName() {  
  
        // 返回一个匿名对象，该对象的firstName属性和lastName属性  
        // 与该对象里的name属性的firstName属性和lastName属性相同  
        return new Name(name.getFirstName(), name.getLastName());  
    }  
  
    public static void main(String[] args) {  
        Name n = new Name("三", "张");  
        Person p = new Person(n);  
        System.out.println(p.getName().getFirstName());  
        // 改变Person对象Name属性的firstName属性值  
        n.setFirstName("无忌");  
        System.out.println(p.getName().getFirstName());  
    }  
}  

再次运行程序，发现Person对象的Name属性的firstName属性没有改变了。

另外，由于不可变类的实例的状态不可改变，所以可以很方便地被多个对象所共享，那么如果程序要经常使用相同的不可变类实例，为了减少系统开销，一般要考虑使用缓存机制。下面使用数组作为缓存池来构建一个可以缓存实例的不可变类：

[java] view plain copy
package com.home;  
  
public class CacheImmutale {  
    private final String name;  
    private static CacheImmutale[] cache = new CacheImmutale[10];  
    private static int pos = 0;  
  
    public CacheImmutale(String name) {  
        super();  
        this.name = name;  
    }  
  
    public String getName() {  
        return name;  
    }  
  
    public static CacheImmutale valueOf(String name) {  
        // 遍历已缓存的对象  
        for (int i = 0; i < pos; i++) {  
            // 如果已有相同实例，直接返回该缓存的实例  
            if (cache[i] != null && cache[i].getName().equals(name)) {  
                return cache[i];  
            }  
        }  
        // 如果缓冲池已满  
        if (pos == 10) {  
            // 把缓存的第一个对象覆盖  
            cache[0] = new CacheImmutale(name);  
            pos = 1;  
            return cache[0];  
        } else {  
            // 把新创建的对象缓存起来，pos加1  
            cache[pos++] = new CacheImmutale(name);  
            return cache[pos - 1];  
        }  
    }  
  
    @Override  
    public int hashCode() {  
        return name.hashCode();  
    }  
  
    @Override  
    public boolean equals(Object obj) {  
        if (obj instanceof CacheImmutale) {  
            CacheImmutale ci = (CacheImmutale) obj;  
            if (name.equals(ci.getName())) {  
                return true;  
            }  
        }  
        return false;  
    }  
  
    public static void main(String[] args) {  
        CacheImmutale c1 = CacheImmutale.valueOf("hello");  
        CacheImmutale c2 = CacheImmutale.valueOf("hello");  
        System.out.println(c1 == c2);// 输出结果为true  
    }  
}  

对于缓存的使用，应根据系统需求而定，简单的说，如果某个对象使用的次数不多，重复使用的概率不大，就没必要使用缓存，毕竟缓存的对象也会占用系统内存。如果某个对象需要频换地重复使用，这时就应该使用缓存了。

另外，上面的示例来源疯狂JAVA讲义一书，个人对上面那个Person类里面的属性是引用类型的解决办法存有疑问，他那种办法虽然保证的Person对象的Name属性所指对象的内容没有改变，但Person对象返回的Name属性已经不是同一个属性了，它的地址已发生改变，赋值和返回都是通过new出来的，我个人做了如下改进，觉得更合理：

[java] view plain copy
package com.home;  
  
public class Person {  
    private final Name name;  
  
    public Person(Name name) {  
        super();  
        // 设置name属性为临时创建的Name对象，该对象的firstName属性和lastName属性  
        // 与传入的name对象的firstName属性和lastName属性相同  
        this.name = new Name(name.getFirstName(), name.getLastName());  
    }  
  
    public Name getName() {  
        // 直接返回当前实例的name属性即可  
        return name;  
    }  
  
    public static void main(String[] args) {  
        Name n = new Name("三", "张");  
        Person p = new Person(n);  
        System.out.println(p.getName() + "  " + p.getName().getFirstName());  
        // 改变Person对象Name属性的firstName属性值  
        n.setFirstName("无忌");  
        System.out.println(p.getName() + "  " + p.getName().getFirstName());  
    }  
}  