1. “==” : 可以比较基本数据类型 , 也可以比较引用数据类型 。基本数据类型比较的是值，引用数据类型比较的是地址。
基本数据类型byte,short,char,int,long,float,double,boolean
封装数据类型Byte,Short,Character,Integer,Long,Float,Double,Boolean
示例代码1：
/**
* @ClassName: TypeCompare1
* @Author: liuhefei
* @Description: byte, short, int, long四种基本数据类型以及其包装类的比较
* 1. 基本数据类型与其对应的包装类运算或比较时，会自动拆箱成基本数据类型；
在自动装箱时，会先检查其值是否在-128到127之间，如果在这之间，就会直接指向常量池中其值的地址;
如果不在-128到127之间，就会创建一个新的对象，存储在堆中，就是两个不同的对象，比较时为false.
2.同时byte, short, long也具有该特性。
3.不同类型之间的基本数据类型也可以使用==进行比较,比较的是它们的值
*
* @Date: 2020/5/11 17:53
*/
public class TypeCompare1 {
public static void main(String[] args) {
int i = 127;
int i1 = 127;
Integer i2 = 127;
Integer i3 = 127;
Integer i4 = new Integer(127);
Integer i5 = new Integer(127);
Integer i6 = 128;
Integer i7 = 128;
int i8 = 300;
int i9 = 300;
long l1 = 300;
float f1 = 300;
double d1 = 300;
System.out.println(i == i1); // true; 基本类型比较值
System.out.println(i1 == i2);// true；i2自动拆箱变成基本类型,两基本类型比较值
System.out.println(i1 == i4);// true； i4自动拆箱变成基本类型,两基本类型比较值
System.out.println(i2 == i3);// true; i2和i3都指向常量池中同一个地址
System.out.println(i2 == i4);// false; 两个不同的对象
System.out.println(i4 == i5);// false； 两个不同的对象
System.out.println(i6 == i7);// false; 自动装箱时，如果值不在-128到127，就会创建一个新的对象
//不同类型之间的基本数据类型也可以使用==进行比较
System.out.println(i8 == i9); //true 基本类型之间的比较，比较的是值
System.out.println(i8 == l1); //true
System.out.println(i8 == f1); //true
System.out.println(i8 == d1); //true
}
}示例代码2：
/**
* @ClassName: TypeCompare2
* @Author: liuhefei
* @Description: float,double的比较
* 1. float,double类型的包装类，都会在堆中创建一个新对象，因此比较的是对象的地址
*
* @Date: 2020/5/11 17:53
*/
public class TypeCompare2 {
public static void main(String[] args) {
float f1 = 314.15926f;
float f2 = 314.15926f;
Float f3 = 314.15926f;
Float f4 = 314.15926f;
System.out.println(f1 == f2); //true，基本数据类型的比较，比较的是值
System.out.println(f3 == f4); //false,包装类型的比较，都会创建新对象，比较的是对象的地址
System.out.println(f1 == f3); //true, 包装类型拆箱为基本数据类型，比较的是值
double d1 = 314.15926575958;
double d2 = 314.15926575958;
Double d3 = 314.15926575958;
Double d4 = 314.15926575958;
System.out.println(d1 == d2); //true,基本类型的比较，比较的是值
System.out.println(d3 == d4); //false,包装类型的比较，都会创建新对象，比较的是对象的地址
System.out.println(d1 == d3); //true,包装类型拆箱为基本数据类型，比较的是值
}
}2. equals() : 只能比较引用数据类型, 默认比较的是地址值，它不能比较基本数据类型，基本数据类型不是Object类型, 不能使用equals方法比较。
使用equals方法比较引用类型时，等同于"=="，比较的是两个对象的值是否相等。
如果你想自定义比较方法，需要重写equals方法。
3. Jave中，Object类是所有Java类的祖先，Object是Java语言中唯一一个没有父类的类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。可以使用类型为Object的变量指向任意类型的对象。
在Object类中定义的方法，在所有类中都可以使用。Object类中定义了equals()方法和hashCode()方法，具体如下：
public boolean equals(Object obj): 比较两个对象引用的值是否相等（比较地址）。指出调用该方法的对象是否与obj对象相等。即地址是否相等。
public int hashCode():该方法返回对象的哈希码值，唯一标识一个对象。
Object类中定义的equals方法，用于比较对象的内存地址， 对于引用数据类型进行equals比较，在没有重写equals方法的情况下，它们之间的比较还是基于它们在内存中的存放位置的地址值的。
而有些类重写了equals方法和hashCode方法，比如Byte,Short,Character,Integer,Long,Float,Double,String,Date,Boolean等等，在这些类当中equals方法有其自身的实现，而不再是比较类在堆内存中的存放地址了。
因为Object的equals方法也是用双等号（==）进行比较的，所以比较后的结果跟双等号（==）的结果相同。
4. 基本数据类型byte,short,char,int,long,float,double,boolean的比较应该使用双等号(==),比较的是它们的值。
5. 引用数据类型在使用==比较的时候，比较的是它们在内存中的存放地址.只有当它们是同一个new出来的对象时，它们的比较结果才会为true,否则比较结果为false.
基本数据类型在使用==比较的时候，比较的是它们的值。不同类型之间的基本数据类型也可以使用==进行比较
6. 基本数据类型与其对应的包装类运算或比较时，会自动拆箱成基本数据类型,也可以使用==直接进行比较。
在自动装箱时，会先检查其值是否在-128到127之间，如果在这之间，就会直接指向常量池中其值的地址;
如果不在-128到127之间，就会创建一个新的对象，存储在堆中，就是两个不同的对象，比较时为false.
7. 凡是new出来的都是对象，存储在堆内存中。
7. java中Integer类型对于-128-127之间的数是存缓冲区的，所以用等号比较是一致的。但对于不在这区间的数字是在堆中new出来的。所以地址空间不一样，也就不相等。
如果两个Integer类型的数相等，且在-128-127之间，用==比较返回true，其余返回false.
8. 对于引用数据类型，我们还可以使用x.compareTo(y)方法来比较， 如果x与y相等，返回0；x大于y返回1；x小于y返回-1；
9. 两个基本类型int进行相等比较，直接用==即可。一个基本类型int和一个包装类型Integer进行相等比较，直接用==比较即可，Integer类型会做拆箱操作。
10. Integer类型比较大小，要么调用Integer.intValue()转为基本类型用“==”比较，要么直接用equals比较。
总结：
(1)凡是new出来的都是对象，new Integer(127)与new Integer(127)使用==比较为false，使用equals比较才会返回true.
(2)无论如何，Integer与new Integer使用==比较都不会相等，使用equals比较才会返回true.
(3)两个都是非new出来的Integer，如果数在-128到127之间，使用==比较则是true,如果不在-128到127之间，使用==比较否则为false。而如果使用equals方法来比较，无论比较的数在不在-128到127之间都为true.
(4)int和integer(无论new否)比，都为true，因为会把Integer自动拆箱为int再去比.
示例代码3：
public class TypeCompare3 {
public static void main(String[] args) {
int i = 127;
int ii = 128;
Integer i1 = new Integer(127);
Integer i2 = new Integer(127);
Integer i3 = 127;
Integer i4 = 127;
Integer i5 = 128;
Integer i6 = 128;
Integer i7 = new Integer(128);
Integer i8 = new Integer(128);
Integer i9 = 200;
Integer i10 = 100;
System.out.println(i == i1); //true int和integer(无论new否)比，都为true，因为会把Integer自动拆箱为int再去比
System.out.println(i == i3); //true
System.out.println(ii == i7); //true
System.out.println(i1 == i2); //false 两个不同的对象
System.out.println(i1 == i3); //false 无论如何，Integer与new Integer不会相等
System.out.println(i3 == i4); //true 在-128-127之间，用==比较返回true
System.out.println(i5 == i6); //false 不在-128-127之间，用==比较返回false
System.out.println(i7 == i8); //false 两个不同的对象
System.out.println(i1 == i3); //false 两个不同的对象
System.out.println(i5 == i7); //false 两个不同的对象
//x.compareTo(y) 如果x与y相等，返回0；x大于y返回1；x小于y返回-1
int result1 = i1.compareTo(i2);
int result2 = i5.compareTo(i6);
int result3 = i7.compareTo(i8);
int result4 = i1.compareTo(i9);
int result5 = i1.compareTo(i10);
System.out.println("result1 = " + result1); //0
System.out.println("result2 = " + result2); //0
System.out.println("result3 = " + result3); //0
System.out.println("result4 = " + result4); //-1
System.out.println("result5 = " + result5); //1
System.out.println("1: " + i1.equals(i2)); //true
System.out.println("2: " + i3.equals(i4)); //true
System.out.println("3: " + i5.equals(i6)); //true
System.out.println("4: " + i7.equals(i8)); //true
System.out.println("5: " + i1.equals(i3)); //true
System.out.println(i1.intValue() == i2.intValue()); //true
System.out.println(i3.intValue() == i4.intValue()); //true
System.out.println(i5.intValue() == i6.intValue()); //true
System.out.println(i7.intValue() == i8.intValue()); //true
}
}
11. long与Long的比较, float与Float的比较, double与Double的比较均与int与Integer的比较类似，不再多说。
示例代码4：
public class TypeCompare4 {
public static void main(String[] args) {
float f1 = 3.14f;
float f2 = 3.14f;
Float f3 = 3.14f;
Float f4 = 3.14f;
Float f5 = new Float(3.14);
Float f6 = new Float(3.14);
System.out.println(f1 == f2); //true 基本数据类型比较
System.out.println(f3 == f4); //false 两个不同的对象
System.out.println(f5 == f6); //false 两个不同的对象
System.out.println(f1 == f3); //true 封装类型会拆箱
System.out.println(f1 == f5); //true 封装类型会拆箱
System.out.println(f3 == f5); //false
System.out.println("1: " + f3.equals(f4)); //true
System.out.println("2: " + f3.equals(f5)); //true
System.out.println("3: " + f5.equals(f6)); //true
}
}示例代码5：
public class TypeCompare5 {
public static void main(String[] args) {
double d1 = 3.1415926d;
double d2 = 3.1415926d;
Double d3 = 3.1415926d;
Double d4 = 3.1415926d;
Double d5 = new Double(3.1415926d);
Double d6 = new Double(3.1415926d);
System.out.println(d1 == d2); //true 基本数据类型比较
System.out.println(d3 == d4); //false 两个不同的对象
System.out.println(d5 == d6); //false 两个不同的对象
System.out.println(d1 == d3); //true 封装类型会拆箱
System.out.println(d1 == d5); //true 封装类型会拆箱
System.out.println(d3 == d5); //false 两个不同的对象
System.out.println("1: " + d3.equals(d4)); //true
System.out.println("2: " + d3.equals(d5)); //true
System.out.println("3: " + d5.equals(d6)); //true
}
}