intern_internet - CSDN
精华内容
参与话题
  • 对String中intern()方法的认识

    千次阅读 2018-03-16 23:54:59
    最近在看字符串相关知识的时候,又看到了关于字符串创建方式和是否相等的相关问题,回忆起之前碰到的一个String中的intern()方法,它是一个本地方法(由Java语言外的语言编写),因此在jdk1.8源码中没有其实现,不过...

    最近在看字符串相关知识的时候,又看到了关于字符串创建方式和是否相等的相关问题,回忆起之前碰到的一个String中的intern()方法,它是一个本地方法(由Java语言外的语言编写),因此在jdk1.8源码中没有其实现,不过有一段描述,讲述了它的作用。
    intern()方法的描述

        /**
         * Returns a canonical representation for the string object.
         * <p>
         * A pool of strings, initially empty, is maintained privately by the
         * class {@code String}.
         * <p>
         * When the intern method is invoked, if the pool already contains a
         * string equal to this {@code String} object as determined by
         * the {@link #equals(Object)} method, then the string from the pool is
         * returned. Otherwise, this {@code String} object is added to the
         * pool and a reference to this {@code String} object is returned.
         * <p>
         * It follows that for any two strings {@code s} and {@code t},
         * {@code s.intern() == t.intern()} is {@code true}
         * if and only if {@code s.equals(t)} is {@code true}.
         * <p>
         * All literal strings and string-valued constant expressions are
         * interned. String literals are defined in section 3.10.5 of the
         * <cite>The Java&trade; Language Specification</cite>.
         *
         * @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();

    归纳一下的话,它的作用在jdk1.7之后是查看常量池中是否存在和调用方法的字符串内容一样的字符串,如果有的话,就返回该常量池中的字符串,若没有的话,就在常量池中写入一个堆中该字符串对象的一个引用,指向堆中的该对象,并返回该引用。
    用代码说话吧,注释中有我对intern()方法的理解,过程中查阅了部分源码和相关博客,如果有谬误,请大家指出,互相交流学习,共同进步。
    intern方法的测试

    public class InternTest {
        public static void main(String[] args) {
            String a = new String("abc");
            // 第一次,创建了两个对象,一个是堆中的string对象,一个是常量池中的"abc"
            String b = new String("abc");
            // 第二次,创建一个对象,堆中的另外一个string对象
            System.out.println(a.intern() == b.intern());// true
            System.out.println(a.intern() == b);// false
            System.out.println(a.intern() == a);// false
            /*
             * intern方法会到常量池中查找是否存在该对象,如果存在,返回该对象。不存在的话就创建该对象并返回该对象(jdk1.6),(jdk1.7)
             * 会在常量池中存一个指向堆中的那个对象的引用。 不存在往往是String s3 = new String("1") + new
             * String("1");这种形式,会在堆中有一个s3指向的11的对象和常量池中的1对象
             * 在这里就是体现的堆中的内存地址不一样,但对应的同一个常量池中的string 第一个比较时常量池中的该对象和自身比较
             * 下面两个比较则是常量池中的对象和堆中的两个对象进行比较
             */
            String poolstr = "abc";
            // 直接从字符串常量池中获取
            System.out.println(a.intern() == poolstr);// true
            System.out.println(b.intern() == poolstr);// true
            /*
             * 这里新声明并赋值了一个poolstr,值为常量池中的字符串"abc",将它和a.intern()和b.inten()比较就是和自身比较
             */
            String str = new String("a") + new String("b");
            System.out.println(str.intern() == str);// true
            /*
             * str创建了3个对象,在堆中有一个"ab",在常量池中有一个"a"和"b" 比较str.intern()和str会得到true
             * 在jdk1.7之后,会在常量池中存一个指向堆中的那个对象的引用。
             * 调用str.intern()会在常量池中存储一个指向堆中"ab"的引用,也就是说它和堆中的对象实际是等价的,因此==时返回true
             */
            String strtwo = "ab";
            System.out.println(strtwo == str);// true
            /*
             * 常量池中已存在ab,所以会直接将strtwo指向常量池中的"ab",即堆中str对象的引用,因此相等
             */
        }
    }

    其中有提到一个new String(“”)会创建几个对象,一般就是一个或两个,主要是看常量池中是否已经有了该字符串,在上述代码在也有所提及。
    对于每一个比较语句我都做了自己的理解的标注,比较通俗易懂,仔细看一下就能理解intern方法的作用,另外附上一篇博文,是一篇讲述intern方法的实现原理的博文,对我理解intern方法有很大帮助,感兴趣的朋友可以看一下。
    Java技术——你真的了解String类的intern()方法吗
    其中提到了jdk1.7将常量池从方法区中转移到堆中对intern()方法的影响,非常清晰的描述了差别,配合本博文实例更适宜使用,本博文更多的从实现角度来解析intern()方法,希望对您有所帮助
    如有谬误,敬请指正。
    欢迎讨论。

    展开全文
  • 浅谈String.intern()方法

    万次阅读 多人点赞 2018-07-14 22:43:33
    1.String类型“==”比较样例代码如下:package com.luna.test; public class StringTest { public static void main(String[] args) { String str1 = "abc"; String str2 = "abc"... ...

    1.String类型“==”比较样例代码如下:

    package com.luna.test;
    public class StringTest {
    	public static void main(String[] args) {
    	String str1 = "todo";
            String str2 = "todo";
            String str3 = "to";
            String str4 = "do";
            String str5 = str3 + str4;
            String str6 = new String(str1);
    
            System.out.println("------普通String测试结果------");
            System.out.print("str1 == str2 ? ");
            System.out.println( str1 == str2);
            System.out.print("str1 == str5 ? ");
            System.out.println(str1 == str5);
            System.out.print("str1 == str6 ? ");
            System.out.print(str1 == str6);
            System.out.println();
    
            System.out.println("---------intern测试结果---------");
            System.out.print("str1.intern() == str2.intern() ? ");
            System.out.println(str1.intern() == str2.intern());
            System.out.print("str1.intern() == str5.intern() ? ");
            System.out.println(str1.intern() == str5.intern());
            System.out.print("str1.intern() == str6.intern() ? ");
            System.out.println(str1.intern() == str6.intern());
            System.out.print("str1 == str6.intern() ? ");
            System.out.println(str1 == str6.intern());
    	}
    }

          代码运行结果如下所示:

    ------普通String测试结果------
    str1 == str2 ? true
    str1 == str5 ? false
    str1 == str6 ? false
    ---------intern测试结果---------
    str1.intern() == str2.intern() ? true
    str1.intern() == str5.intern() ? true
    str1.intern() == str6.intern() ? true
    str1 == str6.intern() ? true

          普通String代码结果分析:Java语言会使用常量池保存那些在编译期就已确定的已编译的class文件中的一份数据。主要有类、接口、方法中的常量,以及一些以文本形式出现的符号引用,如类和接口的全限定名、字段的名称和描述符、方法和名称和描述符等。因此在编译完Intern类后,生成的class文件中会在常量池中保存“todo”、“to”和“do”三个String常量。变量str1和str2均保存的是常量池中“todo”的引用,所以str1==str2成立;在执行 str5 = str3 + str4这句时,JVM会先创建一个StringBuilder对象,通过StringBuilder.append()方法将str3与str4的值拼接,然后通过StringBuilder.toString()返回一个堆中的String对象的引用,赋值给str5,因此str1和str5指向的不是同一个String对象,str1 == str5不成立;String str6 = new String(str1)一句显式创建了一个新的String对象,因此str1 == str6不成立便是显而易见的事了。

    2.String.intern()使用原理

          String.intern()是一个Native方法,底层调用C++的 StringTable::intern方法实现。当通过语句str.intern()调用intern()方法后,JVM 就会在当前类的常量池中查找是否存在与str等值的String,若存在则直接返回常量池中相应Strnig的引用;若不存在,则会在常量池中创建一个等值的String,然后返回这个String在常量池中的引用。因此,只要是等值的String对象,使用intern()方法返回的都是常量池中同一个String引用,所以,这些等值的String对象通过intern()后使用==是可以匹配的。由此就可以理解上面代码中------intern------部分的结果了。因为str1、str5和str6是三个等值的String,所以通过intern()方法,他们均会指向常量池中的同一个String引用,因此str1.intern() == str5.intern() == str6.intern()均为true。

    3.String.intern() in JDK6

          Jdk6中常量池位于PermGen(永久代)中,PermGen是一块主要用于存放已加载的类信息和字符串池的大小固定的区域。执行intern()方法时,若常量池中不存在等值的字符串,JVM就会在常量池中创建一个等值的字符串,然后返回该字符串的引用。除此以外,JVM 会自动在常量池中保存一份之前已使用过的字符串集合。Jdk6中使用intern()方法的主要问题就在于常量池被保存在PermGen中:首先,PermGen是一块大小固定的区域,一般不同的平台PermGen的默认大小也不相同,大致在32M到96M之间。所以不能对不受控制的运行时字符串(如用户输入信息等)使用intern()方法,否则很有可能会引发PermGen内存溢出;其次String对象保存在Java堆区,Java堆区与PermGen是物理隔离的,因此如果对多个不等值的字符串对象执行intern操作,则会导致内存中存在许多重复的字符串,会造成性能损失。

    4.String.intern() in JDK7

          Jdk7将常量池从PermGen区移到了Java堆区,执行intern操作时,如果常量池已经存在该字符串,则直接返回字符串引用,否则复制该字符串对象的引用到常量池中并返回。堆区的大小一般不受限,所以将常量池从PremGen区移到堆区使得常量池的使用不再受限于固定大小。除此之外,位于堆区的常量池中的对象可以被垃圾回收。当常量池中的字符串不再存在指向它的引用时,JVM就会回收该字符串。可以使用 -XX:StringTableSize 虚拟机参数设置字符串池的map大小。字符串池内部实现为一个HashMap,所以当能够确定程序中需要intern的字符串数目时,可以将该map的size设置为所需数目*2(减少hash冲突),这样就可以使得String.intern()每次都只需要常量时间和相当小的内存就能够将一个String存入字符串池中。

    5.intern()适用场景

          Jdk6中常量池位于PermGen区,大小受限,所以不建议适用intern()方法,当需要字符串池时,需要自己使用HashMap实现。Jdk7、8中,常量池由PermGen区移到了堆区,还可以通过-XX:StringTableSize参数设置StringTable的大小,常量池的使用不再受限,由此可以重新考虑使用intern()方法。intern()方法优点:执行速度非常快,直接使用==进行比较要比使用equals()方法快很多;内存占用少。虽然intern()方法的优点看上去很诱人,但若不是在恰当的场合中使用该方法的话,便非但不能获得如此好处,反而还可能会有性能损失。下面程序对比了使用intern()方法和未使用intern()方法存储100万个String时的性能,从输出结果可以看出,若是单纯使用intern()方法进行数据存储的话,程序运行时间要远高于未使用intern()方法时:

    public class InternTest {
        public static void main(String[] args) {
            print("noIntern: " + noIntern());
            print("intern: " + intern());
        }
    
        private static long noIntern(){
            long start = System.currentTimeMillis();
            for (int i = 0; i < 1000000; i++) {
                int j = i % 100;
                String str = String.valueOf(j);
            }
            return System.currentTimeMillis() - start;
        }
    
        private static long intern(){
            long start = System.currentTimeMillis();
            for (int i = 0; i < 1000000; i++) {
                int j = i % 100;
                String str = String.valueOf(j).intern();
            }
            return System.currentTimeMillis() - start;
        }
    }

          程序运行结果:

    noIntern: 48    // 未使用intern方法时,存储100万个String所需时间
    intern: 99      // 使用intern方法时,存储100万个String所需时间

          由于intern()操作每次都需要与常量池中的数据进行比较以查看常量池中是否存在等值数据,同时JVM需要确保常量池中的数据的唯一性,这就涉及到加锁机制,这些操作都是有需要占用CPU时间的,所以如果进行intern操作的是大量不会被重复利用的String的话,则有点得不偿失。由此可见,String.intern()主要 适用于只有有限值,并且这些有限值会被重复利用的场景,如数据库表中的列名、人的姓氏、编码类型等。

    6.总结:

          String.intern()方法是一种手动将字符串加入常量池中的方法,原理如下:如果在常量池中存在与调用intern()方法的字符串等值的字符串,就直接返回常量池中相应字符串的引用,否则在常量池中复制一份该字符串,并将其引用返回(Jdk7中会直接在常量池中保存当前字符串的引用);Jdk6 中常量池位于PremGen区,大小受限,不建议使用String.intern()方法,不过Jdk7 将常量池移到了Java堆区,大小可控,可以重新考虑使用String.intern()方法,但是由对比测试可知,使用该方法的耗时不容忽视,所以需要慎重考虑该方法的使用;String.intern()方法主要适用于程序中需要保存有限个会被反复使用的值的场景,这样可以减少内存消耗,同时在进行比较操作时减少时耗,提高程序性能。

    展开全文
  • Java技术——你真的了解String类的intern()方法吗

    万次阅读 多人点赞 2016-08-23 16:40:53
    0.引言 什么都先不说,先看下面这个引入的例子: ...System.out.println(str1.intern() == str1); System.out.println(str1 == "SEUCalvin"); 本人JDK版本1.8,输出结果为: tru...

     

    0.引言

    什么都先不说,先看下面这个引入的例子:

    String str1 = new String("SEU")+ new String("Calvin");    
    System.out.println(str1.intern() == str1); 
    System.out.println(str1 == "SEUCalvin");
    

    本人JDK版本1.8,输出结果为:

    true
    true

    再将上面的例子加上一行代码:

    String str2 = "SEUCalvin";//新加的一行代码,其余不变
    String str1 = new String("SEU")+ new String("Calvin");    
    System.out.println(str1.intern() == str1); 
    System.out.println(str1 == "SEUCalvin"); 

    再运行,结果为:

    false
    false

    是不是感觉莫名其妙,新定义的str2好像和str1没有半毛钱的关系,怎么会影响到有关str1的输出结果呢?其实这都是intern()方法搞的鬼!看完这篇文章,你就会明白。o(_)o 

    说实话我本来想总结一篇Android内存泄漏的文章的,查阅了很多资料,发现不得不从JavaOOM讲起,讲JavaOOM又不得不讲Java的虚拟机架构。如果不了解JVM的同学可以查看此篇 JVM——Java虚拟机架构。(这篇文章已经被我修改过N多次了,个人感觉还是挺全面清晰的,每次看都会有新的理解。)

    JVM架构一文中也有介绍,在JVM运行时数据区中的方法区有一个常量池,但是发现在JDK1.6以后常量池被放置在了堆空间,因此常量池位置的不同影响到了Stringintern()方法的表现。深入了解后发现还是值得写下来记录一下的。为了确保文章的实时更新,实时修改可能出错的地方,请确保这篇是原文,而不是无脑转载来的“原创文”,原文链接为:SEU_Calvin的博客

     

    1.为什么要介绍intern()方法

    intern()方法设计的初衷,就是重用String对象,以节省内存消耗。这么说可能有点抽象,那么就用例子来证明。

    static final int MAX = 100000;
    static final String[] arr = new String[MAX];
    
    public static void main(String[] args) throws Exception {
    	//为长度为10的Integer数组随机赋值
    	Integer[] sample = new Integer[10];
    	Random random = new Random(1000);
    	for (int i = 0; i < sample.length; i++) {
    	    sample[i] = random.nextInt();
    	}
    	//记录程序开始时间
    	long t = System.currentTimeMillis();
    	//使用/不使用intern方法为10万个String赋值,值来自于Integer数组的10个数
    	    for (int i = 0; i < MAX; i++) {
    	        arr[i] = new String(String.valueOf(sample[i % sample.length]));
    	        //arr[i] = new String(String.valueOf(sample[i % sample.length])).intern();
    	    }
    	    System.out.println((System.currentTimeMillis() - t) + "ms");
    	    System.gc();
    }

    这个例子也比较简单,就是为了证明使用intern()比不使用intern()消耗的内存更少

    先定义一个长度为10Integer数组,并随机为其赋值,在通过for循环为长度为10万的String对象依次赋值,这些值都来自于Integer数组。两种情况分别运行,可通过Window ---> Preferences --> Java --> Installed JREs设置JVM启动参数为-agentlib:hprof=heap=dump,format=b,将程序运行完后的hprof置于工程目录下。再通过MAT插件查看该hprof文件。
    两次实验结果如下:

    从运行结果来看,不使用intern()的情况下,程序生成了101762String对象,而使用了intern()方法时,程序仅生成了1772String对象。自然也证明了intern()节省内存的结论

    细心的同学会发现使用了intern()方法后程序运行时间有所增加。这是因为程序中每次都是用了new String后又进行intern()操作的耗时时间,但是不使用intern()占用内存空间导致GC的时间是要远远大于这点时间的。 

     

    2.深入认识intern()方法

    JDK1.7后,常量池被放入到堆空间中,这导致intern()函数的功能不同,具体怎么个不同法,且看看下面代码,这个例子是网上流传较广的一个例子,分析图也是直接粘贴过来的,这里我会用自己的理解去解释这个例子:

    String s = new String("1");
    s.intern();
    String s2 = "1";
    System.out.println(s == s2);
    
    String s3 = new String("1") + new String("1");
    s3.intern();
    String s4 = "11";
    System.out.println(s3 == s4);

    输出结果为:

    JDK1.6以及以下:false false
    JDK1.7以及以上:false true
    

    再分别调整上面代码2.3行、7.8行的顺序:

    String s = new String("1");
    String s2 = "1";
    s.intern();
    System.out.println(s == s2);
    
    String s3 = new String("1") + new String("1");
    String s4 = "11";
    s3.intern();
    System.out.println(s3 == s4);
    

    输出结果为:

    JDK1.6以及以下:false false
    JDK1.7以及以上:false false

    下面依据上面代码对intern()方法进行分析:

     

    2.1 JDK1.6

     

    JDK1.6中所有的输出结果都是 false,因为JDK1.6以及以前版本中,常量池是放在 Perm 区(属于方法区)中的,熟悉JVM的话应该知道这是和堆区完全分开的

    使用引号声明的字符串都是会直接在字符串常量池中生成的,而 new 出来的 String 对象是放在堆空间中的。所以两者的内存地址肯定是不相同的,即使调用了intern()方法也是不影响的。如果不清楚String类的“==”和equals()的区别可以查看我的这篇博文Java面试——从Java堆、栈角度比较equals和==的区别

    intern()方法在JDK1.6中的作用是:比如String s = new String("SEU_Calvin"),再调用s.intern(),此时返回值还是字符串"SEU_Calvin",表面上看起来好像这个方法没什么用处。但实际上,在JDK1.6中它做了个小动作:检查字符串池里是否存在"SEU_Calvin"这么一个字符串,如果存在,就返回池里的字符串;如果不存在,该方法会把"SEU_Calvin"添加到字符串池中,然后再返回它的引用。然而在JDK1.7中却不是这样的,后面会讨论。

     

    2.2 JDK1.7

    针对JDK1.7以及以上的版本,我们将上面两段代码分开讨论。先看第一段代码的情况:

    再把第一段代码贴一下便于查看:

    String s = new String("1");
    s.intern();
    String s2 = "1";
    System.out.println(s == s2);
    
    String s3 = new String("1") + new String("1");
    s3.intern();
    String s4 = "11";
    System.out.println(s3 == s4);

    String s = newString("1"),生成了常量池中的“1” 和堆空间中的字符串对象

    s.intern(),这一行的作用是s对象去常量池中寻找后发现"1"已经存在于常量池中了

    String s2 = "1",这行代码是生成一个s2的引用指向常量池中的“1”对象

    结果就是 s s2 的引用地址明显不同。因此返回了false。

     

    String s3 = new String("1") + newString("1"),这行代码在字符串常量池中生成“1” ,并在堆空间中生成s3引用指向的对象(内容为"11")。注意此时常量池中是没有 “11”对象的。

    s3.intern(),这一行代码,是将 s3中的“11”字符串放入 String 常量池中,此时常量池中不存在“11”字符串,JDK1.6的做法是直接在常量池中生成一个 "11" 的对象。

    但是在JDK1.7中,常量池中不需要再存储一份对象了,可以直接存储堆中的引用。这份引用直接指向 s3 引用的对象也就是说s3.intern() ==s3会返回true。

    String s4 = "11", 这一行代码直接去常量池中创建,但是发现已经有这个对象了,此时也就是指向 s3 引用对象的一个引用因此s3 == s4返回了true

     

    下面继续分析第二段代码:

    再把第二段代码贴一下便于查看:

    String s = new String("1");
    String s2 = "1";
    s.intern();
    System.out.println(s == s2);
    
    String s3 = new String("1") + new String("1");
    String s4 = "11";
    s3.intern();
    System.out.println(s3 == s4);

    String s = newString("1"),生成了常量池中的“1” 和堆空间中的字符串对象

    String s2 = "1",这行代码是生成一个s2的引用指向常量池中的“1”对象,但是发现已经存在了,那么就直接指向了它

    s.intern(),这一行在这里就没什么实际作用了。因为"1"已经存在了。

    结果就是 s  s2 的引用地址明显不同。因此返回了false。

     

    String s3 = new String("1") + newString("1"),这行代码在字符串常量池中生成“1” ,并在堆空间中生成s3引用指向的对象(内容为"11")。注意此时常量池中是没有 “11”对象的。

    String s4 = "11", 这一行代码直接去生成常量池中的"11"

    s3.intern(),这一行在这里就没什么实际作用了。因为"11"已经存在了。

    结果就是 s3  s4 的引用地址明显不同。因此返回了false。

     

    3 总结

    终于要做Ending了。现在再来看一下开篇给的引入例子,是不是就很清晰了呢。

    String str1 = new String("SEU") + new String("Calvin");      
    System.out.println(str1.intern() == str1);   
    System.out.println(str1 == "SEUCalvin");  
    

    str1.intern() == str1就是上面例子中的情况,str1.intern()发现常量池中不存在“SEUCalvin”,因此指向了str1 "SEUCalvin"在常量池中创建时,也就直接指向了str1了。两个都返回true就理所当然啦。

    那么第二段代码呢:

    String str2 = "SEUCalvin";//新加的一行代码,其余不变
    String str1 = new String("SEU")+ new String("Calvin");    
    System.out.println(str1.intern() == str1); 
    System.out.println(str1 == "SEUCalvin"); 

    也很简单啦,str2先在常量池中创建了“SEUCalvin”,那么str1.intern()当然就直接指向了str2,你可以去验证它们两个是返回的true。后面的"SEUCalvin"也一样指向str2。所以谁都不搭理在堆空间中的str1了,所以都返回了false。

     

    好了,本篇对intern的作用以及在JDK1.6和1.7中的实现原理的介绍就到此为止了。希望能给你带来帮助。转载请注明出处http://blog.csdn.net/seu_calvin/article/details/52291082

     

     

    展开全文
  • String中intern方法的作用

    万次阅读 多人点赞 2018-05-23 20:25:06
    读完这篇文章你可以了解,String在虚拟机内存中的存放,intern方法到底有什么用,这么多String对象的创建到底有什么区别,String 创建的对象有几个!! 进入正题 我们需要先了解一下 String str=”abc”;和 ...

    前言

    读完这篇文章你可以了解,String对象在虚拟机内存中的存放,intern的作用,这么多String对象的创建到底有什么区别,String 创建的对象有几个!!

    进入正题

    先科普几个知识点

    1.常量池存放于方法区中

    2.jdk1.6 方法区放在永久代(java堆的一部分),jdk1.7以后特别将字符串常量池移动到了的堆内存中(使用参数-XX:PermSize 和-XX:MaxPermSize指定大小)。所以导致string的intern方法因为以上变化在不同版本会有不同表现。

    1. jdk1.6将Hotspot虚拟机使用永久代来实现方法区,因为方法区的内存回收跟堆内存回收其实没什么区别,这样实现可以用垃圾收集器来管理这部分内存,但这样容易导致内存溢出(达到-XX:MaxPermSize)。
      这里写图片描述

    JDK1.6,JDK1.7常量池的存放如下都存放于堆内存中
    这里写图片描述
    JDK1.8常量池的存放如下
    在这里插入图片描述
    具体可参考:https://blog.csdn.net/zhyhang/article/details/17246223/

    知道了常量池在内存中的存放后,我们需要先了解一下 String str=“abc”;和 String str =new String(“abc”);的区别

    1.String str=“abc”;

    JDK1.6
    (1) 当常量池中不存在"abc"这个字符串的引用,在堆内存中new一个String对象,复制这个对象加入常量池,返回常量池中的对象。
    这里写图片描述

    (2) 当常量池中存在"abc"这个字符串对象,str指向这个对象的引用;

    这里写图片描述

    JDK1.7以上
    (1) 当常量池中不存在"abc"这个字符串的引用,在堆内存中new一个新的String对象,将这个对象的引用加入常量池。(跟1.6的区别是常量池不再存放对象,只存放引用。)
    (2) 当常量池中存在"abc"这个字符串的引用,str指向这个引用;

    2.String str =new String(“abc”)

    单纯的在堆内存中new一个String对象,通过StringBuilder 跟StringBuffer 构建的对象也是一样。

    Tips:在这里可能有一些争议的点。虽然说是单纯的创建,但是请不要忘记我们用来创建对象的 "abc"是字符串,这个字符串第一次声明的情况下是会被加入常量池中的。

    3.intern方法 (1.7版本,返回常量池中该字符串的引用)

    (1) 当常量池中不存在"abc"这个字符串的引用,将这个对象的引用加入常量池,返回这个对象的引用。
    (2) 当常量池中存在"abc"这个字符串的引用,返回这个对象的引用;

    测试代码如下

            String str1 = "计算机";
            String str2 = "计算机";
            System.out.println("str1==str2:" + (str1 == str2));
            
            String str3 = new String("计算机");
            System.out.println("str1==str3:" + (str1 == str3));
            System.out.println("str1==str3.intern():" + (str1 == str3.intern()));
            System.out.println("str2==str3.intern():" + (str2 == str3.intern()));
            
            String str4 = new String("计算机");
            System.out.println("str3==str4:" + (str3 == str4));
            System.out.println("str3.intern()==str4.intern():" + (str3.intern() == str4.intern()));
    
    
            String str5 = new StringBuilder("软件").append("工程").toString();
            System.out.println("str5.intern() == str5:" + (str5.intern() == str5));
    
            String str6 = new String(new StringBuilder("物联网").append("工程").toString());
            System.out.println("str6.intern() == str6:" + (str6.intern() == str6));
    
            String str7 = new String("物联网");
            System.out.println("str7.intern() == str7:" + (str7.intern() == str7));
    

    JDK1.8输出结果如下:

    str1==str2:true
    str1==str3:false
    str1==str3.intern():true
    str2==str3.intern():true
    str3==str4:false
    str3.intern()==str4.intern():true
    str5.intern() == str5:true
    str6.intern() == str6:true
    str7.intern() == str7:false
    

    这里着重讲解一下为什么str5,str6和str7的结果不一样,

    str7直接用new String(“物联网”)创建,"物联网"这字符串在一出现就自动创建成对象存放到常量池中,所以常量池里面存放的是"物联网"字符串的引用,并不是str7创建的对象的引用。

    str5是通过StringBuilder构建的 在new StringBuilder(“软件”).append(“工程”).toString方法运行后,"软件工程"这个字符串对象才第一次出现。执行了intern方法后str5才被放到常量池中,此时str5跟str5.intern是同一个对象。

    str6是作为对照组出现,这里为了确认StringBuilder 在toString方法执行后会不会把最终字符串放进常量池。很显然并没有,所以str6的intern才会跟str6是同一个对象。同时它也能验证出str7的new String()方式在初始化的时候就会把"物联网"字符串放进常量池中,同理我们可以得出在str5构建的时候常量池里面加入了"软件","工程"这两个字符串(可以自己动手去验证一下!!)。

    JDK1.7结果如下

    str1==str2:true
    str1==str3:false
    str1==str3.intern():true
    str2==str3.intern():true
    str3==str4:false
    str3.intern()==str4.intern():true
    str5.intern() == str5:true
    str6.intern() == str6:true
    str7.intern() == str7:false
    

    当然JDK1.6我们也能大致明确,输出结果会如下

    str1==str2:true
    str1==str3:false
    str1==str3.intern():true
    str2==str3.intern():true
    str3==str4:false
    str3.intern()==str4.intern():true
    str5.intern() == str5:false
    str6.intern() == str6:false
    str7.intern() == str7:false
    

    分析一下jdk1.6中 str5.intern() == str5的结果为什么为false,这里可以这么看在软件工程这个对象中构建完成之后,常量池里面其实存放的只有“软件”,"工程"这两个字符串,而"软件工程"这个字符串是存放于堆内存中的。所以JDK1.6执行了intern后会把“软件工程”复制到常量池中,并返回常量池中的对象。常量池中的"软件工程"跟堆内存中的软件工程并不是同一个。

    因为没有尝试过,如果jdk1.6有不一致的地方欢迎大家指点。

    总结

    1.String对象可能会在堆内存中分配一块空间创建一个String对象,在常量池中创建该对象的复制jdk 1.6(或引用jdk 1.7及以上),也可能直接指向常量池(永久带)中的引用(例String str=“xxx”)。还有一种可能是直接在堆内存中分配一块空间创建一个String对象(例 String str=new String(xxx))。

    2.intern方法可以看成返回常量池中该字符串对象的引用。如果没有该字符串对象就把这个对象(或引用)加到常量池。

    3.jdk1.6跟jdk1.7以上的区别是当常量池中不存在这个字符串,jdk1.6是直接复制对象到常量池,而jdk1.7以上是把对象的引用加入常量池。

    4.类似于”abc”这样的字符串,在第一次被使用到(比如String a=”abc”或者String a=new String(“abc”)或者"abc".equals(xxx))后就会被加载到常量池中去。

    5.面试问题:

    (1)现在当有人问 String str = new String(“abc”);创建了几个对象,常量池有abc字段是1个,常量池没有"abc"字段则是2个。
    (2)String str=“abc”;创建了几个对象(如果常量池里面已经有对象了就是0个。如果没有就是1个);
    (3)new String(“abc”).intern();创建了几个对象(如果常量池里面已经有该字符串对象了就是1个,如果没有就是两个)

    以上是关于String中intern的作用和个人对于内存的一些理解,希望大家有所收获,也期待和大家交流。

    展开全文
  • intern()详解

    2020-08-12 21:57:28
    jdk1.7之后的intern()方法的作用: 1、若是字符串常量池中不存在这个字符串,那么,就创建一个引用,把该字符串实例对象的引用复制过来,并返回该地址。 2、若是字符串常量池中已存在该字符串,那么直接返回该字符串...
  • String方法的intern()方法

    千次阅读 2019-01-05 15:57:57
    引言  在 JAVA 语言中有8中基本类型和一种比较特殊的类型String。这些类型为了使他们在运行过程中速度更快,更节省内存,都提供了一种常量池的概念。常量池就类似一个JAVA系统级别提供的缓存。...
  • intern() 方法

    千次阅读 2018-05-24 13:22:47
    intern() 方法返回字符串对象的规范化表示形式。 它遵循以下规则:对于任意两个字符串 s 和 t,当且仅当 s.equals(t) 为 true 时,s.intern() == t.intern() 才为 true。 具体不做介绍,请看引用:...
  • 几张图轻松理解String.intern()

    万次阅读 多人点赞 2017-04-12 20:35:49
    在翻《深入理解Java虚拟机》的书时,又看到了2-7的 String.intern()返回引用的测试。 其实要搞明白String.intern(),我总结了下面几条规则: 一、new String都是在堆上创建字符串对象。当调用 intern() 方法时,...
  • java1.8 intern方法

    千次阅读 2019-07-10 18:15:34
    请问下面两个输出是什么? 答案是: 对于s1 ...第一步:s1,首先会在常量池查找hello和word,没有就创建,然后new String,在堆中创建"hello"和"word"字面的对象,然后相加在堆创建...第二步,s1.intern(),此时常量池没...
  • JAVA中intern()方法的详解

    千次阅读 2018-02-02 16:00:17
    很多童鞋可能在Java考试中或者笔试中遇到String字符串比较相等的问题,今天就来谈一谈 在JAVA虚拟机中,有运行时数据区,包含线程共享的:堆,方法区 和线程隔离的:程序计数器,Java虚拟机栈,本地方法栈....String.intern()
  • 【举例解释】在调用”ab”.intern()方法的时候会返回”ab”,但是这个方法会首先检查字符串池中是否有”ab”这个字符串,如果存在则返回这个字符串的引用,否则就将这个字符串添加到字符串池中,然会返回这个字符串...
  • JDK1.8中String类的intern()方法学习

    万次阅读 2020-04-06 22:35:43
    jdk1.8字符串常量池是位于堆中; 在jdk1.8中使用如下指令时会同时在堆中和常量池(前提是常量池中还没有该对象)中创建字符串对象,但是s是指向堆中。 String s = new String("HELLO");...s.intern...
  • String.intern()详细分析,JDK1.8

    万次阅读 多人点赞 2018-11-01 12:19:13
      String.intern()分析在文中偏后 一.创建字符串分析 1.直接使用双引号创建字符串  判断这个常量是否存在于常量池,   如果存在,    判断这个常量是存在的引用还是常量,     如果是引用,返回引用地址...
  • 深入解析String#intern

    千次阅读 2014-03-06 17:10:00
    引言 在 JAVA 语言中有8中基本类型和一种比较特殊的类型String。这些类型为了使他们在运行过程中速度更快,更节省内存,都提供了一种常量池的概念。常量池就类似一个JAVA系统级别提供的缓存。 8种基本类型的常量池都...
  • String,intern()有关的那点事儿

    千次阅读 2018-07-23 10:14:37
    String,是Java中除了基本数据类型以外,最为重要的一个类型了。很多人会认为他比较简单。...Q2:如何理解String的intern方法? 上面这两个是面试题和String相关的比较常考的,很多人一般都知道答案。 A1...
  • String的Intern方法详解 引言  在 JAVA 语言中有8中基本类型和一种比较特殊的类型String。这些类型为了使他们在运行过程中速度更快,更节省内存,都提供了一种常量池的概念。常量池就类似一个JAVA系统级别提供的...
  • 关于String类的intern()方法详解
  • 转载自 深入解析String中的intern引言在 JAVA 语言中有8中基本类型和一种比较特殊的类型String。这些类型为了使他们在运行过程中速度更快,更节省内存,都提供了一种常量池的概念。常量池就类似一个JAVA系统级别...
  • String类的intern()方法

    2019-02-13 14:51:44
    0.引言 什么都先不说,先看下面这个引入的例子: [java]&amp;amp;nbsp;view plain&amp;amp;nbsp;copy String&amp;amp;nbsp;str1&amp;amp;nbsp;...amp
  • 关于字符串的比较在前面文章中已经详解过,本篇文章基于字符串常量池的存储及在使用intern方法时所引起的内存变化进行一步深层次的讲解。 重点内容:当字符串调用intern方法后,再进行字符串的比较,会发生什么变化...
1 2 3 4 5 ... 20
收藏数 36,400
精华内容 14,560
关键字:

intern