Arrays.deepEquals

1. Áttekintés

Ebben az oktatóanyagban elmélyülünk a deepEquals módszer a Tömbök osztály. Meglátjuk, mikor kell ezt a módszert használni, és áttekintünk néhány egyszerű példát.

Ha többet szeretne megtudni a különböző módszerekről a java.util.A Arrays osztály, nézze meg gyors útmutatónkat.

2. Cél

Nekünk kellene használja a deepEquals módszer, amikor két egymásba ágyazott vagy többdimenziós tömb egyenlőségét akarjuk ellenőrizni. Továbbá, ha két, felhasználó által definiált objektumból álló tömböt akarunk összehasonlítani, amint azt később látni fogjuk, felül kell írnunk egyenlő módszer.

Most megtudhatunk további részleteket a deepEquals módszer.

2.1. Szintaxis

Kezdjük azzal, hogy megnézzük a módszer aláírása:

public static Boolean deepEquals (objektum [] a1, objektum [] a2)

A metódus aláírásból azt vesszük észre nem használhatjuk deepEquals a primitív adattípusok két egydimenziós tömbjének összehasonlításához. Ehhez vagy be kell jelölnünk a primitív tömböt a megfelelő burkolatába, vagy pedig a Tömbök.egyenlő módszer, amely túlterhelt módszereket tartalmaz a primitív tömbökhöz.

2.2. Végrehajtás

A módszer belső megvalósításának elemzésével ezt láthatjuk a módszer nemcsak a tömbök legfelső szintű elemeit ellenőrzi, hanem rekurzív módon ellenőrzi azok minden alelemét is.

Ezért kellene kerülje a deepEquals módszer öntömegű tömbökkel mert ez azt eredményezi, hogy a java.lang.StackOverflowError.

Ezután derítsük ki, milyen kimenetet kaphatunk ezzel a módszerrel.

3. Kimenet

A Arrays.deepEquals metódus visszatér:

  • igaz ha mindkét paraméter ugyanaz az objektum (ugyanaz a hivatkozás)
  • igaz ha mindkét paraméter nulla
  • hamis ha a két paraméter közül csak az egyik nulla
  • hamis ha a tömbök különböző hosszúságúak
  • igaz ha mindkét tömb üres
  • igaz ha a tömbök ugyanannyi elemet tartalmaznak és minden alelempár mélyen egyenlő
  • hamis más esetekben

A következő szakaszban megnézünk néhány kód példát.

4. Példák

Itt az ideje elkezdeni a nézegetést deepEquals módszer működésben. Sőt, összehasonlítjuk a deepEquals módszer a egyenlő módszer ugyanattól Tömbök osztály.

4.1. Egydimenziós tömbök

Először is kezdjünk egy egyszerű példával, és hasonlítsunk össze két egydimenziós típusú tömböt Tárgy:

 Object [] anArray = new Object [] {"string1", "string2", "string3"}; Object [] anotherArray = new Object [] {"string1", "string2", "string3"}; assertTrue (tömbök.egyenlő (anArray, anotherArray)); assertTrue (tömbök.deepEquals (anArray, anotherArray));

Látjuk, hogy mindkettő egyenlő és deepEquals a módszerek visszatérnek igaz. Tudjuk meg, mi történik, ha tömbjeink egyik eleme az nulla:

 Object [] anArray = new Object [] {"string1", null, "string3"}; Object [] anotherArray = new Object [] {"string1", null, "string3"}; assertTrue (tömbök.egyenlő (anArray, anotherArray)); assertTrue (tömbök.deepEquals (anArray, anotherArray));

Látjuk, hogy mindkét állítás elmúlik. Ezért arra következtethetünk, hogy a deepEquals módszer, nulla az értékeket a bemeneti tömbök bármely mélységében elfogadják.

De próbálkozzunk még egy dologgal, és ellenőrizzük a viselkedést beágyazott tömbökkel:

 Object [] anArray = new Object [] {"string1", null, new String [] {"nestedString1", "nestedString2"}}; Object [] anotherArray = new Object [] {"string1", null, new String [] {"nestedString1", "nestedString2"}}; assertFalse (Tömbök.egyenlő (anArray, anotherArray)); assertTrue (tömbök.deepEquals (anArray, anotherArray));

Itt megtudhatjuk, hogy a deepEquals visszatér igaz míg egyenlő visszatér hamis. Ez azért van, mert deepEquals rekurzívan hívja magát egy tömb találkozásakor, míg az egyenlő csak összehasonlítja az altömbök hivatkozásait.

4.2. Primitív típusok többdimenziós tömbjei

Ezután ellenőrizzük a viselkedést többdimenziós tömbök segítségével. A következő példában a két módszer eltérő kimenettel rendelkezik, hangsúlyozva azt a tényt, hogy használnunk kell deepEquals a helyett egyenlő módszer, amikor többdimenziós tömböket hasonlítunk össze:

 int [] [] anArray = {{1, 2, 3}, {4, 5, 6, 9}, {7}}; int [] [] anotherArray = {{1, 2, 3}, {4, 5, 6, 9}, {7}}; assertFalse (Tömbök.egyenlő (anArray, anotherArray)); assertTrue (tömbök.deepEquals (anArray, anotherArray));

4.3. A felhasználó által definiált objektumok többdimenziós tömbjei

Végül ellenőrizzük a deepEquals és egyenlő módszerek kétdimenziós tömb egyenlőségének teszteléséhez egy felhasználó által definiált objektumhoz:

Kezdjük egy egyszerű létrehozásával Személy osztály:

 osztály Személy {privát int id; privát karakterlánc neve; privát int kor; // constructor & getters & setters @Orride public boolean equals (Object obj) {if (this == obj) {return true; } if (obj == null) {return false; } ha (! (Személy objektuma)) hamis; Személy személy = (Személy) obj; return id == személy.id && név.egyenlő (személynév) && kor == személy.kor; }}

Felül kell írni a egyenlő módszer a mi Személy osztály. Ellenkező esetben az alapértelmezett egyenlő módszer csak az objektumok referenciáit fogja összehasonlítani.

Vegyük figyelembe azt is, hogy bár ez a példánk szempontjából nem releváns, mindig felül kell írnunk hash kód amikor felülírjuk a egyenlő módszerrel, hogy ne sértsük meg a szerződéseiket.

Ezután összehasonlíthatjuk a két kétdimenziós tömböt Személy osztály:

 Személy személyArray1 [] [] = {{új személy (1, "John", 22), új személy (2, "Mike", 23)}, {új személy (3, "Steve", 27), új személy ( 4, "Gary", 28)}}; Személy személyArray2 [] [] = {{új személy (1, "John", 22), új személy (2, "Mike", 23)}, {új személy (3, "Steve", 27), új személy ( 4, "Gary", 28)}}; assertFalse (Tömbök.egyenlő (personArray1, personArray2)); assertTrue (tömbök.deepEquals (personArray1, personArray2));

Az alelemek rekurzív összehasonlításának eredményeként a két módszer ismét eltérő eredményekkel jár.

Végül érdemes megemlíteni, hogy aObjects.deepEquals metódus végrehajtja a Arrays.deepEquals módszer belsőleg amikor kettővel hívják Tárgy tömbök:

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

5. Következtetés

Ebben a gyors bemutatóban megtudtuk, hogy a Arrays.deepEquals módszer, amikor össze akarjuk hasonlítani a objektumok vagy primitív típusok két egymásba ágyazott vagy többdimenziós tömbje közötti egyenlőség.

Mint mindig, a cikk teljes forráskódja elérhető a GitHubon.