Java数据类型的比较-原创手记-慕课网

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

    }

}