java中object的equals方法,Objects.equals()

　　00-1010前言1。犯罪现场2。判断等式的方法2.1使用==符号2.2使用等于方法3。异常空指针4。物体的功能。等于5。对象的坑总结。等于

　　00-1010最近在审核别人的代码时，发现一个同事，在某个业务场景下，用Objects.equals方法判断两个值相等，返回一个与预期不一致的结果，引起了我的兴趣。

　　我以为判断结果会返回true，实际上却返回false。

　　记得很久以前，我用Objects.equals方法踩过类似的坑，所以有必要把这个问题记录下来，分享给大家。

　　这是怎么回事？

　　00-1010假设现在有这样的需求：判断当前登录的用户，如果是我们指定的系统管理员就发邮件。系统管理员没有特殊的字段ID，他的用户id=888，这个值在开发、测试和生产环境中都是一样的。

　　这个要求真的太容易实现了：

　　UserInfo UserInfo=current user . get UserInfo()；if(objects . is null(userinfo)){ log . info(请先登录)；返回；} if(objects . equals(userinfo . getid()，888)) {sendemail (userinfo) 3360}从当前登录用户的上下文中获取用户信息，并进行判断。如果用户信息为空，则直接返回。

　　如果获得的用户信息不为空，则确定用户id是否等于888。

　　如果等于888，则发送邮件。如果不等于888，则什么都不做。当我们用系统管理员账号id=888登录，并做了一些相关操作后，我们期待着收到邮件，却发现自己感到了孤独。

　　后来发现UserInfo类是这样定义的：

　　@Datapublic类UserInfo { private Long id私有字符串名称；私有整数年龄；私有字符串地址；}此时，可能有朋友会说：我看不出有什么问题。

　　但我想说的是，这段代码有问题。

　　有什么问题？

　　答：UserInfo类的成员变量id=888是Long类型，而Objects.equals方法右边的888是int类型，两者不一致，导致返回结果为false。

　　这是什么样的原因？

　　先生们，别担心。我们以后再谈。

　　00-1010我们一起来复习一下，之前有哪些判断两个值是否相等的方法。

　　判断两个值在00-1010之前是否相等的最快方法是使用==符号。

　　int a=1；int b=1；字节c=1；整数d1=新整数(1)；整数d2=新整数(1)；system . out . println(a==b)；//Result:true system . out . println(a==c)；//Result:true system . out . println(a==D1)；//Result:true system . out . println(D2==a)；//Result:true system . out . println(D1==D2)；//结果：假。不知道大家有没有找到。java中的基本类型，包括：int，long，short，byte，char，boolean，float，double，可以用来判断值是否相等。如果有一个包装类的基本类型，比如Integer，使用一个基本类型和一个包装类，使用数也可以判断正确，返回true。

　　Integer和int比较的时候会自动解包，就是比较值是否相等。

　　但是如果有两个包装类，比如d1和d2，使用==符号的结果可能是假的。

　　当比较两个整数时，它们比较它们所指向的引用(即内存地址)是否相等。

　　还有一个有趣的现象：

　　整数D3=1；整数D4=1；整数d5=128整数D6=128；system . out . println(D3==D4)；//结果：真实

　　stem.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); //结果：trueSystem.out.println(e == g); //结果：falseSystem.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); //结果：trueSystem.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)); //结果：falseSystem.out.println(Objects.equals(c, a)); //结果：falseSystem.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方法上，会出现下面的提示：

　　这时你就知道方法用错了，赶紧修正。但如果直接用包装类的equals方法，有个问题就是可能存在报空指针异常的风险。

　　如果你使用Objects.equals方法判断相等，在idea中就并没有错误提示。

　　除此之外，我还测试了findBug、sonar等工具，Objects.equals方法两个参数类型不一致的问题，也没有标识出来。

　　小伙们赶紧看看你们的代码，踩坑了没？

　　常见的坑有：

　　Long类型和Integer类型比较，比如：用户id的场景。Byte类型和Integer类型比较，比如：状态判断的场景。Double类型和Integer类型比较，比如：金额为0的判断场景。

总结

到此这篇关于Java中Objects.equals踩坑记录的文章就介绍到这了,更多相关JavaObjects.equals踩坑内容请搜索盛行IT以前的文章或继续浏览下面的相关文章希望大家以后多多支持盛行IT！

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。