String 与不可变对象

 

什么是不可变对象 ？不可变对象指的是在创建一个对象之后 ，不能再改变它的状态 ，那么这个对象就是不可变的 。不能改变状态的意思是 ，不能改变对象内的成员变量 ，包括基本数据类型的值不能改变 ，引用类型的变量不能指向其它的对象 ，引用类型指向的对象状态也不能改变 。

这里插播一下对象和对象的引用之间的区别 ，对象的引用是放在栈中的 ，而对象是放在堆中的 ，看这个例子 String s = "123" ; s = "456" ; 表面上 s 看是变了 ，但是要搞清楚 ，变的只是 String 对象的引用 s ，而 “123” 这个对象是没有变化的 。看一个图 ：

我们都说 String 是不可变对象 ，那我们就分析一下 String 的源码来看看它是怎么保证 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

    public String(String original) {
        this.value = original.value;
        this.hash = original.hash;
    }

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

    public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String) anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                            return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }
    ...

我们通过分析源码可知 ，首先 String 类和存放字符串的 char 型数组都是 final 类型的 ，保证了 String 类不能被继承 ，value 这个引用本身不会该变 ，但是这样还不能说明属性是不可变的 ，因为我们可以通过改变 value 数组中具体的值来达到改变 value 的目的 。

public static void main(String[] args) {
        char[] value = {'a','b','c','d'};
        System.out.println(value); 
        for (int i = 0; i < value.length; i++) {
            if(i == 1){
                value[i] = 'B';
            }
        }
        System.out.println(value); //aBcd
    }

但是进一步研究会发现 ，对于 value 这个属性 ，被定义为 private ，而且 String 并没有提供相对应的 get set 方法 ，所以我们也不能操作它 。而那些我们常认为改变了 String 对象的方法 ，比方说 subString concat toUpperCase tirm 看了源码之后发现 ，这些方法都是重新创建了一个 char 数组 ，并没有改动之前的对象 。这也就是我们常说 String 是不可变对象的原因 。但是我们还是可以通过反射的方式来改变 value 的值 ，看个例子就好 ，但是我们一般不这么做 。

public static void main(String[] args) throws Exception {
        //创建字符串"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  
    }

为什么要将 String 设计为不可变对象呢 ？当然是为了提高效率和安全 ，也是由于 String 的超高使用频率 。效率主要体现在当我们复制 String 对象的时候我只需要复制引用即可 ，不需要复制具体的对象 ，而在多线程环境中 ，若是不同的线程同时修改 String 对象 ，相互之间也不会有影响 。因为一旦改变都会创建一个新的字符串 ，保证了线程的安全 。

另外在堆中有个字符串常量池 ，我们创建的字符串都会存在这里 ，当创建相同的字符串的时候 ，其实指向的是同一个地方 。这就节省了大量的空间 ，当然 ，能出现字符串常量池也是因为 String 是不可变对象 。

因为 String 不可变 ，所以在创建对象的时候就已经将 hashCode 的值计算出来缓存在字段 hash 中 。这样在 Map 中 String 就很适合作为主键 ，速度快 。（因为在散列表中我们定位时会计算主键的 hash 值 。）

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

还有在数据库连接的时候我们通过字符串来传递用户名 ，密码 ，连接的库等信息 ，若字符串可变 ，则很可能被黑客篡改 。

PS. 基本类型对应的包装类都是不可变对象 ，这样设计的原因还是因为使用太频繁 ，好处在上面已经说过了 。突然感觉学到了好多之前没注意到的细节 。

源码版本为 JDK 1.7

推荐阅读：https://www.cnblogs.com/YJK923/p/9479805.html

参考资料：https://zhuanlan.zhihu.com/p/38144507