深入底层谈谈String

一、聊聊字符串拼接【底层】

给一个测试 Demo1：

public class Demo1 {
    public static void main(String[] args) {
        String a = "a";
        String b = "b";
        String c = "ab";
        String d = a+b;
    }
}

利用 javap -v Demo1.class 命令看看编译后字节码中的main方法（
-v 命令参数，含附加信息）

public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=5, args_size=1
         0: ldc           #2                  // String a
         2: astore_1    放到下面局部变量表中，1表示的是位置，对应Slot列名
         3: ldc           #3                  // String b
         5: astore_2
         6: ldc           #4                  // String ab
         8: astore_3
         9: new           #5      这里准备实例化了一个StringBuilder对象            // class java/lang/StringBuilder
        12: dup
        13: invokespecial #6       通过无参构造的方式           // Method java/lang/StringBuilder."<init>":()V
        16: aload_1		从表中取变量，取Slot为1的
        17: invokevirtual #7    这里对拿到的变量进行字符串凭借             // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        20: aload_2
        21: invokevirtual #7       这里也对拿到的变量进行字符串凭借           // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        24: invokevirtual #8 这里通过调用StringBuilder中的toString方法得到一个新的String对象            // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
        27: astore        4     把那得到的新String对象赋给局部变量表中Slot为4的
        29: return   方法结束
      // 这是main方法中的局部变量表  
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      30     0  args   [Ljava/lang/String;
            3      27     1     a   Ljava/lang/String;
            6      24     2     b   Ljava/lang/String;
            9      21     3     c   Ljava/lang/String;
           29       1     4     d   Ljava/lang/String;

通过分析上面（含附加信息）的main方法的字节码可以得出，字符串对象通过+进行拼接的细节部分。首先会去创建一个空的StringBuilder对象，然后把从局部变量表中取出相应的字符串调用append方法进行拼接，最后通过toString方法得出结果。也就是说每次使用+去拼接字符串都会创建一个新的StringBuilder对象去进行操作。所以如果是什么什么集合字符串然后进行拼接，还是别乱用加号进行拼接。

StringBuilder中的toString方法
    @Override
    public String toString() {
        // Create a copy, don't share the array
        return new String(value, 0, count);
    }

可以看见是重新 new 了一个 String 对象，也就是 d 变量是指向一个新的String 对象，放入堆中。 但是上面的 c 变量是通过直接字符串赋值的方式，这种方式是先会在字符串常量池中查找，如果存在，则返回该字符串的引用，否则就在字符串常量池中创建一个新的字符串对象，并返回该字符串对象的引用。 后者是内存中就一份，可以被多个引用共享；前者是怎么都会在堆中产生对应的新空间给其使用。

下面对 c 和 d 对象地址进行比对会输出 false。

System.out.println(c==d);// false

所以

建议在使用字符串时，尽量使用直接字符串赋值方式，以便复用字符串常量池中的对象，避免不必要的内存占用和性能问题。

再来看看直接通过字符串的方式进行拼接。

	String e = "a" + "b";

字节码分析

也就是和对象 c 指向应该为同一个地址。

System.out.println(c==e);//true

二、聊聊String实现（源码分析）

实现的接口

public final class String implements java.io.Serializable, Comparable<String>, CharSequence

从这可以得出String类是final类型的，不允许你瞎拓展。
还有就是实现了Comparable接口，可以通过compareTo重写的方法进行字符串比较。

内部属性及其部分构造函数

内部属性

重点看那个value数组，它是final类型的，这也是为什么说String字符串定义后永远不会变的原因。

构造函数，重点有几个

这就是直接拿参数的value进行拷贝。

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

这个就是调用copyOf方法==》System.arraycopy方法去进行拷贝。

public String(char value[]) {
        this.value = Arrays.copyOf(value, value.length);
    }

部分方法说明

• equals方法（小编还是觉得挺简单的，没什么好说的，需要注意的是，虽然value是私有的，但传进来的String对象是在本类中使用的，所以也是可以调用value属性的。）

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

明明replace，replaceAll，substring等方法得到了新的字符串，为什么说String是不变的呢？

为什么String对象是不可变的？

其实那个final类型的value数组就很明显了，至于方法为什么返回的是新的字符串，看源码的话非常清晰。这里拿一个replace和substring方法说明一下。

可以看见都是去new一个新的String对象。

三、总结

• 字符串对象之间的拼接底层会创建一个空的StringBuilder对象，然后通过append方法进行拼接；如果是纯字符串拼接，那么底层会直接进行拼接，然后去字符串常量池中找。（字符串常量池是通过哈希表实现的，如果字符串存在的话就会返回其对应的引用）
• String对象不可变性、不可拓展性源于起内部实现是一个final类型的value数组，String类是final型的。
• substring等方法是返回一个新的String对象。

当然上面说的是jdk8中的String对象，在jdk9后String对象做了很多改变，比如底层不再是char数组，而是byte数组，高效的使用内存；还新增了一些静态方法…