字符串·常量池·

最新推荐文章于 2024-07-29 09:04:20 发布

BigDevil_

最新推荐文章于 2024-07-29 09:04:20 发布

阅读量268

点赞数 1

分类专栏： Java基础 Java学习

本文链接：https://blog.csdn.net/BigDevil_/article/details/103371021

版权

Java学习同时被 2 个专栏收录

31 篇文章 0 订阅

订阅专栏

Java基础

26 篇文章 0 订阅

订阅专栏

String类的final修饰的，以字面量的形式创建String变量时，jvm会在编译期间就把该字面量（“hello”）放到字符串常量池中，由Java程序启动的时候就已经加载到内存中了。这个字符串常量池的特点就是有且只有一份相同的字面量，如果有其它相同的字面量，jvm则返回这个字面量的引用，如果没有相同的字面量，则在字符串常量池创建这个字面量并返回它的引用
jdk1.6之前字符串常量池在方法区里
之后再堆里
。

public static void main(String[] args) {
       String s1 = "hello";
       String s2 = "hello";
       String s3 = "he" + "llo";
       String s4 = "hel" + new String("lo");
       String s5 = new String("hello");
       String s6 = s5.intern();
       String s7 = "h";
       String s8 = "ello";
       String s9 = s7 + s8;
      System.out.println(s1==s2);//true
        System.out.println(s1==s3);//true
        System.out.println(s1==s4);//false
        System.out.println(s1==s9);//false
        System.out.println(s4==s5);//false
        System.out.println(s1==s6);//true
    }

在jdk1.6,1.7,1.8下运行的结果为：
System.out.println(s1 == s2); //true
System.out.println(s1 ==s3);//true
System.out.println(s1 == s4);//false
System.out.println(s1 == s9);//false
System.out.println(s4 == s5);//false
System.out.println(s1 == s6);//true

String类的final修饰的，以字面量的形式创建String变量时，jvm会在编译期间就把该字面量（“hello”）放到字符串常量池中，由Java程序启动的时候就已经加载到内存中了。这个字符串常量池的特点就是有且只有一份相同的字面量，如果有其它相同的字面量，jvm则返回这个字面量的引用，如果没有相同的字面量，则在字符串常量池创建这个字面量并返回它的引用。由于s2指向的字面量“hello”在常量池中已经存在了（s1先于s2），于是jvm就返回这个字面量绑定的引用，所以s1 = =s2。s3中字面量的拼接其实就是“hello”，jvm在编译期间就已经对它进行优化，所以s1和s3也是相等的。s4中的new String(“lo”)生成了两个对象，“lo”，“new String(“lo”)”，"lo"存在字符串常量池，"new String(“lo”)"存在堆中，String s4 = “hel” + new String(“lo”)实质上是两个对象的相加，编译器不会进行优化，相加的结果存在堆中，而s1存在字符串常量池中，当然不相等。s1 == s9的原理一样。s4 == s5两个相加的结果都在堆中，不用说，肯定不相等。s1==s6中，s5.intern()方法能使一个位于堆中的字符串在运行期间动态地加入到字符串常量池中（字符串常量池的内容是程序启动的时候就已经加载好了），如果字符串常量池中有该对象对应的字面量，则返回该字面量在字符串常量池中的引用，否则，创建复制一份该字面量到字符串常量池并返回它的引用。因此s1==s6输出true。

不同JDK的intern()的区别

总体来说就是，之前是创建字符串副本到常量池，然后返回引用，jdk1.7 1.8是没有的话就直接引用这堆里的String对象。具体看下面解释。s

public static void main(String[] args) {
        //jdk 1.6过程，只代表注释，不代表结果
        String s1 = new String("hello");
        String intern1 = s1.intern();//在常量池里找hello，如果有返回他的引用给intern1
        String s2 = "hello";//intern1 == s2：true
        System.out.println(s1 == s2);
        //jdk1.7之后的解释
        String s3 = new String("hello") + new String("hello");
        //先找在常量池里找hello，没有就创建，返回引用到堆里的对象，返回对象引用到s3
        String intern3 = s3.intern();//在常量池里找hellohello，没有就把s3的引用放到常量池里。所以s4其实用的就是s3的引用，所以是true
        String s4 = "hellohello";
        System.out.println(s3 == s4);
    }

