Arrays.deepEquals

1. Gambaran keseluruhan

Dalam tutorial ini, kita akan menyelami perincian kaedah deepEquals dari kelas Arrays . Kita akan melihat bila kita harus menggunakan kaedah ini, dan kita akan melalui beberapa contoh mudah.

Untuk mengetahui lebih lanjut mengenai kaedah yang berbeza di kelas java.util.Arays , lihat panduan ringkas kami.

2. Tujuan

Kita harus menggunakan kaedah deepEquals ketika kita ingin memeriksa persamaan antara dua susunan bersarang atau pelbagai dimensi . Juga, apabila kita ingin membandingkan dua tatasusunan yang terdiri daripada objek yang ditentukan pengguna, seperti yang akan kita lihat kemudian, kita mesti mengatasi kaedah sama .

Sekarang, mari kita ketahui lebih banyak maklumat mengenai kaedah deepEquals .

2.1. Sintaks

Kita akan mulakan dengan melihat tandatangan kaedah :

public static boolean deepEquals(Object[] a1, Object[] a2)

Dari kaedah tandatangan, kami perhatikan bahawa kami tidak dapat menggunakan deepEquals untuk membandingkan dua susunan unidimensi jenis data primitif . Untuk ini, kita mesti memasukkan array primitif ke pembungkus yang sesuai atau menggunakan kaedah Arrays.equals , yang mempunyai kaedah yang terlalu banyak untuk array primitif.

2.2. Pelaksanaan

Dengan menganalisis pelaksanaan dalaman kaedah, kita dapat melihat bahawa kaedah tersebut tidak hanya memeriksa elemen-elemen tingkat atas array tetapi juga memeriksa setiap subelemennya secara berulang .

Oleh itu, kita harus mengelakkan penggunaan kaedah deepEquals dengan tatasusunan yang mempunyai rujukan diri kerana ini akan menghasilkan ralat java.lang.StackOverflowError .

Seterusnya, mari kita ketahui apa output yang kita dapat dari kaedah ini.

3. Keluaran

The Arrays.deepEquals kaedah pulangan:

  • benar jika kedua-dua parameter adalah objek yang sama (mempunyai rujukan yang sama)
  • benar sekiranya kedua-dua parameter tersebut tidak sah
  • salah jika hanya salah satu daripada dua parameter yang nol
  • salah jika tatasusunan mempunyai panjang yang berbeza
  • benar sekiranya kedua-dua tatasusunan itu kosong
  • benar jika tatasusunan mengandungi bilangan elemen yang sama dan setiap pasangan subelemen adalah sama
  • palsu dalam kes lain

Di bahagian seterusnya, kita akan melihat beberapa contoh kod.

4. Contohnya

Kini tiba masanya untuk mula melihat kaedah deepEquals dalam tindakan. Lebih-lebih lagi, kami akan bandingkan deepEquals kaedah dengan sama dengan kaedah dari yang sama Tatasusunan kelas.

4.1. Susunan Tidak Dimensi

Pertama, mari kita mulakan dengan contoh mudah dan membandingkan dua tatasusunan jenis objek yang tidak dimensi :

 Object[] anArray = new Object[] { "string1", "string2", "string3" }; Object[] anotherArray = new Object[] { "string1", "string2", "string3" }; assertTrue(Arrays.equals(anArray, anotherArray)); assertTrue(Arrays.deepEquals(anArray, anotherArray));

Kami melihat bahawa kedua-dua kaedah sama dan deepEquals kembali benar . Mari kita ketahui apa yang berlaku jika salah satu elemen tatasusunan kita adalah kosong :

 Object[] anArray = new Object[] { "string1", null, "string3" }; Object[] anotherArray = new Object[] { "string1", null, "string3" }; assertTrue(Arrays.equals(anArray, anotherArray)); assertTrue(Arrays.deepEquals(anArray, anotherArray));

