Objects.equals有坑

阳光穿透心脏的1/2处 2024-04-07 14:58 45阅读 0赞

### 前言 ###

最近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方法判断相等。