Angenommen, es besteht ein Bedarf: Ermitteln Sie den aktuell angemeldeten Benutzer und senden Sie eine E-Mail, wenn es sich um unseren designierten Systemadministrator handelt. Der Systemadministrator hat keine spezielle Feldidentifikation. Seine Benutzer-ID ist 888. Dieser Wert ist in Entwicklungs-, Test- und Produktionsumgebungen gleich.
Diese Anforderung ist wirklich einfach zu implementieren:
UserInfo userInfo = CurrentUser.getUserInfo();
if(Objects.isNull(userInfo)) {
log.info("请先登录");
return;
}
if(Objects.equals(userInfo.getId(),888)) {
sendEmail(userInfo):
}Erhalten Sie die Benutzerinformationen aus dem Kontext des aktuell angemeldeten Benutzers, beurteilen Sie sie und geben Sie sie direkt zurück, wenn die Benutzerinformationen leer sind.
Wenn die erhaltenen Benutzerinformationen nicht leer sind, ermitteln Sie, ob die Benutzer-ID 888 entspricht.
Wenn gleich 888, senden Sie die E-Mail.
Wenn es nicht gleich 888 ist, wird nichts unternommen.
Nachdem wir uns mit dem Systemadministratorkonto mit der ID=888 angemeldet hatten, führten wir relevante Vorgänge durch und bereiteten uns mit großen Erwartungen auf den Empfang der E-Mail vor, stellten jedoch fest, dass die E-Mail einsam war.
Später habe ich herausgefunden, dass die UserInfo-Klasse wie folgt definiert ist:
@Data
public class UserInfo {
private Long id;
private String name;
private Integer age;
private String address;
}Zu diesem Zeitpunkt könnten einige Freunde sagen: Ich sehe kein Problem.
Aber was ich sagen möchte ist, dass mit diesem Code tatsächlich etwas nicht stimmt.
Was ist das Problem?
Antwort: Die Mitgliedsvariable id=888 der UserInfo-Klasse ist vom Typ Long, während die 888 auf der rechten Seite der Objects.equals-Methode vom Typ int ist . Die beiden sind inkonsistent, was zu einer Rückgabe führt. Das Ergebnis ist falsch. Long类型的，而Objects.equals方法右边的888是int类型的，两者不一致，导致返回的结果是false。
这算哪门子原因？
答：各位看官，别急，后面会细讲的。
让我们一起回顾一下，以前判断两个值是否相等的方法有哪些。
之前判断两个值是否相等，最快的方法是使用==号。
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。
使用上面的==号，可以非常快速判断8种基本数据类型是否相等，除此之外，还能判断两个对象的引用是否相等。
但现在有个问题，它无法判断两个对象在内存中具体的数据值是否相等，比如：
String g = new String("abc");
String h = new String("abc");
System.out.println(g == h);
//结果：false字符串对象g和h是两个不同的对象，它们使用==号判断引用是否相等时，返回的是false。
那么，这种对象不同，但数据值相同的情况，我们该如何判断相等呢？
答：使用equals
public boolean equals(Object obj) {
return (this == obj);
}Beim Vergleich von Integer und Int werden sie automatisch entpackt. Dies dient dem Vergleich, ob die Werte gleich sind.Aber wenn es zwei Verpackungsklassen gibt, wie z. B. d1 und d2, kann das Ergebnis der Verwendung des ==-Zeichens falsch sein.
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;
}String e = "abc"; String f = "abc"; System.out.println(e.equals(f)); //结果：true
int a = 1; Integer b = new Integer(1); Integer c = null; System.out.println(a == b); //结果：true System.out.println(a == c); //结果：NullPointerException
equals. Die 🎜🎜equals-Methode ist eigentlich eine Methode in der Object-Klasse: 🎜String e = null; String f = "abc"; System.out.println(e.equals(f)); //结果：NullPointerException
String e = null; String f = "abc"; System.out.println(equals(e, f));
private static boolean equals(String e, String f) {
if (e == null) {
return f == null;
}
return e.equals(f);
}先看看==号判断的情况：
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或者其他类型的对象比较呢？
答：有办法，继续往下看。
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方法再比较两个对象是否相等时，确实是一个不错的方法。
但它有坑，不信继续往下看。
各位小伙们看到这里，可能有点心急了，到底是什么坑？
废话不多说，直接上例子：
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方法两个参数类型不一致的问题，也没有标识出来。
Leute, schaut euch kurz euren Code an. Gibt es irgendwelche Fallstricke?
Häufige Fallstricke sind:
Vergleich zwischen Long-Typ und Integer-Typ, z. B.: Benutzer-ID-Szenario.
Vergleich von Byte-Typ und Integer-Typ, z. B.: Statusbeurteilungsszenario.
Vergleich zwischen Double-Typ und Integer-Typ, zum Beispiel: Beurteilungsszenario, bei dem der Betrag 0 ist.
Das obige ist der detaillierte Inhalt vonAnalyse von Fallstrickbeispielen von Objects.equals in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
