Objects.equals 有坑！！！

前言

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

原本以为判断结果会返回 true 的，但实际上返回了 false。

记得很早之前，我使用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 方法的判断逻辑如下：

1. 该方法先判断对象 a 和 b 的引用是否相等，如果相等则直接返回 true。
2. 如果引用不相等，则判断 a 是否为空，如果 a 为空则返回 false。
3. 如果 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 方法上，会出现下面的提示：

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

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

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

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

常见的坑有：

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