今天小编给大家分享一下Java中Objects.equals踩坑实例代码分析的相关知识点,内容详细,逻辑清晰,相信大部分人都还太了解这方面的知识,所以分享这篇文章给大家参考一下,希望大家阅读完这篇文章后有所收获,下面我们一起来了解一下吧。
1. 案发现场
假设现在有这样一个需求:判断当前登录的用户,如果是我们指定的系统管理员,则发送一封邮件。系统管理员没有特殊的字段标识,他的用户id=888,在开发、测试、生产环境中该值都是一样的。
这个需求真的太容易实现了:
UserInfo userInfo = CurrentUser.getUserInfo(); if(Objects.isNull(userInfo)) { log.info("请先登录"); return; } if(Objects.equals(userInfo.getId(),888)) { sendEmail(userInfo): }
从当前登录用户的上下文中获取用户信息,判断一下,如果用户信息为空,则直接返回。
如果获取到的用户信息不为空,接下来判断用户id是否等于888。
如果等于888,则发送邮件。
如果不等于888,则啥事也不干。
当我们用id=888的系统管理员账号登录之后,做了相关操作,满怀期待的准备收邮件的时候,却发现收了个寂寞。
后来,发现UserInfo类是这样定义的:
@Data public class UserInfo { private Long id; private String name; private Integer age; private String address; }
此时,有些小伙伴可能会说:没看出什么问题呀。
但我要说的是这个代码确实有问题。
什么问题呢?
答:UserInfo类的成员变量id=888是Long
类型的,而Objects.equals方法右边的888是int
类型的,两者不一致,导致返回的结果是false。
这算哪门子原因?
答:各位看官,别急,后面会细讲的。
2. 判断相等的方法
让我们一起回顾一下,以前判断两个值是否相等的方法有哪些。
2.1 使用==号
之前判断两个值是否相等,最快的方法是使用==号。
int a = 1; int b = 1; byte c = 1; Integer d1 = new Integer(1); Integer d2 = new Integer(1); System.out.println(a == b); //结果:true System.out.println(a == c); //结果:true System.out.println(a == d1); //结果:true System.out.println(d2 == a); //结果:true System.out.println(d1 == d2); //结果:false
不知道大家有没有发现,java中的基本类型,包含:int、long、short、byte、char、boolean、float、double这8种,可以使用号判断值是否相等。如果出现了基本类型的包装类,比如:Integer,用一个基本类型和一个包装类,使用号也能正确判断,返回true。
Integer和int比较时,会自动拆箱,这是比较值是否相等。
但如果有两个包装类,比如:d1和d2,使用==号判断的结果可能是false。
两个Integer比较时,比较的是它们指向的引用(即内存地址)是否相等。
还有一个有意思的现象:
Integer d3 = 1; Integer d4 = 1; Integer d5 = 128; Integer d6 = 128; System.out.println(d3 == d4); //结果:true System.out.println(d5 == d6); //结果:false
都是给Integer类型的参数,直接赋值后进行比较。d3和d4判断的结果相等,但d5和d6判断的结果却不相等。
小伙伴们,下巴惊掉了没?
答:因为Integer有一个常量池,-128~127直接的Integer数据直接缓存进入常量池。所以1在常量池,而128不在。
然而,new的Integer对象不适用常量池。从之前d1和d2例子的比较结果,就能看出这一点。
接下来,看看字符串的判断:
String e = "abc"; String f = "abc"; String g = new String("abc"); String h = new String("abc"); System.out.println(e == f); //结果:true System.out.println(e == g); //结果:false System.out.println(g == h); //结果:false
普通的字符串变量,使用==号判断,也能返回正确的结果。
但如果一个普通的字符串变量,跟new出来的字符串对象使用号判断时,返回false。这一点,跟之前说过的用一个基本类型和一个包装类,使用号判断的结果有区别,字符串没有自动拆箱的功能,这一点需要特别注意。
此外,两个new出来的字符串对象使用==号判断时,也返回false。
2.2 使用equals方法
使用上面的==号,可以非常快速判断8种基本数据类型是否相等,除此之外,还能判断两个对象的引用是否相等。
但现在有个问题,它无法判断两个对象在内存中具体的数据值是否相等,比如:
String g = new String("abc"); String h = new String("abc"); System.out.println(g == h); //结果:false
字符串对象g和h是两个不同的对象,它们使用==号判断引用是否相等时,返回的是false。
那么,这种对象不同,但数据值相同的情况,我们该如何判断相等呢?
答:使用equals
方法。
equals方法其实是Object类中的方法:
public boolean equals(Object obj) { return (this == obj); }
该方法非常简单,只判断两个对象的引用是否相等。
很显然,如果字符串类型直接使用父类(即Object类)的equals方法,去判断对象不同,但值相同的情况,是有问题的。
所以,字符串(即String类)会重新的equals方法:
public boolean equals(Object anObject) { if (this == anObject) { return true; } if (anObject instanceof String) { String anotherString = (String)anObject; int n = value.length; if (n == anotherString.value.length) { char v1[] = value; char v2[] = anotherString.value; int i = 0; while (n-- != 0) { if (v1[i] != v2[i]) return false; i++; } return true; } } return false; }
它依然会先判断两个对象引用是否相等,如果相等返回true。接下来,会把两个字符串的挨个字符进行比较,只有所有字符都相等才返回true。
nice,这样就能解决g和h判断的问题:
String e = "abc"; String f = "abc"; System.out.println(e.equals(f)); //结果:true
由此可见,我们使用String类重写后的equals方法,判断两个字符串对象不同,但值相同时,会返回true。
3. 空指针异常
从前面我们已经知道,判断两个对象是否相等,可以使用==号,或者equals方法。
但如果你更深入的使用它们,会发现一个问题,即:这两种方式判断值相等,都可能会报空指针异常。
先看看==号判断的情况:
int a = 1; Integer b = new Integer(1); Integer c = null; System.out.println(a == b); //结果:true System.out.println(a == c); //结果:NullPointerException
int和Integer使用==号判断是否相等时,Integer会自动拆箱成int。
但由于c在自动拆箱的过程中,需要给它赋值int的默认值0。而给空对象,赋值0,必然会报空指针异常。
接下来,看看equals方法:
String e = null; String f = "abc"; System.out.println(e.equals(f)); //结果:NullPointerException
由于字符串对象e是空对象,直接调用它的equals方法时,就会报空指针异常。
那么,如何解决空指针问题呢?
答:在代码中判空。
String e = null; String f = "abc"; System.out.println(equals(e, f));
我们抽取了一个新的equals方法:
private static boolean equals(String e, String f) { if (e == null) { return f == null; } return e.equals(f); }
该方法可以解决空指针问题,但有没有办法封装一下,变得更通用一下,也适用于Integer或者其他类型的对象比较呢?
答:有办法,继续往下看。
4. Objects.equals的作用
Objects
类位于java.util
包下,它是里面提供了很多对象操作的辅助方法。
下面我们重点看看它的equals方法:
public static boolean equals(Object a, Object b) { return (a == b) || (a != null && a.equals(b)); }
equals方法的判断逻辑如下:
该方法先判断对象a和b的引用是否相等,如果相等则直接返回true。
如果引用不相等,则判断a是否为空,如果a为空则返回false。
如果a不为空,调用对象的equals方法进一步判断值是否相等。
该方法是如何使用的?
int a = 1; int b = 1; Integer c = null; System.out.println(Objects.equals(a, c)); //结果:false System.out.println(Objects.equals(c, a)); //结果:false System.out.println(Objects.equals(a, b)); //结果:true
从上面的列子看出,使用Objects.equals方法比较两个对象是否相等,确实可以避免空指针问题。
但这个有个疑问:前面使用a==b这种方式比较引用是否相等,当时b为空时,程序直接抛了空指针异常。
而Objects.equals方法内部也使用了a==b比较引用是否相等,为啥它没有抛异常?
答:因为而Objects类的equals方法,使用了Object类型接收参数,它的默认值是null,不用进行类型转换,也不用像int类型对象赋值默认值0。
从上面的理论可以看出,如果我们把代码改成这样,也不会抛异常:
int a = 1; Integer c = null; System.out.println(equals(a, c)); //结果:false
新定义了一个方法:
private static boolean equals(Object a, Object b) { return a == b; }
执行之后发现,确实没有抛空指针了。
所以Objects.equals方法再比较两个对象是否相等时,确实是一个不错的方法。
但它有坑,不信继续往下看。
5. Objects.equals的坑
各位小伙们看到这里,可能有点心急了,到底是什么坑?
废话不多说,直接上例子:
Integer a = 1; long b = 1L; System.out.println(Objects.equals(a, b)); //结果:false
什么?返回结果是false?
而如果你直接用==号判断:
Integer a = 1; long b = 1L; System.out.println(a == b); //结果:true
返回又是true。
a和b明明都是1,为什么使用Objects.equals方法判断不相等呢?
这就要从Integer的equals方法说起来了。
它的equals方法具体代码如下:
public boolean equals(Object obj) { if (obj instanceof Integer) { return value == ((Integer)obj).intValue(); } return false; }
先判断参数obj是否是Integer类型,如果不是,则直接返回false。如果是Integer类型,再进一步判断int值是否相等。
而上面这个例子中b是long类型,所以Integer的equals方法直接返回了false。
也就是说,如果调用了Integer的equals方法,必须要求入参也是Integer类型,否则该方法会直接返回false。
原来坑在这里!!!
其实,如果把代码改成这样:
Integer a = 1; long b = 1L; System.out.println(Objects.equals(b, a)); //结果:false
执行结果也是false。
因为Long的equals方法代码,跟之前Integer的类似:
public boolean equals(Object obj) { if (obj instanceof Long) { return value == ((Long)obj).longValue(); } return false; }
也是判断入参,如果不是Long类型,则该方法直接返回false。
除此之外,还有Byte、Short、Double、Float、Boolean和Character也有类似的equals方法判断逻辑。
由此可见,我们在使用Objects.equals方法,判断两个值是否相等时,一定要保证两个入参的类型要一致。否则即使两个值相同,但其结果仍然会返回false,这是一个大坑。
那么,如何解决上面的问题呢?
可以将参数b的类型强制转换成int。
Integer a = 1; long b = 1L; System.out.println(Objects.equals(a, (int)b)); //结果:true
或者将参数a的类型强制转换成long。
Integer a = 1; long b = 1L; System.out.println(Objects.equals(b, (long)a)); //结果:true
有些情况也可以直接用==号判断:
Integer a = 1; long b = 1L; System.out.println(a==b); //结果:true
除了Objects.equals方法在两个入参类型不同,而会直接返回false之外,java的8种基本类型包装类的equals也会有相同的问题,需要小伙们特别注意。
之前,如果直接使用java基本类型包装类的equals方法判断相等。
Integer a = new Integer(1); long b = 1L; System.out.println(a.equals(b));
在idea中,如果你将鼠标放在equals方法上,会出现下面的提示:
Long类型和Integer类型比较,比如:用户id的场景。
Byte类型和Integer类型比较,比如:状态判断的场景。
Double类型和Integer类型比较,比如:金额为0的判断场景。
以上就是“Java中Objects.equals踩坑实例代码分析”这篇文章的所有内容,感谢各位的阅读!相信大家阅读完这篇文章都有很大的收获,小编每天都会为大家更新不同的知识,如果还想学习更多的知识,请关注***行业资讯频道。