Analisis contoh perangkap Objects.equals in Java

1 Tempat kejadian

Andaikan terdapat keperluan sedemikian: tentukan pengguna yang sedang log masuk, dan jika ia adalah pentadbir sistem yang ditetapkan kami, hantarkan emel. Pentadbir sistem tidak mempunyai pengenalan medan khas ID penggunanya ialah 888. Nilai ini adalah sama dalam persekitaran pembangunan, ujian dan pengeluaran.

Keperluan ini sangat mudah untuk dilaksanakan:

UserInfo userInfo = CurrentUser.getUserInfo();

if(Objects.isNull(userInfo)) {
   log.info("请先登录");
   return;
}

if(Objects.equals(userInfo.getId(),888)) {
   sendEmail(userInfo):
}

Dapatkan maklumat pengguna daripada konteks pengguna yang sedang log masuk, nilaikannya dan kembalikannya terus jika maklumat pengguna kosong.

Jika maklumat pengguna yang diperolehi tidak kosong, maka tentukan sama ada ID pengguna adalah sama dengan 888.

• Jika sama dengan 888, hantar e-mel.

• Jika ia tidak sama dengan 888, tiada apa yang akan dilakukan.

Selepas kami melog masuk dengan akaun pentadbir sistem dengan ID = 888, kami melakukan operasi yang berkaitan dan bersedia untuk menerima e-mel dengan harapan yang tinggi, tetapi mendapati ia sunyi.

Kemudian, saya mendapati bahawa kelas UserInfo ditakrifkan seperti ini:

@Data
public class UserInfo {
    private Long id;
    private String name;
    private Integer age;
    private String address;
}

Pada masa ini, sesetengah rakan mungkin berkata: Saya tidak nampak sebarang masalah.

Tetapi apa yang saya ingin katakan ialah terdapat sesuatu yang tidak kena dengan kod ini.

Apa masalahnya?

Jawapan: Pembolehubah ahli id=888 kelas UserInfo adalah daripada jenis Long, manakala 888 di sebelah kanan kaedah Objects.equals adalah jenis int Kedua-duanya tidak konsisten, menyebabkan hasil yang dikembalikan adalah palsu.

Alasan apakah ini?

Jawapan: Pembaca yang dihormati, jangan risau, saya akan menerangkannya secara terperinci kemudian.

2. Kaedah menentukan kesaksamaan

Mari kita semak bersama kaedah sebelumnya untuk menentukan sama ada dua nilai adalah sama.

2.1 Gunakan tanda ==

Sebelum menilai sama ada dua nilai adalah sama, cara terpantas ialah menggunakan tanda ==.

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

Saya tidak tahu sama ada anda perasan bahawa jenis asas dalam Java termasuk: int, long, short, byte, char, boolean, float, double Anda boleh menggunakan nombor untuk menentukan sama ada nilainya adalah sama. Jika jenis asas kelas pembalut muncul, seperti Integer, menggunakan jenis asas dan kelas pembalut, nombor penggunaan boleh dinilai dengan betul dan benar akan dikembalikan.

Apabila membandingkan Integer dan int, mereka akan dinyahkotak secara automatik untuk menentukan sama ada nilai perbandingan adalah sama.

Tetapi jika terdapat dua kelas pembungkusan, seperti d1 dan d2, hasil penggunaan tanda == mungkin palsu.

Apabila dua Integer dibandingkan, perbandingannya ialah sama ada rujukan yang mereka tunjuk (iaitu alamat memori) adalah sama.

Terdapat satu lagi fenomena menarik:

Integer d3 = 1;
Integer d4 = 1;
Integer d5 = 128;
Integer d6 = 128;
System.out.println(d3 == d4); 
//结果：true
System.out.println(d5 == d6); 
//结果：false

ialah semua parameter jenis Integer, yang diperuntukkan secara langsung dan dibandingkan. Keputusan penghakiman d3 dan d4 adalah sama, tetapi keputusan penghakiman d5 dan d6 adalah tidak sama.

Kawan-kawan, adakah rahang anda jatuh?

