为了账号安全,请及时绑定邮箱和手机立即绑定

Java数据类型的比较

标签:
Java 源码

https://img2.sycdn.imooc.com/5efbf6de00011e4b06940558.jpg

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

    }

}


点击查看更多内容
TA 点赞

若觉得本文不错,就分享一下吧!

评论

作者其他优质文章

正在加载中
JAVA开发工程师
手记
粉丝
1.5万
获赞与收藏
8507

关注作者,订阅最新文章

阅读免费教程

  • 推荐
  • 评论
  • 收藏
  • 共同学习,写下你的评论
感谢您的支持,我会继续努力的~
扫码打赏,你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫,即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消