一、"=="和equals()的区别
“==”
- 在比较两个对象时，比较的是对象的地址
- 即使是直接使用"= ="操作符（“aa”==“aa”），比较的还是两个字符串的引用地址
“equals()”
- 如果没有重写equals()方法比较的是对象的地址
- 重写方法后比较的是内容(大多数方法都重写)
- 我们都知道我们使用的类都是继承自Object基类，Object中equals方法中是使用==来实现的，即比较的是两者的地址值。但是Object的子类可以重写equals方法，比如Date、String、Integer等类都是重写了equals都是重写了，比较的是值是否相等。https://blog.csdn.net/qq_26947195/article/details/79505553
那么，怎样比较对象的地址呢？
二、常量池
Integer a = new Integer(1);
Integer b = new Integer(1);
System.out.println(a==b); //false
Integer c = 1;
Integer d = 1;
System.out.println(c==d); //true
为什么两个结果不同呢？
常量池在java用于保存在编译期已确定的，已编译的class文件中的一份数据。它包括了关于类，方法，接口等中的常量，也包括字符串常量，如String s = "java"这种申明方式；当然也可扩充，执行器产生的常量也会放入常量池，故认为常量池是JVM的一块特殊的内存空间。
参考文章：https://www.cnblogs.com/syp172654682/p/8082625.html
1 String s1 = "Hello";
2 String s2 = "Hello";
3 String s3 = "Hel" + "lo";
4 String s4 = "Hel" + new String("lo");
5 String s5 = new String("Hello");
6 String s6 = s5.intern();
7 String s7 = "H";
8 String s8 = "ello";
9 String s9 = s7 + s8;
10
11 System.out.println(s1 == s2); // true
12 System.out.println(s1 == s3); // true
13 System.out.println(s1 == s4); // false
14 System.out.println(s1 == s9); // false
15 System.out.println(s4 == s5); // false
16 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地址相同。
s1 == s6这两个相等完全归功于intern方法，s5在堆中，内容为Hello ，intern方法会尝试将Hello字符串添加到常量池中，并返回其在常量池中的地址，因为常量池中已经有了Hello字符串，所以intern方法直接返回地址；而s1在编译期就已经指向常量池了，因此s1和s6指向同一地址，相等。
关于intern：intern方法会返回String对象在常量池中的引用，如果在常量池中已经存在这个字符串了，那么直接返回这个引用；如果没有，就把这个字符串复制到常量池，然后返回引用。
String a = new String("A");
String a1 = "A";
System.out.println(a==a1); //false
System.out.println(a1.intern()==a); //false
System.out.println(a.intern()==a1); //true
特例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，它们是同一个对象
对比上面的s1==s9，同样是拼接的，为什么这里将A和B拼接起来就相等呢？
A和B都是常量，值是固定的，因此s的值也是固定的，它在类被编译时就已经确定了。也就是说：String s=A+B; 等同于：String s=“ab”+“cd”;
常量
https://blog.csdn.net/qq_26947195/article/details/79505553
第一种：是一个值，这个值本身，我们就叫做常量。
整型常量：1024
实型常量：1.024
字符常量：‘g’ ‘c’ ‘w’
字符串常量：“gcw”
逻辑常量：true false
这只是我们平时我们的一个说法而已，比如数字1024，我们说它是一个int类型的常量。
第二种：不可变的变量，我们也称为常量。就是被我们都知道的关键字final修饰的变量，final修饰的变量，只要一经赋值，就不可以改变。可能它本身是个变量，但是被final修饰，我们可以认为是个常量。比如：
final int i=1024;
特例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就不能在编译期被确定，而只能在运行时被创建了。
