Java字符串常量池

最新推荐文章于 2024-04-27 17:30:34 发布

Arambler

最新推荐文章于 2024-04-27 17:30:34 发布

阅读量3.3k

点赞数 5

分类专栏： Java 文章标签： java 开发语言

原文链接：https://blog.csdn.net/TomAndersen/article/details/107147344

版权

Java 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

前言

本文主要用于记录和分享一下博主在解决如题问题时，从各种途径所查询到的个人认为比较可信的相关资料，以及他人或个人得出的一些结论。如果参考资料或者所得结论存在错误，欢迎批评指正。
注意：本文中提及到的概念，均建立在使用HotSpot VM的基础上，在其他Java虚拟机中并不一定适用。

Q&A

Q1：什么是字符串常量池

字符串常量池，即String Constant Pool，又叫做String Pool，String Table。顾名思义，即用于存放字符串常量的运行时内存结构，其底层实现为一种Hashtable。其中所指的字符串常量，可以是编译期在源码中显式的字符串字面量，也可以是之后在程序运行时创建的字符串String对象。

在JDK1.6及之前，字符串常量池中只会存放具体的String实例，在使用String.intern方法时，若字符串常量池中有满足String.equals方法的String对象，则返回其引用；若字符串常量池中没有相同的String对象，则当前String对象为堆上对象，故在字符串常量池中创建一个相同的String对象，并返回其引用。

在JDK1.7及之后，字符串常量池中不仅可以存放String实例，同时还能存放指向Java堆中某个String实例的引用。在使用String.intern方法时，若字符串常量池中有满足String.equals方法的String对象，则返回其引用，这一点和JDK1.6相同；若字符串常量池中没有相同的String对象，则当前String对象为堆上对象，故在字符串常量池中存放一个指向堆上此String对象的引用，并返回此引用。

参考资料

stackoverflow: String Constant Pool vs String pool
stackoverflow: String pool vs Constant pool
美团技术团队: 深入解析String#intern
在IDK1.6中，intern() 方法会把首次遇到的字符串实例复制到永久代中，返回的也是永久代中这个字符串实例的引用。而JDK1.7中（以及部分其他虚拟机，例如 JRockit）的 intern() 实现不会再复制实例，只是在常量池中记录首次出现的实例引用。
——《深入理解 Java 虚拟机（第2版）》2.4.3 方法区和运行时常量池溢出
JDK 7（以及部分其他虚拟机，例如 JRockit）的 intern() 方法实现就不需要再拷贝字符串的实例到永久代了，既然字符串常量池已经移到 Java 堆中，那只需要在常量池里记录一下首次出现的实例引用即可。
——《深入理解 Java 虚拟机（第3版）》2.4.3 方法区和运行时常量池溢出
在方法区中常量引用的对象，譬如字符串常量池（String Table）里的引用
——《深入理解 Java 虚拟机（第3版）》3.2.2 可达性分析

Q2：字符串常量池在JVM中的分布

在JDK1.6及之前，字符串常量和其他的基本类型的常量一样，存放在 运行时常量池（Run-Time Constant Pool） 中，即在方法区（HotSpot中为永久代PermGen）中。

在JDK1.7及之后，字符串常量的存放位置已经从运行时常量池中分离到了 Java堆（Heap）中，形成了独立的字符串常量池（String Pool），其中一方面也是因为在永久代中创建String对象，容易耗尽永久代内存空间。

参考资料

美团技术团队: 深入解析String#intern
在IDK1.6中，intern() 方法会把首次遇到的字符串实例复制到永久代中，返回的也是永久代中这个字符串实例的引用。而JDK1.7中（以及部分其他虚拟机，例如 JRockit）的 intern() 实现不会再复制实例，只是在常量池中记录首次出现的实例引用。
——《深入理解 Java 虚拟机（第2版）》2.4.3 方法区和运行时常量池溢出
JDK 7（以及部分其他虚拟机，例如 JRockit）的 intern() 方法实现就不需要再拷贝字符串的实例到永久代了，既然字符串常量池已经移到 Java 堆中，那只需要在常量池里记录一下首次出现的实例引用即可。
——《深入理解 Java 虚拟机（第3版）》2.4.3 方法区和运行时常量池溢出

Q3：字符串字面量在class文件中的位置

