Java String学习笔记

参照：https://www.jianshu.com/p/2f209af80f84

常量池：

Java代码被编译成class文件时，会生成一个常量池（Constant pool）的数据结构，用以保存字面常量和符号引用（类名、方法名、接口名和字段名等）。

package com.ctrip.ttd.whywhy;
public class Test {  
    public static void main(String[] args) {  
        String test = "test";  
    }  
}

通过命令javap -verbose查看class文件中Constant pool实现：

Constant pool:
   #1 = Methodref          #4.#13         // java/lang/Object."<init>":()V
   #2 = String             #14            // test
   #3 = Class              #15            // com/ctrip/ttd/whywhy/test
   #4 = Class              #16            // java/lang/Object
   #5 = Utf8               <init>
   #6 = Utf8               ()V
   #7 = Utf8               Code
   #8 = Utf8               LineNumberTable
   #9 = Utf8               main
  #10 = Utf8               ([Ljava/lang/String;)V
  #11 = Utf8               SourceFile
  #12 = Utf8               test.java
  #13 = NameAndType        #5:#6          // "<init>":()V
  #14 = Utf8               test
  #15 = Utf8               com/ctrip/ttd/whywhy/test
  #16 = Utf8               java/lang/Object

在main方法字节码指令中，0 ~ 2行对应代码 String test = "test"; 由两部分组成：ldc #2 和 astore_1。

// main方法字节码指令
 public static void main(java.lang.String[]);
   Code:
      0: ldc           #2                  // String test
      2: astore_1
      3: return

1、Test类加载到虚拟机时，"test"字符串在Constant pool中使用符号引用symbol表示，当调用 ldc #2 指令时，如果Constant pool中索引 #2 的symbol还未解析，则调用C++底层的 StringTable::intern 方法生成char数组，并将引用保存在StringTable和常量池中，当下次调用 ldc #2 时，可以直接从Constant pool根据索引 #2获取 "test" 字符串的引用，避免再次到StringTable中查找。

2、astore_1指令将"test"字符串的引用保存在局部变量表中。

常量池的内存分配

在 JDK6、7、8中有不同的实现：
1、JDK6及之前版本中，常量池的内存在永久代PermGen进行分配，所以常量池会受到PermGen内存大小的限制。
2、JDK7中，常量池的内存在Java堆上进行分配，意味着常量池不受固定大小的限制了。
3、JDK8中，虚拟机团队移除了永久代PermGen。

字面常量

public class StringTest {
    public static void main(String[] args) {
        String a = "java";
        String b = "java";
        String c = "ja" + "va";
    }
}

通过 "javap -c" 命令查看字节码指令实现：

其中ldc指令将int、float和String类型的常量值从常量池中推送到栈顶，所以a和b都指向常量池的"java"字符串

通过指令实现可以发现：变量a、b和c都指向常量池的 "java" 字符串，表达式 "ja" + "va" 在编译期间会把结果值"java"直接赋值给c。

String对象

public class StringTest {
    public static void main(String[] args) {
        String a = "java";
        String c = new String("java");
    }
}

这种情况下，a == c 成立么？字节码实现如下：

 

其中3 ~ 9行指令对应代码 String c = new String("java"); 实现：
1、第3行new指令，在Java堆上为String对象申请内存；
2、第7行ldc指令，尝试从常量池中获取"java"字符串，如果常量池中不存在，则在常量池中新建"java"字符串，并返回；
3、第9行invokespecial指令，调用构造方法，初始化String对象。

 

其中String对象中使用char数组存储字符串，变量a指向常量池的"java"字符串，变量c指向Java堆的String对象，且该对象的char数组指向常量池的"java"字符串，所以很显然 a != c，如下图所示：

 

**通过 "字面量 + String对象" 进行赋值会发生什么？ **

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

这种情况下，c == d成立么？字节码实现如下：

 

 

其中6 ~ 21行指令对应代码 String c = a + b; 实现：
1、第6行new指令，在Java堆上为StringBuilder对象申请内存；
2、第10行invokespecial指令，调用构造方法，初始化StringBuilder对象；
3、第14、18行invokespecial指令，调用append方法，添加a和b字符串；
4、第21行invokespecial指令，调用toString方法，生成String对象。

 

通过指令实现可以发现，字符串变量的连接动作，在编译阶段会被转化成StringBuilder的append操作，变量c最终指向Java堆上新建String对象，变量d指向常量池的"hello world"字符串，所以 c != d。

不过有种特殊情况，当final修饰的变量发生连接动作时，虚拟机会进行优化，将表达式结果直接赋值给目标变量：

public class StringTest {
    public static void main(String[] args) {
        final String a = "hello ";
        final String b = "world";
        String c = a + b;
        String d = "hello world";
    }
}

指令实现如下：

c == d