String 和它的 intern()

最新推荐文章于 2023-02-20 13:20:33 发布
最新推荐文章于 2023-02-20 13:20:33 发布
阅读量285 收藏
点赞数
分类专栏： Java基础 文章标签： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21586317/article/details/104242720
版权

String 和它的 intern

先做道题

Q1：定义了几个对象？

public class Q1 {
    public static void main(String[] args) {
        String s = new String("HelloWorld"); // 2 个（堆中 String 对象，常量池中字符串 "HelloWorld" 对象）
    }
}

Q2：判断下面代码输出

public class Q2 {
    public static void main(String[] args) {
        String s1 = "HelloWorld";
        String s2 = "Hello" + "World";
        String s3 = new String("HelloWorld");
        String s4 = s3.intern();
        
        System.out.println(s1 == s2); // true，都指向常量池中字符串 "HelloWorld" 对象
        System.out.println(s1 == s3); // false，符号引用 s3 指向堆中 String 对象
        System.out.println(s1 == s4); // true，都指向常量池中字符串 "HelloWorld" 对象
    }
}

一、String 字符串

String 表示字符串，不属于基本类型，但它可以像基本类型一样，直接通过字面量赋值

编译期

在编译期，符号引用和字面量会被加入到 Class 文件的常量池中，然后在类加载阶段，会进入常量池（常量池中已存在的字符串字面量不会重复添加）

常量池

Java 在内存分配中有 3种常量池：Class 常量池（静态常量池）、字符串常量池（存在于运行时常量池）、运行时常量池

  • 常量池属于线程共享数据区
  • 常量池可分为两大类：静态常量池（Class 常量池，存在于 Class 文件中）和运行时常量池
  • 运行时常量池是方法区的一部分，存放一些运行时常量数据

字符串常量池

字符串常量池存在运行时常量池之中（JDK 6 及以前，存在方法区中；从 JDK 7 开始，存在于堆中）

二、intern() 方法（JDK 1.8）