Kami melihat bahawa kedua-dua penegasan ini berlalu. Oleh itu, kita dapat menyimpulkan bahawa apabila menggunakan kaedah deepEquals , nilai nol diterima pada kedalaman array input .

Tetapi mari kita cuba satu perkara lagi dan mari kita periksa tingkah laku dengan tatasusunan bersarang:

 Object[] anArray = new Object[] { "string1", null, new String[] {"nestedString1", "nestedString2" }}; Object[] anotherArray = new Object[] { "string1", null, new String[] {"nestedString1", "nestedString2" } }; assertFalse(Arrays.equals(anArray, anotherArray)); assertTrue(Arrays.deepEquals(anArray, anotherArray));

Di sini kita dapati bahawa deepEquals kembali benar dan sama dengan pulangan palsu . Ini kerana deepEquals memanggil dirinya secara berulang-ulang ketika menghadapi array , sementara sama membandingkan rujukan sub-array.

4.2. Susunan Multidimensi Jenis Primitif

Seterusnya, mari kita periksa tingkah laku menggunakan tatasusunan multidimensi. Dalam contoh seterusnya, kedua-dua kaedah mempunyai output yang berbeza, menekankan hakikat bahawa kita harus menggunakan deepEquals dan bukannya kaedah yang sama ketika kita membandingkan tatasusunan multidimensi:

 int[][] anArray = { { 1, 2, 3 }, { 4, 5, 6, 9 }, { 7 } }; int[][] anotherArray = { { 1, 2, 3 }, { 4, 5, 6, 9 }, { 7 } }; assertFalse(Arrays.equals(anArray, anotherArray)); assertTrue(Arrays.deepEquals(anArray, anotherArray));

4.3. Susunan Multidimensi Objek yang Ditentukan Pengguna

Akhirnya, mari kita periksa tingkah laku deepEquals dan kaedah sama dengan menguji persamaan dua tatasusunan multidimensi untuk objek yang ditentukan pengguna:

Mari mulakan dengan membuat kelas Orang sederhana :

 class Person { private int id; private String name; private int age; // constructor & getters & setters @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (!(obj instanceof Person)) return false; Person person = (Person) obj; return id == person.id && name.equals(person.name) && age == person.age; } }

Adalah perlu untuk mengatasi kaedah sama untuk kelas Orang kita . Jika tidak, kaedah sama dengan lalai hanya akan membandingkan rujukan objek.

Juga, mari kita pertimbangkan bahawa, walaupun tidak relevan dengan contoh kita, kita harus selalu mengganti hashCode ketika kita mengganti kaedah sama sehingga kita tidak melanggar kontrak mereka.

Seterusnya, kita dapat membandingkan dua tatasusunan multidimensi kelas Person :

 Person personArray1[][] = { { new Person(1, "John", 22), new Person(2, "Mike", 23) }, { new Person(3, "Steve", 27), new Person(4, "Gary", 28) } }; Person personArray2[][] = { { new Person(1, "John", 22), new Person(2, "Mike", 23) }, { new Person(3, "Steve", 27), new Person(4, "Gary", 28) } }; assertFalse(Arrays.equals(personArray1, personArray2)); assertTrue(Arrays.deepEquals(personArray1, personArray2));

Hasil daripada membandingkan subelemen secara berulang, kedua-dua kaedah sekali lagi mempunyai hasil yang berbeza.

Akhirnya, perlu disebutkan bahawa kaedah Objects.deepEquals melaksanakan kaedah Arrays.deepEquals secara dalaman apabila dipanggil dengan dua array Objek :

 assertTrue(Objects.deepEquals(personArray1, personArray2));

5. Kesimpulan

Dalam tutorial ringkas ini, kami mengetahui bahawa kami harus menggunakan kaedah Arrays.deepEquals ketika kami ingin membandingkan persamaan antara dua susunan objek atau jenis primitif bersarang atau pelbagai dimensi .

Seperti biasa, kod sumber penuh artikel terdapat di GitHub.