在jdk1.6下运行的结果为：

false,false

在jdk1.7,1.8下运行的结果为：

false,true
　　
jdk1.6下字符串常量池是在永久区中，是与堆完全独立的两个空间，s1指向堆中的内容，s2指向字符串常量池中的内容，两者当然不一样，s1.intern1()将字面量加入字符串常量池中，由于字符串常量池中已经存在该字面量，所以返回该字面量的唯一引用，intern1==s2就输出true。

jdk1.7,1.8下字符串常量池已经转移到堆中了，是堆中的一部分内容，jvm设计人员对intern()进行了一些修改，当执行s3.intern()时，jvm不再把s3对应的字面量复制一份到字符串常量池中，而是在字符串常量池中存储一份s3的引用，这个引用指向堆中的字面量，当运行到String s4 = "hellohello"时，发现字符串常量池已经存在一个指向堆中该字面量的引用，则返回这个引用，而这个引用就是s3。所以s3==s4输出true。

注意：在new String(“abc”);的时候现在常量池里找，没有就创建对象放进常量池，然后返回引用给堆。

jdk1.7之后
new String(“a”) + new String(“b”) 的时候，也会在常量池找“a”和“b”,但是不会创建“ab”,只会在堆里创建对象。

public class TestString2 {
	public static void main(String[] args) {
		String s1 = "Programming";//编译的时候就加载到了 常量池

		String s2 = new String("Programming");//创建对象，因为常量池有Programming所以，保存他的引用

		String s3 = "Program";

		String s4 = "ming";

		String s5 = "Program" + "ming";//编译时优化，获得Programming，所以s5=s1

		String s6 = s3 + s4;//两个对象相加，不会进行优化，存的是两个引用
		System.out.println(s1 == s2);//false

		System.out.println(s1 == s5); //true

		System.out.println(s1 == s6); //false

		System.out.println(s1 == s6.intern()); //true intern方法把Programming的引用赋值给s6 

		System.out.println(s2 == s2.intern()); //false 
	}
}

必备知识：
1.java 程序在运行的时候,　会创建一个字符串缓冲池。对于诸如　String s1 =“Programming”;　String s3 = “Program”;　String s4 = “ming”;　这些字符串常量，程序首先会在这个　String　缓冲池中寻找相同值的对象。若它们在池中不存在，程序则将这些字符串常量创建于池中。若在池中找到了相同值得对象，则这个找到的对象的引用，就是新变量的引用。由此可见，字符串常量池中一个给定值得对象，最多只有一个。
2.用操作符 new 创建的字符串对象，　如 String s2 = new String(“Programming”);, 或者有字符串变量、操作符 ‘+’　参与的表达式，如 String s6 = s3 + s4;　这样得到的引用，都要放到内存(堆heap)中保存。故，在堆中，若有几个值相同的对象，它们分别都会有各自的地址。
3.字符串的一个成员方法 public String intern(),返回字符串对象的规范化表示形式。当调用 intern 方法时，如果池已经包含一个等于此 String 对象的字符串（用 equals(Object) 方法确定），则返回池中的字符串。否则，将此 String 对象添加到池中，并返回此 String 对象的引用。
解释：
1.由必备知识 1,2所示，s1创建于字符串缓冲池，而s2创建于内存(堆)中，尽管二者内容都是"Programming",但地址不在一个区，故比较地址的结果为 false。
2.至于　String s5 = “Program” + “ming”;的操作，　由于表达式的两个算子都是字符串常量，所以操作始终在池内进行。在池内找到 “Program” 和 "ming"之后，将两者连接成 “Programming”, 然后，又在池内找到了相同值的对象s1，于是就将这个地址，赋予 s5。因此，比较s1 和 s5　的地址，当然相同，结果为 true。
3.如预备知识1、２所示，s6的地址，存在堆里。而s1的地址存在池里。尽管两者值相同，但地址一定不同，结果为 false。
4.如预备知识3所示，因为s6调用了它的成员方法inner()，结果返回了一个在池中的、具有相同值“Programming”的对象s1的地址。用它和 s1的地址相比较，当然相等，结果为 true。
5.如预备知识3所示，s2的地址在堆里，s2.inner()　的地址在池里。一个在堆中，一个在池内，二者比较，肯定不等，结果为false。