源码经过Java编译器编译后，其中的字符串字面量以CONSTANT_String_info的形式存放在class文件的常量池（Constant Pool）中。class文件的常量池，可以通过javap -verbose命令显式查看。
示例代码（JDK1.8）

package com.demo;

public class Test {

    public static String s1 = "He";
    public String s2 = "llo";
    
    public static void main(String[] args) {
        System.out.println("Hello");
    }
}

javap -verbose编译结果

Constant pool:
   #1 = Class              #2             // com/demo/Test
   #2 = Utf8               com/demo/Test
   #3 = Class              #4             // java/lang/Object
   #4 = Utf8               java/lang/Object
   #5 = Utf8               s1
   #6 = Utf8               Ljava/lang/String;
   #7 = Utf8               s2
   #8 = Utf8               <clinit>
   #9 = Utf8               ()V
  #10 = Utf8               Code
  #11 = String             #12            // He
  #12 = Utf8               He
  #13 = Fieldref           #1.#14         // com/demo/Test.s1:Ljava/lang/String;
  #14 = NameAndType        #5:#6          // s1:Ljava/lang/String;
  #15 = Utf8               LineNumberTable
  #16 = Utf8               LocalVariableTable
  #17 = Utf8               <init>
  #18 = Methodref          #3.#19         // java/lang/Object."<init>":()V
  #19 = NameAndType        #17:#9         // "<init>":()V
  #20 = String             #21            // llo
  #21 = Utf8               llo
  #22 = Fieldref           #1.#23         // com/demo/Test.s2:Ljava/lang/String;
  #23 = NameAndType        #7:#6          // s2:Ljava/lang/String;
  #24 = Utf8               this
  #25 = Utf8               Lcom/demo/Test;
  #26 = Utf8               main
  #27 = Utf8               ([Ljava/lang/String;)V
  #28 = Fieldref           #29.#31        // java/lang/System.out:Ljava/io/PrintStream;
  #29 = Class              #30            // java/lang/System
  #30 = Utf8               java/lang/System
  #31 = NameAndType        #32:#33        // out:Ljava/io/PrintStream;
  #32 = Utf8               out
  #33 = Utf8               Ljava/io/PrintStream;
  #34 = String             #35            // Hello
  #35 = Utf8               Hello
  #36 = Methodref          #37.#39        // java/io/PrintStream.println:(Ljava/lang/String;)V
  #37 = Class              #38            // java/io/PrintStream
  #38 = Utf8               java/io/PrintStream
  #39 = NameAndType        #40:#41        // println:(Ljava/lang/String;)V
  #40 = Utf8               println
  #41 = Utf8               (Ljava/lang/String;)V
  #42 = Utf8               args
  #43 = Utf8               [Ljava/lang/String;
  #44 = Utf8               SourceFile

从javap解析结果来看，可以发现class文件的常量池（Constant Pool）中保存有源码中出现的所有字符串字面量。

参考资料

常量池中主要存放两大类常量：字面量（Literal）和符号引用（Symbolic References）。字面量比
较接近于Java语言层面的常量概念，如文本字符串、被声明为final的常量值等。
——《深入理解 Java 虚拟机（第3版）》6.3.2 常量池

Q4：字符串字面量何时进入到字符串常量池中

字符串字面量，和其他基本类型的字面量或常量不同，并不会在类加载中的解析（resolve）阶段填充并驻留在字符串常量池中，而是以特殊的形式存储在运行时常量池（Run-Time Constant Pool） 中。而是只有当此字符串字面量被调用时（如对其执行ldc字节码指令，将其添加到栈顶），HotSpot VM才会对其进行resolve，为其在字符串常量池中创建对应的String实例。

在JDK1.7的HotSpot VM中，这种还未真正解析（resolve）的String字面量，以JVM_CONSTANT_UnresolvedString的形式存放在运行时常量池中，此时并未为其创建String实例；

在JDK1.8的HotSpot VM中，这种未真正解析（resolve）的String字面量，被称为pseudo-string，以JVM_CONSTANT_String的形式存放在运行时常量池中，此时并未为其创建String实例。

在编译期，字符串字面量以**“CONSTANT_String_info”+“CONSTANT_Utf8_info”**的形式存放在class文件的 常量池（Constant Pool） 中；

在类加载之后，字符串字面量以**"JVM_CONSTANT_UnresolvedString(JDK1.7)"或者"JVM_CONSTANT_String(JDK1.8)"的形式存放在运行时常量池（Run-time Constant Pool）** 中；

