String.intern方法怎么用

這篇文章給大家分享的是有關String.intern方法怎么用的內(nèi)容。小編覺得挺實用的，因此分享給大家做個參考，一起跟隨小編過來看看吧。

記錄創(chuàng)建String的兩種方式，"" 和 new String()區(qū)別，String intern方法的使用和常量池。

• String的使用 (Jdk1.8)

  代碼

  package com.com.string;
  
  /**
   * @Auther: lantao
   * @Date: 2019-04-15 13:53
  
   * @maill: lan_tao@suixingpay.com
   * @Description: TODO
   */
  public class StringTest {
      public static void main(String[] args) {
          // 使用 "" 創(chuàng)建  會直接存儲在 常量池中
          String a = "lantao";
          // 使用 new String 創(chuàng)建， 會將zahngsan存儲到常量池中，然后在Heap中創(chuàng)建對象指向b
          String b = new String("zhangsan");
          // 使用 字符串連接符拼接 ，會直接存儲 'wangwuzhaoliu' 字符串在常量池中
          String c = "wangwu" + "zhaoliu";
          // 使用字符串 "引用" 拼接 ，不執(zhí)行 intern 方法，不會存放到常量池中，但是會將 --- 存入到常量池中
          String d = a + "---";
          // 使用 new String 拼接 ，不執(zhí)行 intern 方法，不會存放到常量池中，但是會將wang 和 jiu 兩個字符串存到常量池中
          String f = new String("wang") + "jiu";
          // 使用 new String 拼接 ，不執(zhí)行 intern 方法，不會存放到常量池中， 但是會將 zhao 和 ba 兩個字符串存入到常量池中
          String g = new String("zhao") + new String("ba");
      }
  }

  
  

  解釋

  String 拼接

• 字符串拼接

  public class StringTest {
      public static void main(String[] args) {
          String a = "lan" + "tao";
      }
  }

  
  

  lan 和 tao 都是字符串，都是在編譯器可知的，編譯器會將這行代碼優(yōu)化，當一個字符串是由多個可知的字符串(非引用字符串)連接組成，將會優(yōu)化為如下。

  public class StringTest {
      public static void main(String[] args) {
        String a = "lantao";  
      }
  }

  
  

  JVM會將字符串"lantao"放入到String常量池中。

• 引用拼接：

  public class StringTest {
      public static void main(String[] args) {
          String a = "lan";
        	String b = a + "tao";
        	// 上下含義相同
        	String c = "zhang";
        	String d = "san";
        	String f = c + d;
      }
  }

  
  

  當Java編譯器遇到字符串引用 或 字符串引用和可知字符串拼接的時候，會創(chuàng)建一個StringBuilder對象，后面的append()。

  因為有字符串引用存在，而引用的值在程序編譯期是無法確定的。另外 "lan"、"tao" 都會編譯器添加到字符串常量池中（如果沒有的話），因為它們都是編譯期確定的字符串常量，但是最后的"lantao"并不會添加到字符串常量池, 除非執(zhí)行b.intern() 方法

• final拼接

  public class StringTest {
      public static void main(String[] args) {
          final String a = "lan";
       		final String b = "tao";
        	String c = a + b + "2019";
      }
  }

  
  

  final拼接和以上兩者的區(qū)別就是在前邊增加了final修飾，用final修飾的字符串就是在編譯期可知的，編譯期就會將以上代碼優(yōu)化為

  public class StringTest {
      public static void main(String[] args) {
  				String str = "lantao2019";
      }
  }

  
  

  這里 final 拼接的效果是和字符串拼接是一致的。

• 變量a： "lantao" 是字符串常量，在編譯期就被確定了，先檢查字符串常量池中是否含有"lantao"字符串,若沒有則添加"lantao"到字符串常量池中，并且直接指向它。所以a直接指向字符串常量池的”lantao”,也就是變量a指向的地址是常量池中的 lantao。

• 變量b：用new String() 創(chuàng)建的字符串不是常量，不能在編譯期就確定，所以new String() 創(chuàng)建的字符串不放入常量池中，它們有自己的地址空間(Java Heap 中)，變量b的引用的地址在Java Heap中。 但是"zhangsan"字符串常量在編譯期也會被加入到字符串常量池（如果常量池不存在的話）。

• 變量c："wangwu"和"zhaoliu"也都是字符串常量，當一個字符串由多個字符串常量連接而成時，它自己肯定也是字符串常量，在編譯器會被編譯器優(yōu)化成"wangwuzhaoliu"，所以c也同樣在編譯期就被解析為一個字符串常量，并且c是常量池中”wangwuzhaoliu”的一個引用，所以變量c的引用地址在常量池中。

