String类的Intern()方法

2018年7月16日
Error configuring application listener of class
2018年7月13日
java关键字volatile
2018年7月23日

String类的Intern()方法

public class test01 {
  public static void  main(String args[]) {

    //String str2 = "JasonZhang";
    String str1 = new String("Jason")+ new String("Zhang");    
    System.out.println(str1.intern() == str1); 
    System.out.println(str1 == "JasonZhang");
  }
}

 

运行程序后,程序输出true,ture。

我们去掉注释再运行一次:

public class test01 {
  public static void  main(String args[]) {

    String str2 = "JasonZhang";
    String str1 = new String("Jason")+ new String("Zhang");    
    System.out.println(str1.intern() == str1); 
    System.out.println(str1 == "JasonZhang");
  }
}

 

程序输出了false,false。

这是怎么回事?

这是由于intern()方法重用String对象的结果,我们继续往下看。

public class test02 {

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

}

 

这个程序很简单,注释中已经标记了程序的运行结果,我们可以发现使用intern()方法和不使用intern()方法时程序所运行的时间差距十分明显,这也说明了使用intern()比不使用intern()消耗的内存更少。

 

 

需要注意的是自JDK1.7以后,常量池被放入到堆空间中,这导致intern()函数的功能不同,具体我们来看下面代码,这个例子广泛流传于网络:

public class test03 {
  /**
   * 运行结果:
   * JDK1.6以及以下:false false
   * JDK1.7以及以上:false true
   */
  public static void main(String[] args) {
    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);
  }
}

 

public class test04 {
  /**
   * 运行结果:
   * JDK1.6以及以下:false false
   * JDK1.7以及以上:false false
   */
  public static void main(String args[]) {
    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以及以前版本中,常量池是放在 Perm 区(属于方法区)中的,这是和堆区完全分开的。(见下图,图片来自《深入理解java虚拟机》)

111

我们知道使用引号声明的String字符串会直接在常量池中生成的,而 new 出来的 String 对象放在堆空间中。所以两者的内存地址是不相同的。当我们String s = new String("str")

,再调用s.intern()后,在JDK1.6中会检查字符串池里是否存在"str"字符串,如果存在,就返回池里的字符串;如果不存在,该方法会把"str"添加到字符串池中,然后再返回它的引用。

简单的说,就是往常量池放的东西变了:原来在常量池中找不到时,复制一个副本放到常量池,1.7后则是将在堆上的地址引用复制到常量池。 

我们继续分析JDK1.7以后的程序输出内容:

public class test03 {
  /**
   * 运行结果:
   * JDK1.6以及以下:false false
   * JDK1.7以及以上:false true
   */
  
  public static void main(String[] args) {
    String s = new String("1");//生成了常量池中的“1” 和堆空间中的字符串对象s
    s.intern();//s对象去常量池中寻找后发现"1"已经存在于常量池中
    String s2 = "1";//生成一个s2的引用指向常量池中的“1”对象
    System.out.println(s == s2); //s 和 s2 的引用地址不同。因此返回了false
     
    String s3 = new String("1") + new String("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。
    System.out.println(s3 == s4);//

  }

}


public class test04 {
  /**
   * 运行结果:
   * JDK1.6以及以下:false false
   * JDK1.7以及以上:false false
   */

  public static void main(String args[]) {
    String s = new String("1");//生成了常量池中的“1” 和堆空间中的字符串对象s
    String s2 = "1";//生成一个s2的引用指向常量池中的“1”对象,已经存在,直接指向它。
    s.intern();//这一行无实际作用。因为"1"已经存在了。
    System.out.println(s == s2); //s 和 s2 的引用地址不同。因此返回了false
     
    String s3 = new String("1") + new String("1");////在字符串常量池中生成“1” ,并在堆空间中生成s3引用指向的对象(内容为"11")。注意此时常量池中是没有 “11”对象的
    String s4 = "11";//直接去生成常量池中的"11"
    s3.intern();//这一行无实际作用。因为"1"已经存在了。
    System.out.println(s3 == s4);//s3 和 s4 的引用地址不同。因此返回了false
    
  }
}

 

通过以上的讲解相信你已经对String的intern()方法有了更深的理解。希望本文对你有帮助。

常见试题解答

有了对以上的知识的了解,我们现在再来看常见的面试或笔试题就很简单了: 
Q:下列程序的输出结果: 
String s1 = “abc”; 
String s2 = “abc”; 
System.out.println(s1 == s2); 
A:true,均指向常量池中对象。根据JDK的说明,只有在两个引用都指向了同一个对象时才返回真值。

Q:下列程序的输出结果: 
String s1 = new String(“abc”); 
String s2 = new String(“abc”); 
System.out.println(s1 == s2); 
A:false,两个引用指向堆中的不同对象。只要是用new()来新建对象的,都会在堆中创建,而且其字符串是单独存值的,即使与栈中的数据相同,也不会与栈中的数据共享。 

Q:下列程序的输出结果: 
String s1 = “abc”; 
String s2 = “a”; 
String s3 = “bc”; 
String s4 = s2 + s3; 
System.out.println(s1 == s4); 
A:false,因为s2+s3实际上是使用StringBuilder.append来完成,会生成不同的对象。

Q:下列程序的输出结果: 
String s1 = “abc”; 
final String s2 = “a”; 
final String s3 = “bc”; 
String s4 = s2 + s3; 
System.out.println(s1 == s4); 
A:true,因为final变量在编译后会直接替换成对应的值,所以实际上等于s4=”a”+”bc”,而这种情况下,编译器会直接合并为s4=”abc”,所以最终s1==s4。

Q:下列程序的输出结果: 
String s = new String(“abc”); 
String s1 = “abc”; 
String s2 = new String(“abc”); 
System.out.println(s == s1.intern()); 
System.out.println(s == s2.intern()); 
System.out.println(s1 == s2.intern()); 
A:false,false,true。

发表评论

电子邮件地址不会被公开。 必填项已用*标注