public class com.qjc.construction.Test
  minor version: 0
  major version: 51
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #7.#27         // java/lang/Object."<init>":()V
   #2 = Class              #28            // com/qjc/construction/Test
   #3 = Methodref          #2.#27         // com/qjc/construction/Test."<init>":()V
   #4 = Methodref          #2.#29         // com/qjc/construction/Test.test:()I
   #5 = Fieldref           #30.#31        // java/lang/System.out:Ljava/io/PrintStream;
   #6 = Methodref          #32.#33        // java/io/PrintStream.println:(Ljava/lang/Object;)V
   #7 = Class              #34            // java/lang/Object
   #8 = Utf8               <init>
   #9 = Utf8               ()V
  #10 = Utf8               Code
  #11 = Utf8               LineNumberTable
  #12 = Utf8               LocalVariableTable
  #13 = Utf8               this
  #14 = Utf8               Lcom/qjc/construction/Test;
  #15 = Utf8               test
  #16 = Utf8               ()I
  #17 = Utf8               a
  #18 = Utf8               I
  #19 = Utf8               b
  #20 = Utf8               c
  #21 = Utf8               main
  #22 = Utf8               ([Ljava/lang/String;)V
  #23 = Utf8               args
  #24 = Utf8               [Ljava/lang/String;
  #25 = Utf8               SourceFile
  #26 = Utf8               Test.java
  #27 = NameAndType        #8:#9          // "<init>":()V
  #28 = Utf8               com/qjc/construction/Test
  #29 = NameAndType        #15:#16        // test:()I
  #30 = Class              #35            // java/lang/System
  #31 = NameAndType        #36:#37        // out:Ljava/io/PrintStream;
  #32 = Class              #38            // java/io/PrintStream
  #33 = NameAndType        #39:#40        // println:(Ljava/lang/Object;)V
  #34 = Utf8               java/lang/Object
  #35 = Utf8               java/lang/System
  #36 = Utf8               out
  #37 = Utf8               Ljava/io/PrintStream;
  #38 = Utf8               java/io/PrintStream
  #39 = Utf8               println
  #40 = Utf8               (Ljava/lang/Object;)V

int a = 1;
int b = 2;
int c = "abcdefg";
int d = "abcdefg";

String s = "qjc";  // s指向常量池中的引用

String s1 = new String("qjc");  // s1指向內(nèi)存中的對象引用

String s1 = new String("qjc");   
String s2 = s1.intern();

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

/**
 * @author qijianchun
 * @title: TestPool
 * @projectName 
 * @description: TODO JDK8:-Xms6M -Xmx6M -XX:MetaspaceSize=10M -XX:MaxMetaspaceSize=10M
 * @description: TODO JDK6:-Xms6M -Xmx6M -XX:PermSize=6M -XX:MaxPermSize=6M
 * @date 2021/4/1313:02
 */
public class TestPool {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<String>();
        for (int i = 0; i < 10000000; i++) {
            String str = String.valueOf(i).intern();
            list.add(str);
        }
    }
}

String s1 = new String("he") + new String("llo");
String s2 = s1.intern();
 
System.out.println(s1 == s2);
// 在 JDK 1.6 下輸出是 false，創(chuàng)建了 6 個對象
// 在 JDK 1.7 及以上的版本輸出是 true，創(chuàng)建了 5 個對象
// 當(dāng)然我們這里沒有考慮GC，但這些對象確實存在或存在過

String s0="qjc";
String s1="qjc";
String s2="qj" + "c";
System.out.println( s0==s1 ); //true
System.out.println( s0==s2 ); //true

String s0="qjc";
String s1=new String("qjc");
String s2="qj" + new String("c");
System.out.println( s0==s1 );// false
System.out.println( s0==s2 );// false
System.out.println( s1==s2 );// false

String a = "a1";
String b = "a" + 1;
System.out.println(a == b); // true

String a1 = "atrue";
String b1 = "a" + "true";
System.out.println(a1 == b1); // true

String a2 = "a3.4";
String b2 = "a" + 3.4;
System.out.println(a2 == b2); // true

String a = "ab";
String bb = "b";
String b = "a" + bb;
System.out.println(a == b); // false

String a = "ab";
final String bb = "b";
String b = "a" + bb;

System.out.println(a == b); // true

String a = "ab";
final String bb = getBB();
String b = "a" + bb;

System.out.println(a == b); // false

private static String getBB() 
{  
    return "b";  
 }

String  s  =  "a" + "b" + "c";  //就等價于String s = "abc";
String  a  =  "a";
String  b  =  "b";
String  c  =  "c";
String  s1  =   a  +  b  +  c;

StringBuilder temp = new StringBuilder();
temp.append(a).append(b).append(c);
String s = temp.toString(); 

//字符串常量池："計算機"和"技術(shù)"     堆內(nèi)存：str1引用的對象"計算機技術(shù)"  
//堆內(nèi)存中還有個StringBuilder的對象，但是會被gc回收，StringBuilder的toString方法會new String()，這個String才是真正返回的對象引用
String str2 = new StringBuilder("計算機").append("技術(shù)").toString();   //沒有出現(xiàn)"計算機技術(shù)"字面量，所以不會在常量池里生成"計算機技術(shù)"對象
System.out.println(str2 == str2.intern());  //true
//"計算機技術(shù)" 在池中沒有，但是在heap中存在，則intern時，會直接返回該heap中的引用

//字符串常量池："ja"和"va"     堆內(nèi)存：str1引用的對象"java"  
//堆內(nèi)存中還有個StringBuilder的對象，但是會被gc回收，StringBuilder的toString方法會new String()，這個String才是真正返回的對象引用
String str1 = new StringBuilder("ja").append("va").toString();    //沒有出現(xiàn)"java"字面量，所以不會在常量池里生成"java"對象
System.out.println(str1 == str1.intern());  //false
//java是關(guān)鍵字，在JVM初始化的相關(guān)類里肯定早就放進字符串常量池了

String s1=new String("test");  
System.out.println(s1==s1.intern());   //false
//"test"作為字面量，放入了池中，而new時s1指向的是heap中新生成的string對象，s1.intern()指向的是"test"字面量之前在池中生成的字符串對象

String s2=new StringBuilder("abc").toString();
System.out.println(s2==s2.intern());  //false
//同上

        //5種整形的包裝類Byte,Short,Integer,Long,Character的對象，
        //在值小于127時可以使用對象池
        Integer i1 = 127;  //這種調(diào)用底層實際是執(zhí)行的Integer.valueOf(127)，里面用到了IntegerCache對象池
        Integer i2 = 127;
        System.out.println(i1 == i2);//輸出true
       
       //值大于127時，不會從對象池中取對象
        Integer i3 = 128;
        Integer i4 = 128;
        System.out.println(i3 == i4);//輸出false
 	   //用new關(guān)鍵詞新生成對象不會使用對象池
        Integer i5 = new Integer(127);
        Integer i6 = new Integer(127);
        System.out.println(i5 == i6);//輸出false
     

        //Boolean類也實現(xiàn)了對象池技術(shù)
        Boolean bool1 = true;
        Boolean bool2 = true;
        System.out.println(bool1 == bool2);//輸出true

       //浮點類型的包裝類沒有實現(xiàn)對象池技術(shù)
        Double d1 = 1.0;
        Double d2 = 1.0;
        System.out.println(d1 == d2);//輸出false