• 變量d： JVM對于字符串引用，由于在字符串的”+”連接中，有字符串引用存在，而引用的值在程序編譯期是無法確定的，即`(a+"---")

• 變量f： 變量f同樣不能在編譯期確定，但是"wang"和"jiu"這兩個字符串常量會添加到字符串常量池中，并且在堆中創(chuàng)建String對象。（字符串常量池并不會存放"wangjiu"這個字符串,除非執(zhí)行f.intern()方法）

• 變量g： 同理變量f。

• String#intern方法

  intern方法詳解

  String.intern()是一個Native(本地)方法，它的作用是如果字符串常量池已經(jīng)包含一個等于此String對象的字符串，則返回字符串常量池中這個字符串的引用, 否則將當前String對象的引用地址（堆中）添加到字符串常量池中并返回。

  使用

  注意：基本數(shù)據(jù)類型之間的 == 是比較值，引用數(shù)據(jù)類型 == 比較的是地址值

• 常量池中存在字符串

  public class StringTest {
      public static void main(String[] args) {
        	// 基本數(shù)據(jù)類型之間的 ==  是比較值，引用數(shù)據(jù)類型 == 比較的是地址值
        	// 1：在Java Heap中創(chuàng)建對象 2：在字符串常量池中添加 zhangsan
          String a = new String("zhangsan");
        	// 調(diào)用 intern 方法，因上一步中已經(jīng)將zhangsan存入常量池中，這里直接返回常量池 zhangsan 的引用地址
          String b = a.intern();
        	// a 的地址在Java Heap中 ， b的地址在 常量池中 ，所以結果是flase
          System.out.println(a == b);
        	// 因為常量池中已經(jīng)包含zhangsan，所以直接返回
          String c = "zhangsan";
          // b c 的地址一致，所以是true
          System.out.println(b == c);
      }
  }
  
  //結果
  false
  true

  
  

  解釋：

  1：在Java Heap中創(chuàng)建對象然后在字符串常量池中添加 zhangsan。

  2：調(diào)用 intern 方法，因上一步中已經(jīng)將zhangsan存入常量池中，這里直接返回常量池 zhangsan 的引用地址。

  3：因 a 的地址在Heap中，b的地址在字符串常量池中。

  4：因為常量池中已經(jīng)包含zhangsan，所以直接返回

  5： b c 的地址一致，所以是true

  地址可以使用System.identityHashCode(a)方法獲取

• 常量池中不存在字符串

  public class StringTest {
      public static void main(String[] args) {
        	//1： 首先會在Heap中創(chuàng)建對象，然后在常量池中放入zhagnsan 和 wangwu ，但是并不會放入zhagnsanwangwu
          String a = new String("zhangsan") + "wangwu";
        	// 2：調(diào)用 intern ，因為字符串常量池中沒有”zhangsanwangwu”這種拼接后的字符串，所以將堆中String對象的引用地址添加到字符串常量池中。jdk1.7后常量池引入到了Heap中，所以可以直接存儲引用
          String b = a.intern();
        	// 3：因為 a 的地址和 b的地址一致，鎖以是true
          System.out.println(a == b);
  
        	//4：因常量池中已經(jīng)存在 zhangsanwangwu 了，所以直接返回引用就是 a 類型 a ==b 鎖 a==b==c
          String c = "zhangsanwangwu";
          System.out.println(a == c); // true
        	System.out.println(b == c); // true
  
        	// 5：首先會在Heap中創(chuàng)建對象，然后會在常量池中存儲 zhang 和 san
        	String d = new String("zhang") + "san";
        	// 6： 返回的是 常量池中的 地址，因在a變量時已經(jīng)將 zhangsan 放入到了常量池中
        	String f = d.inter();
        	System.out.println(d = f); // false
      }
  }

  
  

  解釋：

  1：首先會在Heap中創(chuàng)建對象a，然后在常量池中放入zhagnsan 和 wangwu** ，但是并不會放入zhagnsanwangwu。

  2：調(diào)用 intern ，因為字符串常量池中沒有”zhangsanwangwu”這種拼接后的字符串，所以將堆中String對象的引用地址添加到字符串常量池中。jdk1.7后常量池引入到了Heap中，所以可以直接存儲引用。

  3：因為 a 的地址和 b的地址一致，所以是true。

  4：因常量池中已經(jīng)存在 zhangsanwangwu 了，所以直接返回引用就是 a 類型， a ==b 所以 a==b==c。

  5：首先會在Heap中創(chuàng)建對象d，然后會在常量池中存儲 zhang 和 san。

  6：因在創(chuàng)建對象a時，已經(jīng)將 "zhangsan"放入到了常量池，所以返回的是常量池中的zhangsan地址，對象d的地址在Heap中，f的地址在常量池中，并不是一個，所以false；

感謝各位的閱讀！關于“String.intern方法怎么用”這篇文章就分享到這里了，希望以上內(nèi)容可以對大家有一定的幫助，讓大家可以學到更多知識，如果覺得文章不錯，可以把它分享出去讓更多的人看到吧！