1 、概念:

1.1 、什么是常量:

用final修饰的成员变量表示常量，值一旦给定就无法改变！
final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。

扩展: final 可以修饰那类、方法、变量.

1.2 、常量池的两种形态:

Java中的常量池，实际上分为两种形态：静态常量池和运行时常量池。

1.2.1 、静态常量池:

所谓静态常量池，即*.class文件中的常量池，class文件中的常量池不仅仅包含字符串(数字)字面量，还包含类、方法的信息，占用class文件绝大部分空间。这种常量池主要用于存放两大类常量：字面量(Literal)和符号引用量(Symbolic References)，字面量相当于Java语言层面常量的概念，如文本字符串，声明为final的常量值等，符号引用则属于编译原理方面的概念，包括了如下三种类型的常量：

类和接口的全限定名
字段名称和描述符
方法名称和描述符

1.2.2 、运行时常量池:

运行时常量池jvm虚拟机在完成类装载操作后，将class文件中的常量池载入到内存中，并保存在方法区中，我们常说的常量池，就是指方法区中的运行时常量池。(jdk8以前存在于方法区, 在jdk8中，移除了方法区，转而用Metaspace区域替代 ,那么也就是存在于Metaspace区, )

运行时常量池相对于CLass文件常量池的另外一个重要特征是具备动态性，Java语言并不要求常量一定只有编译期才能产生，也就是并非预置入CLass文件中常量池的内容才能进入方法区运行时常量池，运行期间也可能将新的常量放入池中，这种特性被开发人员利用比较多的就是String类的intern()方法。

String的intern()方法会查找在常量池中是否存在一份equal相等的字符串,如果有则返回该字符串的引用,如果没有则添加自己的字符串进入常量池。

1.3 、==和equals()的区别:

==:

对于基本数据类型来说比较的是值是否相等.

对于引用数据类型来说比较的是内存地址是否相等.

equals():

只有引用数据类型才能调用,比较的值是否相等.

1.4 、常量池的好处

常量池是为了避免频繁的创建和销毁对象而影响系统性能，其实现了对象的共享。
例如字符串常量池，在编译阶段就把所有的字符串文字放到一个常量池中。

节省内存空间：常量池中所有相同的字符串常量被合并，只占用一个空间。
节省运行时间：比较字符串时，==比equals()快。对于两个引用变量，只用==判断引用是否相等，也就可以判断实际值是否相等。

2 、哪些包装类实现了常量池:

JAVA的8个包装类种只有: Byte,Short,Integer,Long,Character,Boolean 这个六种实现了常量池, 但是其中 Byte,Short,Integer,Long,Character 这5种包装类默认创建了数值[-128，127]的相应类型的缓存数据，但是超出此范围仍然会去创建新的对象。

Byte,Short,Integer,Long,Character实现了常量池:

public static void main(String[] args) {
    Integer a = 127;
    Integer b = 127;
    Integer c = 128;
    Integer d = 128;
    System.out.println("a == b : " + (a == b));  //true
    System.out.println("c == d : " + (c == d));  //false
}

2. Float,Double并没有实现常量池技术:

public static void main(String[] args) {
    Double e = 1.2D;
    Double f = 1.2D;
    System.out.println("e == f : "+(e == f));//false
}

3. 应用常量池的场景:

Integer i1 = 40；Java在编译的时候会直接将代码封装成Integer i1=Integer.valueOf(40);，从而使用常量池中的对象。
Integer i1 = new Integer(40);这种情况下会创建新的对象。

public static void main(String[] args) {
    Integer i1 = 40;
    Integer i2 = new Integer(40);
    System.out.println(i1==i2);//false
}

4. Integer 的例子:

public static void main(String[] args) {
    Integer i1 = 127;
    int i2 = 127;
    int  i3 = 0;
    Integer i4 = Integer.valueOf(127);
    Integer i5 = new Integer(127);
    Integer i6 = new Integer(0);
    Integer i7 = new Integer(127);
    int i8 = 128 ;
    int  i9 =128;
    Integer i10 = 128;
    Integer i11 = 128;
    Integer i12 = new Integer(128);

    System.out.println(i1 == i2 ); //true : i1 自动拆箱成int
    System.out.println((i1+i3) == i2); // true
    System.out.println(i1 == i4);  //true  : 自动装箱 调用的就是valueOf 方法,两个Integer 比较,又在常量池内 ,所以是true
    System.out.println(i1 == i5); // false : new 了. 得新建,不在常量池 ,所以地址一定不同
    System.out.println(i2 == i5 ); //true  :  i5自动拆箱成了 int
    System.out.println((i5 + i6) == i7); //true:  i5+ i6 得进行拆箱成 int 再相加 , 结果也就是int  再跟 i7比较时, 127 == i7 , Integer 没法比较,又进行了拆箱 ,最终  127 == 127
    System.out.println(i8 == i9); // 毫无疑问true
    System.out.println(i10 == i11); //false : 不在常量池了,  自动装箱得新建对象,  地址就不一样了, false
    System.out.println(i8 == i12); // true :  i12 自动拆箱再比较
    System.out.println((i8 + i9) == (i10 + i12)); // true  


}

自动拆箱与自动装箱

3.String类和常量池

3.1 、String对象创建方式

public static void main(String[] args) {
    String str1 = "wakaka";
    String str2 = new String("wakaka");
    System.out.println(str1 == str2);//false
}

