【Java源码系列】String 底层结构分析

String 继承关系，核心成员变量，主要构造函数：

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
    /**
     * 1.final会被jvm缓存，提高了性能
     * 2.fianl变量线程安全，节省了线程同步的开销
     * 正因为是final的，所有不可变，即所有String都是新的
     * 注：这个数组是不可变的，不存在容器的扩容问题
     */
    private final char value[];
    
    // 空参构造 如果只是new String()那么只会产生一个空数组
    public String() {
      this.value = new char[0];
	}
    
    // char[]构造，调用 Arrays.copyOf
    // 注：Arrays.copyOf是拷贝后返回一个新数组，system.arrayCopy是可以对目标数组拷贝
    public String(char value[]) {
    	this.value = Arrays.copyOf(value, value.length);
	}
   
    // 指定char[]部分，实际是调用Arrays.copyOfRange(部分拷贝)
    // 常用于subString方法
    public String(char value[], int offset, int count) {
        if (offset < 0) {
            throw new StringIndexOutOfBoundsException(offset);
        }
        if (count < 0) {
            throw new StringIndexOutOfBoundsException(count);
        }
        // Note: offset or count might be near -1>>>1.
        if (offset > value.length - count) {
            throw new StringIndexOutOfBoundsException(offset + count);
        }
        this.value = Arrays.copyOfRange(value, offset, offset+count);
    }
    
    // 构造器有很多，这里只列举3个.....
}    

1.实现的接口

1）Serializable : 序列化，string可以写到io流中，并可保存整个对象以及用于网络传输

private static final long serialVersionUID = -6849794470754667710L;

2）Comparable : 比较，若返回值>0则，当前字符串小于另一个字符串

// 注：只有在实现Compareable时指定了泛型，这里才会是myString ====> 指定泛型是必要的
public int compareTo(String anotherString) {
        int len1 = value.length;
        int len2 = anotherString.value.length;
        // 取两者最小长度
        int lim = Math.min(len1, len2);
        char v1[] = value;
        char v2[] = anotherString.value;

    	// 1.先逐个字符比较，若遇见不同了，即使A比B长，但B[i]>A[i]，那么也是B>A
        int k = 0;
        while (k < lim) {
            char c1 = v1[k];
            char c2 = v2[k];
            // 不相同，就ASCII相减
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
    	// 2.再比较长度
        return len1 - len2;
    }

3）CharSequence：CharSequence与String都能用于定义字符串，但CharSequence的值是可读可写序列，而String的值是只读序列

2.final 与不变性

• String 被 final 修饰，说明 String 类绝不可能被继承了，也就是说任何对 String 的操作方法，都不会被继承覆写
• String 中保存数据的是一个 char 的数组 value。我们发现 value 也是被 final 修饰的，也就是说 value 一旦被赋值，内存地址是绝对无法修改的，而且 value 的权限是 private 的，外部绝对访问不到，String 也没有开放出可以对 value 进行赋值的方法，所以说 value 一旦产生，内存地址就根本无法被修改。

final 的作用

• final关键字提高了性能，JVM缓存了final变量
• final变量线程安全，节省了多线程环境下同步的开销
• JVM会对final方法及变量进行优化

String 通过充分利用 final 关键字实现了不变性，所以 string 的绝大多数写法都是返回新的 string

两个String不变性的示例：

• demo1:

String str ="hello world !!";
// 这种写法是替换不掉的，必须接受 replace 方法返回的参数才行
// 比如：str = str.replace("l","dd");
str.replace("l","dd");

• demo2:

String s ="hello";
s ="world";

从代码上来看，s 的值好像被修改了，但从 debug 的日志来看，其实是 s 的内存地址已经被修改了，也就说 s =“world” 这个看似简单的赋值，其实已经把 s 的引用指向了新的 String，debug 的截图显示内存地址已经被修改，两张截图如下：

3.new与不new的问题

来看一段程序：

String str1 = "abc";
String str2 = new String("def");
String str3 = "abc";
String str4 = str2.intern();
String str5 = "def";
System.out.println(str1 == str3);//true
System.out.println(str2 == str4);//false
System.out.println(str4 == str5);//true

先来说一下 JVM 对于字符串处理的整个流程：

1. 上面程序的经过编译之后，在该类的class常量池中存放一些符号引用
2. 类加载之后，将class常量池中存放的符号引用转存到运行时常量池中
3. 经过验证，准备阶段之后，在堆中生成驻留字符串的实例对象（也就是上例中str1所指向的”abc”实例对象），然后将这个对象的引用存到全局String Pool中，也就是StringTable中
4. 最后在解析阶段，要把运行时常量池中的符号引用替换成直接引用，那么就直接查询 StringTable，保证StringTable里的引用值与运行时常量池中的引用值一致，大概整个过程就是这样了

回到上面的那个程序，现在就很容易解释整个程序的内存分配过程了，

1. 首先，在堆中会有一个”abc”实例，全局StringTable中存放着”abc”的一个引用值
2. 然后在运行第二句的时候会生成两个实例，
   • 一个是”def”的实例对象，并且StringTable中存储一个”def”的引用值
   • 还有一个是new出来的一个”def”的实例对象，与上面那个是不同的实例
3. 当在解析str3的时候查找StringTable，里面有”abc”的全局驻留字符串引用，所以str3的引用地址与之前的那个已存在的相同
4. str4是在运行的时候调用intern()函数，返回 StringTable中”def”的引用值，如果没有就将 str2 的引用值添加进去，在这里，StringTable 中已经有了”def”的引用值了，所以返回上面在 new str2 的时候添加到StringTable中的 “def”引用值
5. 最后str5在解析的时候就也是指向存在于StringTable中的”def”的引用值

那么这样一分析之后，下面三个打印的值就容易理解了。

总结一下，字符串实例都是存在堆上的；但是，如果不 new，则会直接将字符串常量池的引用返回；如果 new，则会再创建一个字符串实例，并将其引用返回；如果要将某个字符串也添加到字符串常量池，可以通过 intern() 方法（前提是字符串常量池无该实例）。