1、常量
字面量包括：1.文本字符串 2.八种基本类型的值 3.被声明为final的常量等;
符号引用包括：1.类和方法的全限定名 2.字段的名称和描述符 3.方法的名称和描述符。
2、常量池分类
类文件常量池：又称为静态常量池，存储区域在堆中，编译时产生对应的class文件，主要包含字面量和符号引用；
运行时常量池：存在元数据（Meta Space）空间，JVM运行时，在类加载完成后，将每个class常量池中的符号引用转换为直接引用；
字符串常量池：存在堆内存中，类在加载、验证、准备完成后在堆中生成字符串对象实例，然后将该字符串对象实例的引用只存储到String Pool中，String Pool是一个StringTable类，是哈希表结果，里面存储的是字符串引用，具体的实例对象存储在堆中，这个stringtable表在每个hotspot中的实例只有一份，被所有类共享。
基本类型包装类常量池：
3、运行时常量池
运行时常量池是方法区元数据区的一部分。Class 文件中除了有类的版本、字段、方法、接口等描述信息外，还有常量池表（用于存放编译期生成的各种字面量和符号引用）。
1、JDK1.7之前版本运行时常量池包含字符串常量池位于方法区。
2、JDK1.7版本字符串常量池位置从方法区搬到了堆中； 运行时常量池还在方法区。
3、JDK1.8hotspot永久代被元空间(Metaspace)取代, 字符串常量池位置还在堆中, 运行时常量池位置变成了元空间(Metaspace)。
4、字符串常量池
1 package com.javabasic.str;
2
3 public class StringTest1 {
4
5 public static void main(String[] args) {
6 //对象创建两种方式
7 //第一种：创建了几个对象呢？ 1个或2个 第一个对象:如果常量池中已有"abc"直接返回引用，如果不存在就创建一个；第二个对象:在堆内存中new的String对象。
8 String s1 = new String("abc");//s1指向堆内存对象的引用地址
9
10 //第二种：堆内存字符常量池（首先检查字符串常量池中是否存在，如果存在则直接引用，不存在添加进入）
11 String s2 = "abc";//指向字符串常量池引用
12 String s3 = "abc";//指向字符串常量池引用
13 System.out.println(s1==s2);//false
14 System.out.println(s2==s3);//true
15 System.out.println("1>>>>>>>>>>>>>>>");
16
17 String s4 = new String("hello");//s4指向堆内存地址的引用地址
18 s4.intern();//调用intern方法，查询字符常量池是否存在字符串，如果不存在就放入字符常量池，如果存在返回地址引用
19 String s5 = "hello";
20 System.out.println(s4==s5);//false
21 System.out.println("2>>>>>>>>>>>>>>>");
22
23 //字符串拼接
24 String s6_1 = "123" + "123";//在字符串常量池创建
25 String s6_2 = new String("123") + new String("123");//在堆内存中创建
26 String s7 = "123123";
27 System.out.println(s6_1==s6_2);//false
28 System.out.println(s6_1==s7);//true
29 System.out.println(s6_2==s7);//false
30 System.out.println("3>>>>>>>>>>>>>>>");
31
32 String s8 = new String("456") + "4561";//在字符串常量池创建
33 String s9 = "4564561";
34 System.out.println(s8==s9);//false
35 System.out.println("4>>>>>>>>>>>>>>>");
36
37 final String s10 = "abc";
38 final String s11 = new String("abc");
39 System.out.println("s1与s10：" + (s1 == s10));// false
40 System.out.println("s1与s11：" + (s1 == s11));// false
41 }
42
43 }String.intern() 是一个 Native 方法，它的作用是：
如果运行时常量池中已经包含一个等于此 String 对象内容的字符串，则返回常量池中该字符串的引用；
如果没有，
JDK1.7之前（不包含1.7）的处理方式是在常量池中创建与此 String 内容相同的字符串，并返回常量池中创建的字符串的引用；
JDK1.7以及之后的处理方式是在常量池中记录此字符串的引用，并返回该引用。
5、基本类型包装类常量池
Java 基本类型的包装类的大部分都实现了常量池技术，即 Byte,Short,Integer,Long,Character,Boolean。
前面 4 种包装类默认创建了数值[-128，127] 的相应类型的缓存数据，
Character创建了数值在[0,127]范围的缓存数据，
Boolean 直接返回True Or False。
两种浮点数类型的包装类 Float,Double 没有实现常量池技术。
1 package com.javabasic.str;
2
3 import java.lang.Integer.IntegerCache;
4
5 /**
6 * 默认创建了数值[-128，127] 的相应类型的缓存数据
7 * @author wangymd
8 *
9 */
10 public class IntegerTest1 {
11
12 public static void main(String[] args) {
13 Integer i1 = 40;//Java 在编译的时候会直接将代码封装成 Integer i1=Integer.valueOf(40);，从而使用常量池中的对象。
14 Integer i2 = 40;//常量池
15 Integer i3 = 0;
16 Integer i4 = new Integer(40);//这种情况下会在堆中创建新的对象
17 Integer i5 = new Integer(40);//堆内存
18 Integer i6 = new Integer(0);
19
20 Integer i7 = i2 + i3;//因为+这个操作符不适用于 Integer 对象，首先 i5 和 i6 进行自动拆箱操作，进行数值相加
21 Integer i8 = i5 + i6;
22 Integer i9 = new Integer(128);
23 Integer i10 = new Integer(128);
24
25 Integer i11 = Integer.valueOf(127);//IntegerCache.cache取数
26 Integer i12 = Integer.valueOf(127);//IntegerCache.cache取数
27
28 Integer i13 = Integer.valueOf(128);
29 Integer i14 = Integer.valueOf(128);
30
31 System.out.println("i1==i2 " + (i1 == i2));//true
32 System.out.println("i1==i7 " + (i1 == i7));//true
33 System.out.println("i1==i4 " + (i1 == i4));//false
34 System.out.println("i4==i5 " + (i4 == i5));//false
35 System.out.println("i4==i8 " + (i4 == i8));//false
36 System.out.println("40==i8 " + (40 == i8));//true Integer对象无法与数值进行直接比较，所以 i4 自动拆箱转为 int 值 40，最终这条语句转为 40 == 40 进行数值比较。
37 System.out.println("i9==i10 " + (i9 == i10));//false
38 System.out.println("i11==i12 " + (i11 == i12));//true
39 System.out.println("i13==i14 " + (i13 == i14));//false
40 }
41
42 }