Jawapan: Oleh kerana Integer mempunyai himpunan malar, data Integer langsung -128~127 dicache terus ke dalam kolam malar. Jadi 1 berada dalam kolam malar, tetapi 128 tidak.

Walau bagaimanapun, objek Integer baharu tidak sesuai untuk kumpulan tetap. Ini dapat dilihat daripada hasil perbandingan contoh d1 dan d2 sebelum ini.

Seterusnya, mari kita lihat penghakiman rentetan:

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

Pembolehubah rentetan biasa juga boleh mengembalikan hasil yang betul menggunakan tanda ==.

Tetapi jika pembolehubah rentetan biasa digunakan untuk menilai objek rentetan yang dihasilkan oleh yang baharu, palsu akan dikembalikan. Perkara ini berbeza daripada apa yang saya katakan sebelum ini tentang menggunakan jenis asas dan kelas pembungkusan, dan hasil daripada menggunakan pertimbangan nombor tidak mempunyai fungsi unboxing automatik, yang memerlukan perhatian khusus.

Selain itu, apabila dua objek rentetan baharu dinilai menggunakan tanda ==, false juga akan dikembalikan.

2.2 Gunakan kaedah equals

Menggunakan tanda == di atas, anda boleh dengan cepat menentukan sama ada lapan jenis data asas adalah sama Selain itu, anda juga boleh menentukan sama ada rujukan dua objek adalah sama.

Tetapi kini terdapat masalah Ia tidak dapat menentukan sama ada nilai data khusus dua objek dalam ingatan adalah sama. . Apabila mereka menggunakan tanda == untuk menentukan sama ada rujukan adalah sama, mereka kembali palsu.

Jadi, bagaimana kita menilai kesaksamaan apabila objek berbeza tetapi nilai data adalah sama?

J: Gunakan kaedah

. Kaedah

equalsequals sebenarnya adalah kaedah dalam kelas Object:

String g = new String("abc");
String h = new String("abc");
System.out.println(g == h); 
//结果：false

Kaedah ini sangat mudah dan hanya menentukan sama ada rujukan dua objek adalah sama.

Jelas sekali, jika jenis rentetan secara langsung menggunakan kaedah yang sama dengan kelas induk (iaitu kelas Objek) untuk menilai situasi di mana objek berbeza tetapi nilainya sama, terdapat masalah.

Jadi, rentetan (iaitu kelas String) akan melaksanakan semula kaedah equals:

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

Ia masih akan menentukan terlebih dahulu sama ada dua rujukan objek adalah sama dan mengembalikan benar jika ia sama . Seterusnya, dua rentetan akan dibandingkan dengan aksara demi aksara, dan benar akan dikembalikan hanya jika semua aksara adalah sama.

bagus, ini boleh menyelesaikan masalah menilai g dan h:

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

Dapat dilihat bahawa kami menggunakan kaedah sama yang ditulis semula kelas String untuk menilai bahawa dua objek rentetan adalah berbeza , tetapi Apabila nilai adalah sama, benar akan dikembalikan.

3. Pengecualian penunjuk nol

Kita sudah tahu dari titik sebelumnya bahawa untuk menentukan sama ada dua objek adalah sama, anda boleh menggunakan tanda == atau kaedah sama.

Tetapi jika anda menggunakannya dengan lebih mendalam, anda akan menemui masalah, iaitu: jika kedua-dua kaedah ini menentukan bahawa nilai adalah sama, pengecualian penuding nol mungkin dilaporkan.

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

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方法两个参数类型不一致的问题，也没有标识出来。

Kawan-kawan, cepat lihat kod anda. Adakah anda menemui sebarang kesilapan?

Perangkap biasa termasuk:

• Perbandingan antara jenis Long dan jenis Integer, contohnya: senario ID pengguna.

• Perbandingan jenis Byte dan jenis Integer, contohnya: senario pertimbangan status.

• Perbandingan antara jenis Double dan jenis Integer, contohnya: senario penghakiman di mana jumlahnya ialah 0.

Atas ialah kandungan terperinci Analisis contoh perangkap Objects.equals in Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!