Analyse von Fallstrickbeispielen von Objects.equals in Java

1. Tatort

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。

这算哪门子原因？

答：各位看官，别急，后面会细讲的。

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

Was ist das für ein Grund?

Antwort: Liebe Leser, keine Sorge, ich werde es später ausführlich erklären.

2. Methoden zur Beurteilung der Gleichheit

Lassen Sie uns gemeinsam überprüfen, welche Methoden verwendet wurden, um zu beurteilen, ob zwei Werte gleich sind.

2.1 Verwenden Sie das ==-Zeichen

Der schnellste Weg, um festzustellen, ob zwei Werte gleich sind, ist die Verwendung des ==-Zeichens.

public boolean equals(Object obj) {
    return (this == obj);
}

Ich weiß nicht, ob Ihnen aufgefallen ist, dass die Grundtypen in Java Folgendes umfassen: int, long, short, byte, char, boolean, float, double. Sie können die Zahl verwenden, um festzustellen, ob die Werte gleich sind . Wenn ein Basistyp einer Wrapper-Klasse, wie z. B. Integer, unter Verwendung eines Basistyps und einer Wrapper-Klasse angezeigt wird, kann die Verwendungsnummer korrekt beurteilt werden und es wird „true“ zurückgegeben.

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.

Wenn zwei Ganzzahlen verglichen werden, wird verglichen, ob die Referenzen, auf die sie verweisen (d. h. Speicheradressen), gleich sind.

Es gibt noch ein weiteres interessantes Phänomen:

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;
}

sind alle Parameter vom Typ Integer, die direkt zugewiesen und verglichen werden. Die Beurteilungsergebnisse von d3 und d4 sind gleich, aber die Beurteilungsergebnisse von d5 und d6 sind nicht gleich. 🎜🎜Leute, ist euch die Kinnlade heruntergefallen? 🎜🎜Antwort: Da Integer über einen Konstantenpool verfügt, werden die direkten Integer-Daten von -128 bis 127 direkt im Konstantenpool zwischengespeichert. Also ist 1 im konstanten Pool, 128 jedoch nicht. 🎜🎜Neue Integer-Objekte sind jedoch nicht für konstante Pools geeignet. Dies ist aus den Vergleichsergebnissen der vorherigen d1- und d2-Beispiele ersichtlich. 🎜🎜Als nächstes schauen wir uns die Beurteilung von Strings an: 🎜

String e = "abc";
String f = "abc";
System.out.println(e.equals(f)); 
//结果：true

🎜 Gewöhnliche String-Variablen können auch mit dem ==-Zeichen das richtige Ergebnis zurückgeben. 🎜🎜Aber wenn eine gewöhnliche String-Variable verwendet wird, um das von new erzeugte String-Objekt zu beurteilen, wird false zurückgegeben. Dieser Punkt unterscheidet sich von dem, was ich zuvor über die Verwendung eines Basistyps und einer Verpackungsklasse gesagt habe, und das Ergebnis der Verwendung einer Zahlenbeurteilung. Strings verfügen nicht über die Funktion des automatischen Unboxings, was besondere Aufmerksamkeit erfordert. 🎜🎜Wenn die beiden neuen Zeichenfolgenobjekte außerdem anhand des ==-Zeichens beurteilt werden, wird auch false zurückgegeben. 🎜

2.2 Verwenden Sie die Gleichheitsmethode

🎜Mit dem ==-Zeichen oben können Sie schnell feststellen, ob die acht Grunddatentypen gleich sind. Darüber hinaus können Sie auch feststellen, ob die Referenzen zweier Objekte gleich sind. 🎜🎜Aber jetzt gibt es ein Problem. Es kann nicht festgestellt werden, ob die spezifischen Datenwerte der beiden Objekte im Speicher gleich sind: 🎜

int a = 1;
Integer b = new Integer(1);
Integer c = null;
System.out.println(a == b); 
//结果：true
System.out.println(a == c); 
//结果：NullPointerException

🎜String-Objekte g und h == Zeichen, um zu bestimmen, ob die Referenz gleich ist. Bei Gleichheit wird false zurückgegeben. 🎜🎜Wie beurteilen wir also die Gleichheit, wenn die Objekte unterschiedlich sind, die Datenwerte jedoch gleich sind? 🎜🎜Antwort: Verwenden Sie die Methode 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

🎜Diese Methode ist sehr einfach und bestimmt nur, ob die Referenzen zweier Objekte gleich sind. 🎜🎜Wenn der Zeichenfolgentyp direkt die Methode equal der übergeordneten Klasse (d. h. der Objektklasse) verwendet, um die Situation zu beurteilen, in der die Objekte unterschiedlich, die Werte jedoch gleich sind, liegt offensichtlich ein Problem vor. 🎜🎜Daher implementieren Strings (d. h. die String-Klasse) die Methode „equals“ erneut: 🎜

String e = null;
String f = "abc";
System.out.println(equals(e, f));

🎜Es wird immer noch zunächst ermittelt, ob die beiden Objektreferenzen gleich sind, und true zurückgeben, wenn sie gleich sind. Als nächstes werden die beiden Zeichenfolgen Zeichen für Zeichen verglichen und nur dann „true“ zurückgegeben, wenn alle Zeichen gleich sind. 🎜🎜Schön, dies kann das Problem der Beurteilung von g und h lösen: 🎜

private static boolean equals(String e, String f) {
    if (e == null) {
        return f == null;
    }
    return e.equals(f);
}

🎜 Es ​​ist ersichtlich, dass wir die von der String-Klasse neu geschriebene Methode equal verwenden, um zu beurteilen, dass die beiden String-Objekte unterschiedlich sind, aber den gleichen Wert haben und wahr sind wird zurückgegeben. 🎜🎜3. Nullzeiger-Ausnahme🎜🎜Wir wissen bereits aus dem vorherigen Punkt, dass Sie das ==-Zeichen oder die Gleichheitsmethode verwenden können, um festzustellen, ob zwei Objekte gleich sind. 🎜🎜Aber wenn Sie sie tiefer verwenden, werden Sie auf ein Problem stoßen, nämlich: Diese beiden Methoden melden möglicherweise eine Nullzeigerausnahme, wenn die Werte gleich sind. 🎜

先看看==号判断的情况：

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方法上，会出现下面的提示：

这时你就知道方法用错了，赶紧修正。但如果直接用包装类的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!