【Java基础】JAVA不可变类(immutable)机制与String的不可变性

一、不可变类简介

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

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

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

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

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

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

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

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

二、不可变类的优点

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

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

三、不可变类的设计方法

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

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;
    }
    ...
}

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

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

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

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

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

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

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

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

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

缺点：

  1. 如果有对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

  1. package public Address {
  2. String detail;
  3. Address() {
  4. .detail = ;
  5. Address(String detail) {
  6. .detail = detail;
  7. String getDetail() {
  8. detail;
  9. hashCode() {
  10. detail.hashCode();
  11. equals(Object obj) {
  12. (obj  Address) {
  13. (.getDetail().equals(address.getDetail())) {
  14. ;
  15. ;
  16. }

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

[java] view
plain copy

  1. package

    public Person {

  2. Name name;
  3. Person(Name name) {
  4. ();
  5. .name = name;
  6. Name getName() {
  7. name;
  8. main(String[] args) {
  9. Name(, );
  10. Person(n);
  11. );
  12. }

Name：

[java] view
plain copy

  1. package

    public Name {

  2. String firstName;
  3. String lastName;
  4. Name() {
  5. ();
  6. Name(String firstName, String lastName) {
  7. ();
  8. .firstName = firstName;
  9. .lastName = lastName;
  10. String getFirstName() {
  11. firstName;
  12. setFirstName(String firstName) {
  13. .firstName = firstName;
  14. String getLastName() {
  15. lastName;
  16. setLastName(String lastName) {
  17. .lastName = lastName;
  18. }

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

[java] view
plain copy

  1. package

    public Person {

  2. Name name;
  3. Person(Name name) {
  4. ();
  5. .name =  Name(name.getFirstName(), name.getLastName());
  6. Name getName() {
  7. Name(name.getFirstName(), name.getLastName());
  8. main(String[] args) {
  9. Name(, );
  10. Person(n);
  11. );
  12. }

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

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

[java] view
plain copy

  1. package

    public CacheImmutale {

  2. String name;
  3. CacheImmutale[] cache =  CacheImmutale[];
  4. pos = ;
  5. CacheImmutale(String name) {
  6. ();
  7. .name = name;
  8. String getName() {
  9. name;
  10. CacheImmutale valueOf(String name) {
  11. ( i = ; i < pos; i++) {
  12. (cache[i] !=  && cache[i].getName().equals(name)) {
  13. cache[i];
  14. (pos == ) {
  15. ] =  CacheImmutale(name);
  16. ;
  17. cache[];
  18. {
  19. CacheImmutale(name);
  20. cache[pos - ];
  21. hashCode() {
  22. name.hashCode();
  23. equals(Object obj) {
  24. (obj  CacheImmutale) {
  25. (name.equals(ci.getName())) {
  26. ;
  27. ;
  28. main(String[] args) {
  29. );
  30. );
  31. }

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

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

[java] view
plain copy

  1. package

    public Person {

  2. Name name;
  3. Person(Name name) {
  4. ();
  5. .name =  Name(name.getFirstName(), name.getLastName());
  6. Name getName() {
  7. name;
  8. main(String[] args) {
  9. Name(, );
  10. Person(n);
  11. );
  12. }

从打印结果可以看出p的name属性的地址和所指内容都没变。

时间： 2024-10-18 12:25:40

【Java基础】JAVA不可变类(immutable)机制与String的不可变性的相关文章

JAVA不可变类(immutable)机制与String的不可变性

不可变类:是指这个类实例一旦创建,就不能不该其成员变量的值 优点: 1.线程安全 对象的值无法改变,降低并发错误的可能性 2.效率高 当一个对象需要复制时,就只需要复制对象地址,不用复制本生 不变性,保证了hashcode的唯一性,每次缓存时不必重新计算hashcode,所以常用string作为key 3.便于测试 而且如果程序里的变量都是immutable 的话 side effect就比较小 程序只要写好测一遍基本没有什么bug 缺点: 每一次改变都需要产生新的对象,容易产生很多垃圾 设计方

Java 的不可变类 (IMMUTABLE CLASS) 和 可变类 (MUTABLE CLASS)

一.简单定义不可变对象(Immutable Objects)即对象一旦被创建,它的状态(对象的数据,也即对象属性值)就不能改变,反之即为可变对象(Mutable Objects).当满足以下条件时,对象才是不可变的:1. 对象创建以后其状态就不能修改.2. 对象的所有域都是final类型.3. 对象是正确创建的(在对象的创建期间,this引用没有逸出).不可变对象的类即为不可变类(Immutable Class).Java平台类库中包含许多不可变类,如String.基本类型的包装类.BigInt

Java中的不可变类

本文与个人博客 zhiheng.me 同步发布,标题: Java中的不可变类. 不可变类(Immutable Objects):当类的实例一经创建,其内容便不可改变,即无法修改其成员变量. 可变类(Mutable Objects):类的实例创建后,可以修改其内容. Java 中八个基本类型的包装类和 String 类都属于不可变类,而其他的大多数类都属于可变类. 与引用不可变的区别 需要特别注意的是,不可变类的不可变是指该类的实例不可变而非指向该实例的引用的不可变. String s = "ab

Java基础----Java API中的常用类

System:描述系统的一些信息 preperties();获取系统信息 Properties prop =new System.getProperties(); 是hashtable 的子类.用map的方法去除该类集合中的元素.该集合中存储的都是字符串,没有泛型定义. String calue=(String)prop.get(obj); System.out.println(obj+":"+value); //如何在系统中自定义一些特有信息? System.setProperty(

Java基础知识：面向对象&类图

类(Class)封装了数据和行为,是面向对象的重要组成部分,它是具有相同属性.操作.关系的对象集合的总称.在系统中,每个类都具有一定的职责,职责指的是类要完成什么样的功能,要承担什么样的义务.一个类可以有多种职责,设计得好的类一般只有一种职责.在定义类的时候,将类的职责分解成为类的属性和操作(即方法).类的属性即类的数据职责,类的操作即类的行为职责.设计类是面向对象设计中最重要的组成部分,也是最复杂和最耗时的部分. 1.面向对象特性 1)抽象 2)继承 3)封装 4)多态 2.类图: 在软件系统

java基础学习总结——Object类

永不放弃,一切皆有可能!!! 只为成功找方法,不为失败找借口! java基础学习总结——Object类 一.Object类介绍 Object类在JAVA里面是一个比较特殊的类,JAVA只支持单继承,子类只能从一个父类来继承,如果父类又是从另外一个父类继承过来,那他也只能有一个父类,父类再有父类,那也只能有一个,JAVA为了组织这个类组织得比较方便,它提供了一个最根上的类,相当于所有的类都是从这个类继承,这个类就叫Object.所以Object类是所有JAVA类的根基类,是所有JAVA类的老祖宗.

Java基础-Java源文件与类

Java基础-Java源文件与类 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 原文地址:https://www.cnblogs.com/yinzhengjie/p/8654877.html

[Java基础] Java线程复习笔记

先说说线程和进程,现代操作系统几乎无一例外地采用进程的概念,进程之间基本上可以认为是相互独立的,共享的资源非常少.线程可以认为是轻量级的进 程,充分地利用线程可以使得同一个进程中执行多种任务.Java是第一个在语言层面就支持线程操作的主流编程语言.和进程类似,线程也是各自独立的,有自 己的栈,自己的局部变量,自己的程序执行并行路径,但线程的独立性又没有进程那么强,它们共享内存,文件资源,以及其他进程层面的状态等.同一个进程内的 多个线程共享同样的内存空间,这也就意味着这些线程可以访问同样的变量和

[Java基础] Java对象内存结构

转载地址:http://www.importnew.com/1305.html 原文于2008年11月13日 发表, 2008年12月18日更新:这里还有一篇关于Java的Sizeof运算符的实用库的文章. 学C/C++出身的我,对Java有一点非常困惑,那就是缺乏计算对象占用内存大小的机制.而在C++中就可以通过sizeof运算符来获得基本类型以及类实例的大小.C和C++中的这个操作符对于指针运算.内存拷贝和IO操作都非常有用. Java中并没有一个类似的运算符.事实上,Java也不需要这种运