一、不可变类简介

不可变类:所谓的不可变类是指这个类的实例一旦创建完成后,就不能改变其成员变量值。如JDK内部自带的很多不可变类:Interger、Long和String(8种基本数据类型的包装类和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属性的地址和所指内容都没变。

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

  1. JAVA不可变类(immutable)机制与String的不可变性--非常好.

    JAVA不可变类(immutable)机制与String的不可变性 https://www.cnblogs.com/jaylon/p/5721571.html

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

    一.不可变类简介 不可变类:所谓的不可变类是指这个类的实例一旦创建完成后,就不能改变其成员变量值.如JDK内部自带的很多不可变类:Interger.Long和String等. 可变类:相对于不可变类, ...

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

    一.简单定义不可变对象(Immutable Objects)即对象一旦被创建,它的状态(对象的数据,也即对象属性值)就不能改变,反之即为可变对象(Mutable Objects).当满足以下条件时,对 ...

  4. Java中的不可变类理解

    一.Java中的不可变类 不可变类(Immutable Objects):当类的实例一经创建,其内容便不可改变,即无法修改其成员变量. 可变类(Mutable Objects):类的实例创建后,可以修 ...

  5. Java基础-Java中的堆内存和离堆内存机制

    Java基础-Java中的堆内存和离堆内存机制 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任.

  6. Java基础-Java中的内存分配与回收机制

    Java基础-Java中的内存分配与回收机制 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一. 二.

  7. Java基础-日期格式化DateFormat类简介

    Java基础-日期格式化DateFormat类简介 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.DateFormat类概述 DateFormat 是日期/时间格式化子类的抽象 ...

  8. Java基础-Java中23种设计模式之常用的设计模式

    Java基础-Java中23种设计模式之常用的设计模式 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任.   一.设计模式分类 设计模式是针对特定场景给出的专家级的解决方案.总的来说设 ...

  9. java基础---->java中正则表达式二

    跟正则表达式相关的类有:Pattern.Matcher和String.今天我们就开始Java中正则表达式的学习. Pattern和Matcher的理解 一.正则表达式的使用方法 一般推荐使用的方式如下 ...

随机推荐

  1. 《编写高质量代码改善JavaScript程序的188个建议》读书笔记

    逗号运算符比较怪异.如    var a =(1,2,3,4);alert(a);// 4      var a = 1,2,3,4;//报错 注意a++和++a的差别,变量在参与运算中不断地变化.v ...

  2. Java参数引用传递之例外:null

    今天写链表的时候写了一个函数,实参是一个空链表,应该是按引用传参,但是在函数内修改了链表,外部的链表没有变化. 原来是null作为参数传递的时候,就不是引用传参了. 引自:http://blog.cs ...

  3. IbatisNet连接oracle 报错

    提示什么 connect oracle   1.5.0.xxxx 将你本机的oracle 客户端版本重装换成32位即可

  4. Mybatis笔记八:MyBatis中#{}和${}的区别

    先给大家介绍下MyBatis中#{}和${}的区别,具体介绍如下: 1. $将传入的数据直接显示生成在sql中 2. #方式能够很大程度防止sql注入. 3.$方式无法防止Sql注入. 4.$方式一般 ...

  5. Linux命令之ipcalc

    ipcalc命令是一个简单的ip地址计算器,可以完成简单的IP地址计算任务.参数: -b:由给定的IP地址和网络掩码计算出广播地址: -4:ipv4: -6:ipv6: -h:显示给定IP地址所对应的 ...

  6. 【cdq分治】【P4390】[BOI2007]Mokia 摩基亚

    Description 给你一个 \(W~\times~W\) 的矩阵,每个点有权值,每次进行单点修改或者求某子矩阵内权值和,允许离线 Input 第一行是两个数字 \(0\) 和矩阵大小 \(W\) ...

  7. 《剑指offer》— JavaScript(16)合并两个排序的链表

    合并两个排序的链表 题目描述 输入两个单调递增的链表,输出两个链表合成后的链表,当然我们需要合成后的链表满足单调不减规则. *** 思路 如果pHead1和pHead2中有一个为空,则result是另 ...

  8. 微服务Kong(八)——代理参考

    Kong侦听四个端口的请求,默认情况是: 8000:此端口是Kong用来监听来自客户端的HTTP请求的,并将此请求转发到您的上游服务.这也是本教程中最主要用到的端口. 8443:此端口是Kong监听H ...

  9. python基础之while语句continue以及break --语法以及案例

    1.while 死循环 [root@localhost python]# cat while.py #!/usr/bin/env python # _*_ coding:utf8 _*_ import ...

  10. SpringBoot(十一):Spring boot 中 mongodb 的使用

    原文出处: 纯洁的微笑 mongodb是最早热门非关系数据库的之一,使用也比较普遍,一般会用做离线数据分析来使用,放到内网的居多.由于很多公司使用了云服务,服务器默认都开放了外网地址,导致前一阵子大批 ...