String 为何不可变 ?

众所周知, String 是一个不可变的，由 final 修饰的类。那么它的不可变性体如今哪里呢? 看下面一段简单的代码：

String str= "123";
  str = "456";
复制代码

相信应该没人会以为这段代码是错误的，那么这符合 String 的不可变性吗？String 的不可变性是如何体现的？ 不可变性的好处是什么？带着这些疑问，read the fuck source code !

什么是不可变类 ？

Effective Java 中第 15 条 使可变性最小化 中对 不可变类 的解释：

不可变类只是其实例不能被修改的类。每一个实例中包含的全部信息都必须在建立该实例的时候就提供，而且在对象的整个生命周期内固定不变。为了使类不可变，要遵循下面五条规则：

1. 不要提供任何会修改对象状态的方法。

2. 保证类不会被扩展。 通常的作法是让这个类称为 final 的，防止子类化，破坏该类的不可变行为。

3. 使全部的域都是 final 的。

4. 使全部的域都成为私有的。 防止客户端得到访问被域引用的可变对象的权限，并防止客户端直接修改这些对象。

5. 确保对于任何可变性组件的互斥访问。 若是类具备指向可变对象的域，则必须确保该类的客户端没法得到指向这些对象的引用。

在 Java 平台类库中，包含许多不可变类，例如 String , 基本类型的包装类，BigInteger, BigDecimal 等等。综上所述，不可变类具备一些显著的通用特征：类自己是 final 修饰的；全部的域几乎都是私有 final 的；不会对外暴露能够修改对象属性的方法。经过查阅 String 的源码，能够清晰的看到这些特征。

为何 String 不可变 ？

String 的源码实现

回到开头提出的问题，对于这段代码：

String str= "123";
str = "456";
复制代码

下面这张图清楚地解释了代码的执行过程：

执行第一行代码时，在堆上新建一个对象实例 123 ,str 是一个指向该实例的引用，引用包含的仅仅只是实例在堆上的内存地址而已。执行第二行代码时，仅仅只是改变了 str 这个引用的地址，指向了另外一个实例 456。因此，正如前面所说过的，不可变类只是其实例不能被修改的类。 给 str 从新赋值仅仅只是改变了它的引用而已，并不会真正去改变它原本的内存地址上的值。这样的好处也是显而易见的，最简单的当存在多个 String 的引用指向同一个内存地址时，改变其中一个引用的值并不会对其余引用的值形成影响。固然还有其余的一些好处，这个放在后面再总结。

那么，String 是如何保持不可变性的呢？结合 Effective Java 中总结的五条原则，阅读它的 源码 以后就一清二楚了。

看一下 String 的几个域：

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 类是 final 修饰的，知足第二条原则：保证类不会被扩展。 分析一下它的几个域：

• private final char value[] : 能够看到 Java 仍是使用字节数组来实现字符串的，而且用 final 修饰，保证其不可变性。这就是为何 String 实例不可变的缘由。

• private int hash : String的哈希值缓存

• private static final long serialVersionUID = -6849794470754667710L ： String对象的 serialVersionUID

• private static final ObjectStreamField[] serialPersistentFields = new ObjectStreamField[0] ： 序列化时使用

其中最主要的域就是 value，表明了 String对象的值。因为使用了 private final 修饰，正常状况下外界没有办法去修改它的值的。正如第三条 使全部的域都是 final 的。 和第四条 使全部的域都成为私有的 所描述的。难道这样一个 private 加上 final 就能够保证万无一失了吗？看下面代码示例：

final char[] value = {'a', 'b', 'c'};
    value[2] = 'd';
复制代码

这时候的 value 对象在内存中已是 a b d 了。其实 final 修饰的仅仅只是 value 这个引用，你没法再将 value 指向其余内存地址，例以下面这段代码就是没法经过编译的：

final char[] value = {'a', 'b', 'c'};
    value = {'a', 'b', 'c', 'd'};
复制代码

因此仅仅经过一个 final 是没法保证其值不变的，若是类自己提供方法修改实例值，那就没有办法保证不变性了。Effective Java 中的第一条原则 不要提供任何会修改对象状态的方法 。String 类也很好的作到了这一点。在 String 中有许多对字符串进行操做的函数，例如 substring concat replace replaceAll 等等，这些函数是否会修改类中的 value 域呢？咱们看一下 concat() 函数的内部实现：

