由“String不可变”引发的一些思考

最新推荐文章于 2020-07-20 09:33:03 发布

jeveuxquetucrois

最新推荐文章于 2020-07-20 09:33:03 发布

阅读量84

点赞数

分类专栏： JAVA 文章标签： JAVA

本文链接：https://blog.csdn.net/qq_41306759/article/details/86501288

版权

JAVA 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

字符串常量池

JVM为了字符串的服用，减少字符串对象的重复创建，特别维护了一个常量池。

jdk1.7之前的版本，常量池存放在方法区，方法区和JAVA堆一样，是各个线程共享的内存区域，用于存储已经被虚拟机加载的类信息、常量、静态常量、JIT编译后的代码等。在java虚拟机规范中将方法区描述为堆的一个逻辑部分，也被叫做Non-Heap(非堆)。经常遇到的一个错误：java.lang.OutOfMemoryError: PermGen space，这里的PermGenspace也就是我们经常提到的永久代，方法区可以理解为java虚拟机的规范，而永久代则看作是规范的一种实现。而在jdk1.7中，常量池从永久代移到到了堆区，为移除永久代工作做准备。于是我们看到的常量池内存溢出变成了java.lang.OutOfMemoryError: Java heap space。

到了jdk1.8，永久代彻底移除，元空间（Meta space）出现，可以看作是对JVM规范中方法区的另一种实现。不过元空间与永久代之间最大的区别在于：元空间并不在JVM中，而是使用本地内存。因此，默认情况下，元空间的大小仅受本地内存限制，把类的元数据扔到了元空间，而常量池仍然放在java heap中。

元空间取代永久代可能是因为，字符串存于永久代，占用堆区内存，太小可能导致永久代溢出，太大导致老年代溢出，为GC也带来不必要的复杂度，并且回收效率也偏低。当然以上内容仅针对HotSpot 。

String

        String str1 = "123";
        String str2 = new String("123");
        System.out.println(str1 == str2);
        System.out.println(str1.equals(str2));

首先是String的两种不同的初始化写法。第一种字面量形式的写法，会直接在字符串常量池中查找是否存在值 123，若存在直接返回这个值的引用，若不存在创建一个字符串123存入字符串常量池中。而使用 new 关键字，则会直接在堆上生成一个新的 String 对象，并不会理会常量池中是否有这个值。所以本质上 str1 和 str2 指向的内存地址是不一样的，str1 指向常量池，str2指向堆，而对于“==”比较的是地址，所以第一句是返回false，而第二句equals比较值（对于没有复写equals的对象，equals仍然比较的是地址），当然是返回true。

String对象不可变是因为它用了final修饰。在同一个方法内，当final修饰一个基本数据类型时，表示该基本数据类型的值在初始化后便不能发生变化；如果final修饰一个引用类型，则对其初始化之后便不能再改变值，但栈上的引用可以改变。

上栗子1：

        String s = "123";
        System.out.println("s = " + s);
        s = "456";
        System.out.println("s = " + s);

打印结果为

s = 123
s = 456

s的值变了，那123这个对象改变了吗，其实“123”这个对象还是存在，只不过生成了一个新的”456“对象，并把这个s指向了“456”，如下图所示。

在进一步讨论讨论String的不可变性之前，看下面的一个栗子：

    public static void main(String args[]) {
        String str = "hello";
        change(str);
        System.out.println(str);      
    }
    private static void change(String str) {
        str = "word";
    }

    输出结果：
        hello

为什么这个执行结果是hello，而不像上一个栗子，str指向了新的对象“word”呢？这个涉及到java函数调用时的参数传递策略，java到底是值传递还是引用传递。

先理解几个基础概念：

形参：用来接收调用该方法时传递的参数。只有在被调用的时候才分配内存空间，一旦调用结束，就释放内存空间。因此仅仅在方法内有效，也就是change函数里面的这个str。

实参：传递给被调用方法的值，预先创建并赋予确定值，对应main函数里面的str。

值传递：方法调用时，实参把它的副本传递给对应的形参。

引用传递：方法调用时，将实参的引用地址直接传给形参，函数接收到原参数的内存地址。

值传递和引用传递都是属于函数调用时参数的求值策略(Evaluation Strategy)，这是对调用函数时，求值和传值的方式的描述，而非传递的内容的类型，引用类型和引用传递是不同方法的概念，一个描述内存分配方式，一个描述参数求值策略。