这两种不同的创建方法是有差别的，第一种方式是在常量池中拿对象，第二种方式是直接在堆内存空间创建一个新的对象。

只要使用new方法，便需要创建新的对象。

3.2 、连接表达式 +

只有使用引号包含文本的方式创建的String对象之间使用“+”连接产生的新对象才会被加入字符串池中。
对于所有包含new方式新建对象（包括null）的“+”连接表达式，它所产生的新对象都不会被加入字符串池中。

public static void main(String[] args) {
    String str1 = "str";
    String str2 = "ing";

    String str3 = "str" + "ing";
    String str4 = str1 + str2;
    System.out.println(str3 == str4);//false

    String str5 = "string";
    System.out.println(str3 == str5);//true
}

个人理解:

str3 : 虽然是动态拼接出来的字符串，但是所有参与拼接的部分都是已知的字面量，在编译期间，这种拼接会被优化，编译器直接帮你拼好为: String str3 = "string", 那么 string 是会添加到在常量池中的

str4: 虽然str1、str2在赋值的时候使用的字符串字面量,但是拼接成str4的时候，str1、str2 作为两个变量，都是不可预料的，编译器毕竟是编译器，不可能当解释器用，不能在编译期被确定，所以不做优化，只能等到运行时，在堆中创建str1、str2拼接成的新字符串，在堆中地址不确定，不可能与常量池中的s5地址相同。

str5 : 被放到了常量池

特例1:

public static final String A = "ab"; // 常量A
public static final String B = "cd"; // 常量B
public static void main(String[] args) {
     String s = A + B;  // 将两个常量用+连接对s进行初始化 
     String t = "abcd";   
    if (s == t) {   
         System.out.println("s等于t，它们是同一个对象");   
     } else {   
         System.out.println("s不等于t，它们不是同一个对象");   
     }   
 } 
//结果:  s等于t，它们是同一个对象

A和B都是常量，值是固定的，因此s的值也是固定的，它在类被编译时就已经确定了。也就是说：String s=A+B; 等同于：String s="ab"+"cd";

特例2:

public static final String A; // 常量A
public static final String B;    // 常量B
static {   
     A = "ab";   
     B = "cd";   
 }   
 public static void main(String[] args) {   
    // 将两个常量用+连接对s进行初始化   
     String s = A + B;   
     String t = "abcd";   
    if (s == t) {   
         System.out.println("s等于t，它们是同一个对象");   
     } else {   
         System.out.println("s不等于t，它们不是同一个对象");   
     }   
 } 
//结果: s不等于t，它们不是同一个对象

A和B虽然被定义为常量，但是它们都没有马上被赋值。在运算出s的值之前，他们何时被赋值，以及被赋予什么样的值，都是个变数。因此A和B在被赋值之前，性质类似于一个变量。那么s就不能在编译期被确定，而只能在运行时被创建了。

例子:

String s1 = "Hello";
String s2 = "Hello";
String s3 = "Hel" + "lo";
String s4 = "Hel" + new String("lo");
String s5 = new String("Hello");
String s6 = s5.intern();
String s7 = "H";
String s8 = "ello";
String s9 = s7 + s8;
          
System.out.println(s1 == s2);  // true
System.out.println(s1 == s3);  // true
System.out.println(s1 == s4);  // false
System.out.println(s1 == s9);  // false
System.out.println(s4 == s5);  // false
System.out.println(s1 == s6);  // true

s1 == s2这个非常好理解，s1、s2在赋值时，均使用的字符串字面量，说白话点，就是直接把字符串写死，在编译期间，这种字面量会直接放入class文件的常量池中，从而实现复用，载入运行时常量池后，s1、s2指向的是同一个内存地址，所以相等。
s1 == s3这个地方有个坑，s3虽然是动态拼接出来的字符串，但是所有参与拼接的部分都是已知的字面量，在编译期间，这种拼接会被优化，编译器直接帮你拼好，因此String s3 = "Hel" + "lo";在class文件中被优化成String s3 = "Hello"，所以s1 == s3成立。只有使用引号包含文本的方式创建的String对象之间使用“+”连接产生的新对象才会被加入字符串池中。
s1 == s4当然不相等，s4虽然也是拼接出来的，但new String("lo")这部分不是已知字面量，是一个不可预料的部分，编译器不会优化，必须等到运行时才可以确定结果，结合字符串不变定理，鬼知道s4被分配到哪去了，所以地址肯定不同。对于所有包含new方式新建对象（包括null）的“+”连接表达式，它所产生的新对象都不会被加入字符串池中。

配上一张简图理清思路：

s1 == s9也不相等，道理差不多，虽然s7、s8在赋值的时候使用的字符串字面量，但是拼接成s9的时候，s7、s8作为两个变量，都是不可预料的，编译器毕竟是编译器，不可能当解释器用，不能在编译期被确定，所以不做优化，只能等到运行时，在堆中创建s7、s8拼接成的新字符串，在堆中地址不确定，不可能与方法区常量池中的s1地址相同。
s4 == s5已经不用解释了，绝对不相等，二者都在堆中，但地址不同。
s1 == s6这两个相等完全归功于intern方法，s5在堆中，内容为Hello ，intern方法会尝试将Hello字符串添加到常量池中，并返回其在常量池中的地址，因为常量池中已经有了Hello字符串，所以intern方法直接返回地址；而s1在编译期就已经指向常量池了，因此s1和s6指向同一地址，相等。