灵魂拷问：java的String到底可不可变？

ゞ浴缸里的玫瑰 2023-08-17 16:25 143阅读 0赞

从认识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;
        ……
        ……
        ……

很好理解，因为被final关键字修饰了，所以是不可变的，但你能清楚的解释下面的问题吗

public static void main(String[] args) {
            String a = new String("abcd");
            String b = new String("abcd");
            String c = "abcd" + "ppp";
            String d = "abcd";
            String e = "abcd" + "ppp";
            String f = d + "ppp";
            
            System.out.println("情况1："+(a == b) + "-------------" + a.equals(b));
            System.out.println("情况2："+(a == d) + "-------------" + a.equals(d));
           
           
            System.out.println("情况4："+(c == e) + "-------------" + c.equals(e));
            System.out.println("情况5："+(f == e) + "-------------" + f.equals(e));
            a = a.intern();
            System.out.println("情况6："+(a == d) + "-------------" + a.equals(d));
        }

是不是疯了？  
  
其实每种情况的后半段`equals`好理解，根据源码的描述

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重写的Object的eqals方法，本质是转成字符数组然后逐一比较，所以上述6种情况后半段都是true  
  
  
一个个来分析，情况1

String a = new String("abcd");
            String b = new String("abcd");
            System.out.println("情况1："+(a == b) + "-------------" + a.equals(b));

看一下带参数的构造函数的源码：

/**
         * Initializes a newly created {@code String} object so that it represents
         * the same sequence of characters as the argument; in other words, the
         * newly created string is a copy of the argument string. Unless an
         * explicit copy of {@code original} is needed, use of this constructor is
         * unnecessary since Strings are immutable.
         *
         * @param  original
         *         A {@code String}
         */
        public String(String original) {
            this.value = original.value;
            this.hash = original.hash;
        }

首先`this.value`是String定义的一个私有的被`final`修饰成员变量`private final char value[];`，将原始字符串的value和hash值进行赋值后，会返回一个String对象的引用，所以a和b返回的是两个引用，自然不一样，所以情况1前半段为`false`

情况2

String a = new String("abcd");
      String d = "abcd";
      System.out.println("情况2："+(a == d) + "-------------" + a.equals(d));

看着好像是一样的，但这个就涉及到String字符池的概念，其实在情况1中，**jvm会在内部维护的String Pooll中放入一个"abc"对象，并在heap中创建一个String对象，然后将该heap中对象的引用返回给用户**  
大概意思如下图  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlaXN1cmVfbGlmZQ_size_16_color_FFFFFF_t_70]  
堆内存和字符串有什么不同呢，堆内存会随着对象的回收而被GC回收，而字符池不会  
  
所以执行`String d = "abcd";`的时候，实际上java的处理方式是**先去字符池找，有没有已经存在的字符串，如果有，则返回一个指向它的引用，如果没有，则与new String(“abcd”)处理一样**，这里可知，字符池中已经有，所以返回的只是一个String类型的引用，而`===`比较的就是引用，所以情况2的前半段结果也是`false`

情况3

String b = new String("abcd");
        System.out.println("情况3："+(b == d) + "-------------" + b.equals(d));
        String d = "abcd";

与情况2如出一辙，前半段结果也是`false`  
  
情况4

String c = "abcd" + "ppp";
      String e = "abcd" + "ppp";
      System.out.println("情况4："+(c == e) + "-------------" + c.equals(e));

**如果用+号来实现String的串接时：1）仅当+号两边均为字符串常量时，才将其+后的结果当做字符串常量，且该结果直接放入String Pool；2）若+号两边有一方为变量时，+后的结果即当做非字符串常量处理(等同于new String()的效果)** ，所以可知c和e引用的是用一个对象，所以情况4的前半段结果是`true`

情况5

String d = "abcd";
            String e = "abcd" + "ppp";
            String f = d + "ppp";
    	    System.out.println("情况5："+(f == e) + "-------------" + f.equals(e));

根据情况4的分析，+号有一方为变量，处理与`new String()`一致，自然前半段结果也是`false`  
  
情况6

String a = new String("abcd");
    		 a = a.intern();
            System.out.println("情况6："+(a == d) + "-------------" + a.equals(d));

情况6与情况2唯一的不同就是`a = a.intern();`,那这个`a = a.intern();`到底做了什么呢，源码是这样说的

/**
         * Returns a canonical representation for the string object.
         * <p>
         * A pool of strings, initially empty, is maintained privately by the
         * class {@code String}.
         * <p>
         * When the intern method is invoked, if the pool already contains a
         * string equal to this {@code String} object as determined by
         * the {@link #equals(Object)} method, then the string from the pool is
         * returned. Otherwise, this {@code String} object is added to the
         * pool and a reference to this {@code String} object is returned.
         * <p>
         * It follows that for any two strings {@code s} and {@code t},
         * {@code s.intern() == t.intern()} is {@code true}
         * if and only if {@code s.equals(t)} is {@code true}.
         * <p>
         * All literal strings and string-valued constant expressions are
         * interned. String literals are defined in section 3.10.5 of the
         * <cite>The Java™ Language Specification</cite>.
         *
         * @return  a string that has the same contents as this string, but is
         *          guaranteed to be from a pool of unique strings.
         */
        public native String intern();

大概意思就是**如果常量池中存在当前字符串, 就会直接返回当前字符串. 如果常量池中没有此字符串, 会将此字符串放入常量池中后, 再返回**  
  
所以`a.intern()`是显式的调用了`intern()`方法，将a的引用由原来的指向heap中对象改为指向内部维护的strings pool中的对像，a原来指向的String对象已经成为垃圾对象了，随时会被GC收集  
如此一来自然前半段结果就是`true`了，真TM神奇

总结一下，String对象真的是不可变的，“可变的”是引用，jvm通过上面的策略，可以使多个引用指向一个对象而互不影响。字符池的存在当然是基于节约内存考虑。

最后我们来看一下结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlaXN1cmVfbGlmZQ_size_16_color_FFFFFF_t_70 1]  
好像是全对了，100分，**但是故事结束了吗？**

public static String changeStr(String before) throws Exception{
    
            System.out.println("之前是这个---- "+before); //
            Field field = String.class.getDeclaredField("value");
    
            field.setAccessible(true);
    
            char[] value = (char[]) field.get(before);
    
            value[6] = 'J';
    
            value[7] = 'a';
    
            value[8] = 'v';
    
            value[9] = 'a';
    
            value[10] = '!';
    
            value[11] = '!';
    
            System.out.println("之后呀是这个---- "+before); 
          return before;
    
        }
    
        public static void main(String[] args) {
            try {
    
                System.out.println(changeStr("Hello String"));
            }catch (Exception e ){
                // 异常处理
            }
    
        }

![在这里插入图片描述][20190928180658604.png]  
啪，打脸，好疼！！！

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlaXN1cmVfbGlmZQ_size_16_color_FFFFFF_t_70]: /images/20230810/ab55f3f893054eb29ccb3edf35944261.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xlaXN1cmVfbGlmZQ_size_16_color_FFFFFF_t_70 1]: /images/20230810/4c606c991eac407fa1cb9945d58463bc.png
[20190928180658604.png]: /images/20230810/aa60a038ae9d498399e873f1c8659d7d.png