对于引用传递，在函数中可以改变原始对象，这里的改变是指将一个变量指向另一个对象，就像第一个栗子中呈现的那样，而不是仅仅是改变属性或者成员变量之类的，所以Java是值传递。

而这些行为与参数类型是基本类型还是引用类型无关。对于值传递来说，无论参数是基本类型还是引用类型，都会在栈上创建一个副本，但有一点不同，对于值类型，这个副本是整个原始值的复制，而对于引用类型来说，由于对象实例在堆上，复制的只是在栈上的它的一个引用值。

上例代码中，str传入change()函数时，形参str只是原引用str的一个引用副本，它们同时指向了堆中的“hello”对象，也就是同时存在两个不同的str。当执行形参str = “word”;时，在内存再创建了一个“word”对象，并把形参str引用指向了这个新创建的对象，但是main函数里面的str的地址并没有改变。

那么再来看这段代码：

    public static void main(String args[]) {
        final char[] ch = {'h', 'e', 'l', 'l', 'o'};
        change(ch);
        System.out.println(ch);
    }
    private static void change(char[] ch) {
        ch[1] = 'a';
    }

	输出结果：
		hallo

因为是值传递，所以引用不可变，但是可以改变对象的属性或者成员变量。那怎么改变对象的属性或者成员变量呢？比如上述的数组，直接改变ch[i]的值，要么对象自身提供改变的方法，比如StringBuilder的append方法：

    public static void main(String args[]) {
        StringBuilder sb = new StringBuilder("hello");
        change(sb);
        System.out.println(sb.toString());
    }
    private static void change(StringBuilder sb) {
        sb.append(" world");
    }

    输出结果：
        hello world

String对象不可变

在Effective Java中对不可变类的设计提出了以下五点建议：

不要提供任何会修改对象状态的方法。
保证类不会被扩展。
使所有的域都是 final 的。
使所有的域都成为私有的。
确保对于任何可变性组件的互斥访问。

我们再结合jdk源码（1.8）就可以知道为什么String被称为一个不可变类了，除了在类上标识final保证类不会被扩展，其所有的域都是final且私有的，也不提供改变对象状态的方法（比如setter等）。

    public final class String
        implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

    /** Cache the hash code for the string */
    private int hash; // Default to 0

    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = -6849794470754667710L;

    /**
     * Class String is special cased within the Serialization Stream Protocol.
     *
     * A String instance is written into an ObjectOutputStream according to
     * <a href="{@docRoot}/../platform/serialization/spec/output.html">
     * Object Serialization Specification, Section 6.2, "Stream Elements"</a>
     */
    private static final ObjectStreamField[] serialPersistentFields =
        new ObjectStreamField[0];

那么String真的一定不可改变，发现String的值是用一个char[]数组存储的，结合我们上面提到的栗子是不是可以做到改变呢？

改变String

计算机科学领域的任何问题都可以通过增加一个中间层来解决，那么对于java，通过反射往往可以做到一些普通方法做不到的事。通过反射获取这个value[]数组，然后改变它不就可以了吗。

    public static void main(String args[]) throws Exception {
        String str = "hello";
        change(str);
        System.out.println(str);
    }
    private static void change(String str) throws Exception {
        // 1.获取域
        Field field = String.class.getDeclaredField("value");
        // 2.value是私有域，设置为可访问
        field.setAccessible(true);
        // 3.找到对应值
        char[] value = (char[]) field.get(str);
        value[1] = 'a';
    }

	输出结果：
		hallo

很显然，通过反射可以破坏 String 的不可变性。

总结

Java的传参方式是值传递，这个是函数调用时参数的求值策略，与参数是基本类型还是引用类型无关。另外，不可变类的设计在使用过程中不容易出错，天生的线程安全，当然也应该避免不可变设计的滥用。

jeveuxquetucrois

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
由“String不可变”引发的一些思考

字符串常量池 JVM为了字符串的服用，减少字符串对象的重复创建，特别维护了一个常量池。 jdk1.7之前的版本，常量池存放在方法区，方法区和JAVA堆一样，是各个线程共享的内存区域，用于存储已经被虚拟机加载的类信息、常量、静态常量、JIT编译后的代码等。在java虚拟机规范中将方法区描述为堆的一个逻辑部分，也被叫做Non-Heap(非堆)。经常遇到的一个错误：java.lang.OutOf...
复制链接

扫一扫

专栏目录