public String concat(String str) {
    int otherLen = str.length();
    if (otherLen == 0) {
        return this;
    }
    int len = value.length;
    char buf[] = Arrays.copyOf(value, len + otherLen);
    str.getChars(buf, len);
    return new String(buf, true);
}
复制代码

注意其中的每一步实现都不会对 value产生任何影响。首先使用 Arrays.copyOf() 方法来得到 value 的拷贝，最后从新 new 一个String对象做为返回值。其余的方法和 contact 同样，都采起相似的方法来保证不会对 value 形成变化。的的确确，String 类中并无提供任何能够改变其值的方法。相比 final 而言，这更能保障 String 不可变。

String 对象在内存中的位置

关于 Java 内存区域的相关知识能够阅读 《深刻理解 Java 虚拟机》 一书中相关章节或者个人对应的 读书笔记。

细心的读者应该发现上面出现过两种 String 对象的写法：

String str1 = "123";
  String str2 = new String("123");
  System.out.println(str1 == str2);
复制代码

结果显然是 false。咱们都知道字符串常量池的概念，JVM 为了字符串的复用，减小字符串对象的重复建立，特别维护了一个字符串常量池。第一种字面量形式的写法，会直接在字符串常量池中查找是否存在值 123，若存在直接返回这个值的引用，若不存在建立一个值为 123 的 String 对象并存入字符串常量池中。而使用 new 关键字，则会直接在堆上生成一个新的 String 对象，并不会理会常量池中是否有这个值。因此本质上 str1 和 str2 指向的内存地址是不同的。

那么，使用 new 关键字生成的 String 对象能够进入字符串常量池吗？答案是确定的，String 类提供了一个 native 方法 intern() 用来将这个对象加入字符串常量池：

String str1 = "123";
  String str2 = new String("123");
  str2=str2.intern();
  System.out.println(str1 == str2);
复制代码

打印结果为 true。str2 调用 intern() 函数后，首先在字符串常量池中寻找是否存在值为 123 的对象，若存在直接返回该对象的引用，若不存在，加入 str2 并返回。上述代码中，常量池中已经存在值为 123 的 str1 对象，则直接返回 str1 的引用地址，使得 str1 和 str2 指向同一个内存地址。

那么说了半天的字符串常量池在内存中处于什么位置呢？常量池是方法区的一部分，用于存放编译期生成的各类字面量和符号引用，运行期间也有可能将新的常量放入池中。在 Java 虚拟机规范中把方法区描述为堆的一个逻辑部分，但它却有一个别名叫 Non-Heap，目的应该是为了和 Java 堆区分开。

不可变类的好处

Effective Java 中总结了不可变类的特色。

• 不可变类比较简单。
• 不可变对象本质上是线程安全的，它们不要求同步。不可变对象能够被自由地共享。
• 不只能够共享不可变对象，甚至能够共享它们的内部信息。
• 不可变对象为其余对象提供了大量的构建。
• 不可变类真正惟一的缺点是，对于每一个不一样的值都须要一个单独的对象。

String 真的不可变吗？

综上所述，String 的确是个不可变类，可是真的没有办法改变 String 对象的值吗？答案确定是否认的，反射机制能够作到不少日常作不到的事情。

String str = "123";
System.out.println(str);
Field field = String.class.getDeclaredField("value");
field.setAccessible(true);
char[] value = (char[]) field.get(str);
value[1] = '3';
复制代码

执行结果：

123
  133
复制代码

很显然，经过反射能够破坏 String 的不可变性。

总结

除了 String 类，系统类库中还提供了一些其余的不可变类，基本类型的包装类、BigInteger、BigDecimal等等。这些不可变类比可变类更加易于设计、实现和使用，不容易出错且更加安全。另外，要记住并不只仅是靠一个 final 关键字来实现不可变的，更多的是靠类内部的具体实现细节。

文章同步更新于微信公众号： 秉心说 ， 专一 Java 、 Android 原创知识分享，LeetCode 题解，欢迎关注！