/**
 * ...
 * When the intern method is invoked, if the pool already contains a
 * string equal to this String object as determined by
 * the equals(Object) method, then the string from the pool is
 * returned. Otherwise, this String object is added to the
 * pool and a reference to this String object is returned.
 * 调用 intern 方法时，如果池中已包含由 equals 方法确定的与此 string 对象相等的字符串，则返回池中的字符串
 * 否则，此字符串对象将添加到池中，并返回对此字符串对象的引用
 * ...
 *
 * @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();

上面 String#intern() 方法的注释中，其中一段所要表达的意思很明确：“调用 intern 方法时，如果池中已包含由 equals 方法确定的与此 string 对象相等的字符串，则返回池中的字符串。否则，此字符串对象将添加到池中，并返回对此字符串对象的引用”，就是说当 String 实例调用 intern() 方法时，JVM 会在字符串常量池中查询当前字符串是否存在，若存在，返回当前字符串；若不存在，则先将当前字符串放入常量池中，之后再返回

在 JDK 6 及以前版本中，字符串常量池里放的都是字符串常量；从 JDK 7 开始，字符串常量池从方法区移到了堆中，字符串常量池中也可以存放放于堆内的字符串对象的引用

三、字符串分析（JDK 1.8）

先用双引号创建字符串，再用一个 new 创建字符串

public class Test1 {
    public static void main(String[] args) {
        String str1 = "Test1";
        String str2 = new String("Test1");
        String str3 = str2.intern();
        
        System.out.println(str1 == str2); // false
        System.out.println(str1 == str3); // true
        System.out.println(str2 == str3); // false
    }
 }

String str1 = “Test1”;
       编译期：将字面量 Test1 会被加入到 Class 文件的常量池中
       类加载阶段：字面量 Test1 会进入字符串常量池（注意：进入的条件是该常量此时不在字符串常量池，即不会重复添加相同常量）
       str1 指向字符串常量池中字符串 “Test1” 对象
String str2 = new String(“Test1”);
       编译期：在此之前字符串常量池中已存在 “Test1”，不会重复添加到字符串常量池
       运行期：在堆中创建一个 String 对象
       符号引用 str2 指向堆中创建的 String 对象
String str3 = str2.intern();
       字符串常量池中已存在 “Test1”，调用 intern() 方法，不会重复添加到字符串常量池，直接返回字符串常量池中 “Test1” 对象
       str3 指向字符串常量池中 “Test1” 对象
因此
       str1（字符串常量池中字符串 “Test1” 对象）== str2（堆中创建的 String 对象）：false
       str1（字符串常量池中字符串 “Test1” 对象）== str3（字符串常量池中字符串 “Test1” 对象）：true
       str2（堆中创建的 String 对象）== str3（字符串常量池中字符串 “Test1” 对象）：false

小结：

  • 双引号创建的字符串在字符串常量池中
  • 通过一个 new 方式创建字符串，不管该字符串是否已在字符串常量池中，intern() 调用前后两个符号引用指向的不是同一个对象

JVM 启动过程中加入常量池的字符串

上面的字符串 “Test1” 在字符串常量池中一开始并没有，但有的字符串在 JVM 启动过程中就已经存在，如：“Java”

public class Test2 {
    public static void main(String[] args) {
        String str1 = new String("ja") + new String("va");
        String str2 = str1.intern();
        String str3 = "java";
        
        System.out.println(str1 == str2); // false
        System.out.println(str1 == str3); // false
        System.out.println(str2 == str3); // true
    }
 }

String str1 = new String(“ja”) + new String(“va”);
       编译期：将字面量 ja 和 va 会被加入到 Class 文件的常量池中
       类加载阶段：字面量 ja 和 va 会进入字符串常量池
       运行期：在堆中创建三个 String 对象（两个匿名 String 对象，一个符号引号 str1 指向的 String 对象）
       str1 指向堆中创建的 String 对象
String str2 = str1.intern();
       编译期：在此之前字符串常量池中已存在 “java”，不会重复添加到字符串常量池（在 JVM 启动的时候会调用了一些方法，在常量池中会生成 “java” 等字符串常量）
       str2 指向字符串常量池中的字符串 “java” 对象
String str3 = “java”;
       编译期：在此之前字符串常量池中已存在 “Test1”，不会重复添加到字符串常量池
       str3 指向字符串常量池中的字符串 “java” 对象
因此
       str1（堆中创建的 String 对象）== str2（字符串常量池中的字符串 “java” 对象）：false
       str1（堆中创建的 String 对象）== str3（字符串常量池中的字符串 “java” 对象）：false
       str2（字符串常量池中的字符串 “java” 对象）== str3（字符串常量池中的字符串 “java” 对象）：true

小结：

  • 特殊情况：在 JVM 启动的时候会调用了一些方法，在常量池中会生成 “java” 等字符串常量（正常情况：下方 “### 先用两个 new 创建字符串”）
  • JVM 启动过程中加入常量池的字符串，调用 intern() 方法，指向字符串常量池中的字符串对象

先用一个 new 创建字符串

public class Test3 {
    public static void main(String[] args) {
        // 情况一
        String s1 = new String("Test3_1");
        String s2 = s1.intern(); // intern() 在双引号之前调用
        String s3 = "Test3_1";
        System.out.println(s1 == s2); // false
        System.out.println(s1 == s3); // false
        System.out.println(s2 == s3); // true
        
        System.out.println();
        
        // 情况二
        String s4 = new String("Test3_2");
        String s5 = "Test3_2";
        String s6 = s4.intern(); // intern() 在双引号之后调用
        System.out.println(s4 == s5); // false
        System.out.println(s4 == s6); // false
        System.out.println(s5 == s6); // true
    }
}

情况一
       符号引号 s1 指向堆中创建的 String 对象（字符串内容是 “Test3_1”）
       符号引用 s2 指向字符串常量池中的字符串 “Test3_1” 对象
       符号引用 s3 指向字符串常量池中的字符串 “Test3_1” 对象
情况二
       符号引号 s4 指向堆中创建的 String 对象（字符串内容是 “Test3_2”）
       符号引用 s5 指向字符串常量池中的字符串 “Test3_2” 对象
       符号引用 s6 指向字符串常量池中的字符串 “Test3_2” 对象
因此
       s1（堆中创建的 String 对象，字符串内容是 “Test3_1”）== s2（字符串常量池中的字符串 “Test3_1” 对象）：fasle
       s1（堆中创建的 String 对象，字符串内容是 “Test3_1”）== s3（字符串常量池中的字符串 “Test3_1” 对象）：fasle
       s2（字符串常量池中的字符串 “Test3_1” 对象）== s3（字符串常量池中的字符串 “Test3_1” 对象）：true

       s4（堆中创建的 String 对象，字符串内容是 “Test3_2”）== s5（字符串常量池中的字符串 “Test3_2” 对象）：fasle
       s4（堆中创建的 String 对象，字符串内容是 “Test3_2”）== s6（字符串常量池中的字符串 “Test3_2” 对象）：fasle
       s5（字符串常量池中的字符串 “Test3_2” 对象）== s6（字符串常量池中的字符串 “Test3_2” 对象）：true

小结：

  • 通过一个 new 方式创建字符串，不管该字符串是否已在字符串常量池中，intern() 前后两个符号引用指向的不是同一个对象

先用两个 new 创建字符串

public class Test4 {
    public static void main(String[] args) {
        // 情况一
        String s1 = new String("Test4_1") + new String("Test4_1");
        String s2 = s1.intern(); // intern() 在双引号之前调用
        String s3 = "Test4_1Test4_1";
        System.out.println(s1 == s2); // true
        System.out.println(s1 == s3); // true
        System.out.println(s2 == s3); // true
        
        System.out.println();
        
        // 情况二
        String s4 = new String("Test4_2") + new String("Test4_2");
        String s5 = "Test4_2Test4_2";
        String s6 = s4.intern(); // intern() 在双引号之后调用
        System.out.println(s4 == s5); // false
        System.out.println(s4 == s6); // false
        System.out.println(s5 == s6); // true
    }
}

情况一
       符号引号 s1 指向堆中创建的 String 对象（字符串内容是 “Test4_1Test4_1”）
       符号引用 s2 指向字符串常量池中的引用，该引用指向 s1 引用的对象
       符号引用 s3 指向字符串常量池中的引用，该引用指向 s1 引用的对象
情况二
       符号引号 s4 指向堆中创建的 String 对象（字符串内容是 “Test4_2Test4_2”）
       符号引用 s5 指向字符串常量池中的字符串 “Test4_2Test4_2” 对象
       符号引用 s6 指向字符串常量池中的字符串 “Test4_2Test4_2” 对象
因此
       s1（堆中创建的 String 对象，字符串内容是 “Test4_1Test4_1”）== s2（字符串常量池中的一个引用，该引用指向 s1 引用的对象）：true
       s1（堆中创建的 String 对象，字符串内容是 “Test4_1Test4_1”）== s3（字符串常量池中的一个引用，该引用指向 s1 引用的对象）：true
       s2（字符串常量池中的一个指向 s1 的引用）== s3（字符串常量池中的一个指向 s1 的引用）：true

       s4（堆中创建的 String 对象，字符串内容是 “Test4_2Test4_2”）== s5（字符串常量池中的字符串 “Test4_2Test4_2” 对象）：fasle
       s4（堆中创建的 String 对象，字符串内容是 “Test4_2Test4_2”）== s6（字符串常量池中的字符串 “Test4_2Test4_2” 对象）：fasle
       s5（字符串常量池中的字符串 “Test4_2Test4_2” 对象）== s6（字符串常量池中的字符串 “Test4_2Test4_2” 对象）：true

小结：

  • JDK 1.7 及以后，多个字符串变量拼接的字符串（如：通过两个 new 创建字符串），intern() 方法调用前，常量池中不存在拼接后的字符串
  • JDK 1.7 及以后，多个字符串变量拼接的字符串（如：通过两个 new 创建字符串），intern() 方法调用后，常量池中不需要再存储一份对象了，可以直接存储堆中的引用（String#intern 方法时，如果存在堆中的对象，会直接保存对象的引用，而不会重新创建对象）

四、总结

  • JDK 1.7 及以后，字符串常量池从方法区移动到了堆中
  • 双引号创建的字符串在字符串常量池中
  • 通过一个 new 方式创建字符串，不管该字符串是否已在字符串常量池中，intern() 调用前后两个符号引用指向的不是同一个对象（调用 intern() 前后分别是：堆中 String 对象、字符串常量池中对应字符串对象）
  • 特殊情况：在 JVM 启动的时候会调用了一些方法，在常量池中会生成 “java” 等字符串常量
  • JVM 启动过程中加入常量池的字符串，调用 intern() 方法，指向字符串常量池中的字符串对象
  • 通过一个 new 方式创建字符串，不管该字符串是否已在字符串常量池中，intern() 前后两个符号引用指向的不是同一个对象
  • JDK 1.7 及以后，多个字符串变量拼接的字符串（如：通过两个 new 创建字符串），intern() 方法调用前，常量池中不存在拼接后的字符串
  • JDK 1.7 及以后，多个字符串变量拼接的字符串（如：通过两个 new 创建字符串），intern() 方法调用后，常量池中不需要再存储一份对象了，可以直接存储堆中的引用（调用 String#intern() 方法时，如果存在堆中的对象，会直接在字符串常量池中保存堆中对象的引用，而不会重新创建字符串对象）
韭菜鲜肉大馄饨
关注
专栏目录
String以及intern()的使用
qq_47102228的博客
11-30 284
String的基本特性 String:字符串，使用- -对""引起来表示。 String声明为final的，不可被继承 String实现了Serializable接口:表示字符串是支持序列化的。    实现了Comparable接口:表示String可以比较大小 String在jdk8及以前内部定义了final char[] value用 于存储字符串数据。jdk9时改为byte[]。基于String的相关类也做了一定的修改：AbstractStringBuilder、StringBuffe
String.intern()方法
nore的博客
08-06 211
补充：String.intern()方法 ​ intern方法用来返回常量池中的某字符串，如果常量池中已经存在该字符串，则直接返回常量池中该对象的引用。否则，在常量池中加入该对象，然后返回引用。 先做基本了解 intern（）判断这个常量是否存在于常量池。   (1)如果存在    1.1判断存在内容是引用还是常量，     如果是引用，      返回引用地址指向堆空间对象，     如果是常量...
String与Intern
qq_27185561的博客
09-28 161
String与Intern String.intern()是一个Native方法,它的作用是:如果字符常量池中已经包含一个等于此String对象的字符串,则返回常量池中字符串的引用,否则,将新的字符串放入常量池,并返回新字符串的引用,不同版本的JAVA虚拟机对此方法的实现可能不同 https://blog.csdn.net/tyyking/article/details/82496901 ...
每天记录学习的新知识 ：String和String.intern()实现原理
嗯...
05-25 364
简介 String.intern() 方法可以使得所有含相同内容的字符串都共享同一个内存对象，减少内存中相同字符串的数量，节省一些内存空间。 注意：字符串常量池中的 String 对象，也是可以被 GC 回收的，只要它不再被引用了。 intern原理分析 注：本文基于JDK8分析 ,如有错误，欢迎指出，非常感谢。 1. new String() String str1 = new Stri...
深入理解String和intern方法
林竹清_清清清
06-23 453
定义字符串：String str=”abc”;  和String str=new String(“abc”); 的区别： String str="abc"; String str1=new String("abc"); String str2="abc"; System.out.println(str); System.out.println(str1)
C#中字符串优化String.Intern、IsInterned详解
08-28
C#中字符串优化String.Intern、IsInterned详解 C#中字符串优化是指在编程过程中对字符串进行优化，以减少内存占用和提高...通过使用String.Intern和String.IsInterned方法，可以减少内存占用，提高程序的运行效率。
jdk1.8之后的String.intern()方法内存分析
01-20
关于String.intern()方法，这个问题都被问烂了，有的文章在分析的时候还在用jdk1.7，jdk1.8之后内存模型发生了变化，内存的变化也会影响intern方法的执行，这里有必要写文章分析一下，请大家务必从头开始看，这样...
关于java String中intern的深入讲解
08-26
Java String 中的 intern 方法是一个非常重要的概念，它可以将字符串对象存储在字符串常量池中，以便重复使用相同的字符串对象，减少内存的占用。下面我们将深入讲解 Java String 中 intern 的相关知识点。 什么是 ...
实战干货|String字符串intern()方法底层原理剖析
一一哥
11-11 1165
Hello，大家好，最近又是一年求职季。有不少小伙伴私聊壹哥，问壹哥知道String的intern()方法不？这不，就来活了。今天壹哥就给大家谈谈String的intern()方法，让我们一起来看看这究竟是个什么玩意？难道是科技与狠活？我们先上一段代码： 大家猜猜上面代码的输出结果是什么？true还是false？321，你猜对了吗？这里的输出结果是：false！上面的结果是为什么呢？为了搞清楚这个问题，我们看看需要了解一下intern()方法的内部原理。其实大家可以将String的intern()方法，
Java String的intern用法解析
08-25
今天，我们将深入探究Java String的intern用法解析，了解它的工作原理和应用场景。 Java String的intern方法 在Java中，每个String对象都有一个唯一的标识符，这个标识符是通过String对象的intern方法获取的。...
理解String.intern()
我是泛滥
12-04 250
在翻《深入理解Java虚拟机》的书时，又看到了2-7的 String.intern()返回引用的测试。 其实要搞明白String.intern()，我总结了下面几条规则： 一、new String都是在堆上创建字符串对象。当调用 intern() 方法时，编译器会将字符串添加到常量池中（stringTable维护），并返回指向该常量的引用。 二、通过字面量赋值创建字符串（如：String str=”twm”）时，会先在常量池中查找是否存在相同的字符串，若存在，则将栈中的引用直接指向该字符串；若不存在，则
Java之关于String字符串笔试面试重点
qq_64580912的博客
02-20 1390
我们学习过了字符串的不可变性,进入到change方法之后,字符数组直接在堆进行改变,而对字符串的改变,直接产生了新的字符串,str指向了新的地址,而主方法里的str指向的还是原来的地址,所以最后输出。第二个s1==s2,因为值为"abc"已经存在与常量池中了,不会将s2对象置入到常量池中,但是结果的返回值为s1的地址,此时令s2=s2.intern(),s2的地址便与s1的地址相同。这样一段代码,改变的是s1的引用,它的指向一直在改变,不断指向新的字符串常量。的时候,就会产生字符常量,放入到常量池中。
String的intern()方法浅析
tianyuzui6的博客
04-27 1万+
String.intern()方法是一种手动将字符串加入常量池中的native方法，原理如下：如果在当前类的常量池中存在与调用intern()方法的字符串等值的字符串，就直接返回常量池中相应字符串的引用，否则在常量池中复制一份该字符串（Jdk7中会直接在常量池中保存当前字符串的引用），并将其引用返回；因此，只要是堆中等值的String对象，使用intern()方法返回的都是常量池中同一个String引用，所以，这些等值的String对象通过intern()后使用==是可以匹配的。
String str1="abc"; String str2=new String("abc");
thedays_withyou的博客
03-23 3003
Java中以下两句有什么区别呢？String str1="abc"; String str2=new String("abc");Java把内存划分成两种：一种是栈内存，一种是堆内存。 在函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配。 当在一段代码块定义一个变量时，Java就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java会自动释放掉为该变量所分配的内存
几张图轻松理解String.intern()
热门推荐
tyyking的博客
09-07 4万+
https://blog.csdn.net/soonfly/article/details/70147205 在翻《深入理解Java虚拟机》的书时，又看到了2-7的 String.intern()返回引用的测试。 其实要搞明白String.intern()，我总结了下面几条规则： 一、new String都是在堆上创建字符串对象。当调用 intern() 方法时，编译器会将字符串添加到常量池中（...
你可能不知道的String类
lebronchen的博客
07-14 302
一直很喜欢一句话，如果你不能向一个六岁的孩子解释清楚，那么其实你自己根本没弄懂。这句话很适合我们这些技术人，程序员的世界里不应该出现模糊的概念，遇到一些拿捏不准的东西需要及时理解透彻。 String类是我们每天需要使用到无数次的对象，工作中直接拿来用就好了，很少会再去细细的琢磨琢磨String，这里就带大家一起琢磨琢磨String。 String的内存分配 String是一个不可变的对象...
String、StringBuffer、StringBuilder的特性851376263
weixin_49329785的博客
08-07 345
String类:字符串是常量，使用一对""引起来表示。他们的值在创建之后不能修改。 1.String声明为final的，不可被继承 2.String实现了Serializable接口，表示字符串时支持序列化的。 实现了Comparable接口：表示String可以比较大小 3.String内部定义了final char[] value用于存储字符串数据 4.String:代表不可变的字符序列。简称：不可变性体现：1.当对字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行.......
Java中String str1 = “Java”和String str2 = New String（“Java”）两种声明方式之间的区别
SmartAnt_5658的专栏
06-27 6325
我们知道，对象间的比较可通过“==”运算符和“equals（）”方法两种方式进行，“==”运算符用于比较两个对象的内存地址的值是否相等，而“equals（）”方法则是用比较两个对象的内容是否一致。在这里，str1与str3相等，说明str1和str3是指向同一个内存空间的。如下图所示：如下图所示：...
String intern
最新发布
08-24
使用 intern() 方法可以节省内存，因为它可以确保同一个内容的字符串只有一个对象存在于常量池中。这对于比较字符串内容是否相等非常有用，可以直接使用 "==" 操作符进行比较，而不需要使用 equals() 方法。 例如，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值