在首次使用某个字符串字面量时，字符串字面量以真正的String对象的方式存放在字符串常量池（String Pool） 中。
示例代码（JDK1.8）

package com.demo;

public class Test {
    public static void main(String[] args) {
        // 堆上创建"Hello","He","llo"实例，String Pool中创建"He"和"llo"实例
        String s1 = new String("He") + new String("llo");
        // 将堆上的 "Hello"的引用存入String Pool
        s1.intern(); 
        // 获取String Pool中的 "Hello"的引用
        String s2 = "Hello"; 
        System.out.println(s1 == s2); // true
    }
}

参考资料

知乎: Java 中new String(“字面量”) 中 “字面量” 是何时进入字符串常量池的?
OpenJDK1.7 HotSpot: src/share/vm/oops/constantPoolOop.cpp
OpenJDK1.8 HotSpot: src/share/vm/oops/constantPool.cpp

Q5：new String(“Hello”);到底创建了几个对象

基于对之前问题的解答，这个问题就比较好解答了：

若此代码运行之前没有显示使用过"Hello"字面量，也没有调用某个值为"Hello"字符串对象的intern方法，那么new String(“Hello”)运行时会创建两个对象，一个在堆上，一个在字符串常量池中
若此代码运行之前已经使用过"Hello"字面量，或者调用了intern方法，在字符串常量池中创建了相同的实例或者保存了堆上相同对象的引用，那么new String(“Hello”)运行时只会创建一个对象，在堆上

注意

若在某个类的静态变量中使用了某个字符串字面量，如"Hello"，则在类加载的初始化（initialize）阶段，便会在字符串常量池中创建对应的String实例，并将其赋值给对应的静态变量
示例代码（JDK1.8）

// 1. 静态变量 s
public class Test {
    public static String s = "Hello";

    public static void main(String[] args) {
        // 堆上创建"Hello","He","llo"实例，String Pool中创建"He"和"llo"实例
        String s1 = new String("He") + new String("llo");
        // String Pool中已有"Hello"实例，故没有将s1的引用添加到String Pool中，返回的是String Pool中已有的"Hello"的引用
        s1.intern();
        // 获取String Pool中的 "Hello"的引用
        String s2 = "Hello";
        System.out.println(s1 == s2); // false
        System.out.println(s == s2); // true
    }
}

// 2. 成员变量 s
public class Test {
    String s = "Hello";

    public static void main(String[] args) {
        Test obj = new Test();
        // 堆上创建"Hello","He","llo"实例，String Pool中创建"He"和"llo"实例
        String s1 = new String("He") + new String("llo");
        // String Pool中已有"Hello"实例，故没有将s1的引用添加到String Pool中，返回的是String Pool中已有的"Hello"的引用
        s1.intern();
        // 获取String Pool中的 "Hello"的引用
        String s2 = "Hello";
        System.out.println(s1 == s2); // false
        System.out.println(obj.s == s2); // true
    }
}

// 3. 成员变量 s
public class Test {
    String s = "Hello";

    public static void main(String[] args) {
        // 堆上创建"Hello","He","llo"实例，String Pool中创建"He"和"llo"实例
        String s1 = new String("He") + new String("llo");
        // String Pool中还没有"Hello"实例，故将s1的引用添加到String Pool中
        s1.intern();
        // 获取String Pool中的 "Hello"的引用
        String s2 = "Hello";
        System.out.println(s1 == s2); // true
        Test obj = new Test();
        System.out.println(obj.s == s2); // true
    }
}

转载原文

Java字符串字面量是何时进入到字符串常量池中的

Arambler

关注

5
点赞
踩
25

收藏

觉得还不错? 一键收藏
0
评论
Java字符串常量池

Q&A字符串常量池，即String Constant Pool，又叫做String Pool，String Table。顾名思义，即用于存放字符串常量的运行时内存结构，其底层实现为一种Hashtable。其中所指的字符串常量，可以是编译期在源码中显式的字符串字面量，也可以是之后在程序运行时创建的字符串String对象。在JDK1.6及之前，字符串常量池中只会存放具体的String实例，在使用String.intern方法时，若字符串常量池中有满足String.equals方法的String对象，则返回其引用
复制链接

扫一扫