Arrays.deepEquals

1. Overzicht

In deze tutorial gaan we dieper in op de details van het deepEquals methode van de Arrays klasse. We zullen zien wanneer we deze methode moeten gebruiken, en we zullen enkele eenvoudige voorbeelden doornemen.

Voor meer informatie over de verschillende methoden in het java.util.Arrays les, bekijk dan onze beknopte handleiding.

2. Doel

We zouden gebruik de deepEquals methode wanneer we de gelijkheid tussen twee geneste of multidimensionale arrays willen controleren. Als we twee arrays willen vergelijken die zijn samengesteld uit door de gebruiker gedefinieerde objecten, zoals we later zullen zien, moeten we de is gelijk aan methode.

Laten we nu eens kijken naar meer details over het deepEquals methode.

2.1. Syntaxis

We beginnen met het bekijken van het methode handtekening:

openbare statische boolean deepEquals (Object [] a1, Object [] a2)

Dat merken we aan de methodehandtekening we kunnen niet gebruiken deepEquals om twee eendimensionale arrays van primitieve gegevenstypen te vergelijken. Hiervoor moeten we de primitieve array in de bijbehorende wrapper plaatsen of de Arrays.equals methode, die de methoden voor primitieve arrays heeft overbelast.

2.2. Implementatie

Door de interne implementatie van de methode te analyseren, kunnen we dat zien de methode controleert niet alleen de elementen op het hoogste niveau van de arrays, maar controleert ook recursief elk subelement ervan.

Daarom moeten we vermijd het gebruik van de deepEquals methode met arrays die een zelfreferentie hebben omdat dit resulteert in een java.lang.StackOverflowError.

Laten we vervolgens kijken welke output we van deze methode kunnen krijgen.

3. Uitvoer

De Arrays.deepEquals methode retourneert:

  • waar als beide parameters hetzelfde object zijn (dezelfde referentie hebben)
  • waar als beide parameters zijn nul
  • false als slechts een van de twee parameters is nul
  • false als de arrays verschillende lengtes hebben
  • waar als beide arrays leeg zijn
  • waar als de arrays hetzelfde aantal elementen bevatten en elk paar subelementen diep gelijk is
  • false in andere gevallen

In de volgende sectie zullen we enkele codevoorbeelden bekijken.

4. Voorbeelden

Nu is het tijd om naar te kijken deepEquals methode in actie. Bovendien zullen we de deepEquals methode met de is gelijk aan methode van hetzelfde Arrays klasse.

4.1. Unidimensionale arrays

Laten we eerst beginnen met een eenvoudig voorbeeld en twee unidimensionale arrays van het type vergelijken Voorwerp:

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

We zien dat beide is gelijk aan en deepEquals methoden terugkeren waar. Laten we eens kijken wat er gebeurt als een element van onze arrays is nul:

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

We zien dat beide beweringen voorbijgaan. Daarom kunnen we concluderen dat bij gebruik van de deepEquals methode, nul waarden worden geaccepteerd op elke diepte van de invoerarrays.

Maar laten we nog een ding proberen en laten we het gedrag met geneste arrays controleren:

 Object [] anArray = nieuw object [] {"string1", null, nieuwe string [] {"nestedString1", "nestedString2"}}; Object [] anotherArray = nieuw object [] {"string1", null, nieuwe string [] {"nestedString1", "nestedString2"}}; assertFalse (Arrays.equals (anArray, anotherArray)); assertTrue (Arrays.deepEquals (anArray, anotherArray));

Hier ontdekken we dat de deepEquals geeft terug waar terwijl is gelijk aan geeft terug false. Dit is zo omdat deepEquals roept zichzelf recursief aan bij het tegenkomen van een array, terwijl gelijk is vergelijkt alleen de referenties van de sub-arrays.

4.2. Multidimensionale arrays van primitieve typen

Laten we vervolgens het gedrag controleren met behulp van multidimensionale arrays. In het volgende voorbeeld hebben de twee methoden verschillende outputs, wat het feit benadrukt dat we moeten gebruiken deepEquals in plaats van de is gelijk aan methode wanneer we multidimensionale arrays vergelijken:

 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. Multidimensionale arrays van door de gebruiker gedefinieerde objecten

Laten we tot slot het gedrag van deepEquals en is gelijk aan methoden bij het testen van de gelijkheid van twee multidimensionale arrays voor een door de gebruiker gedefinieerd object:

Laten we beginnen met het maken van een eenvoudig Persoon klasse:

 klasse Persoon {privé int id; private String naam; privé int leeftijd; // 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; Persoon person = (Persoon) obj; return id == person.id && name.equals (person.name) && leeftijd == person.age; }}

Het is noodzakelijk om het is gelijk aan methode voor onze Persoon klasse. Anders is de default is gelijk aan methode zal alleen de referenties van de objecten vergelijken.

Laten we er ook rekening mee houden dat, hoewel het niet relevant is voor ons voorbeeld, we altijd moeten overschrijven hashCode wanneer we de is gelijk aan methode zodat we hun contracten niet schenden.

Vervolgens kunnen we twee multidimensionale arrays van de Persoon klasse:

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

Als resultaat van het recursief vergelijken van de subelementen, hebben de twee methoden weer verschillende resultaten.

Ten slotte is het vermeldenswaard dat deObjects.deepEquals methode voert het Arrays.deepEquals methode intern wanneer het wordt aangeroepen met twee Voorwerp arrays:

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

5. Conclusie

In deze korte tutorial hebben we geleerd dat we de Arrays.deepEquals methode wanneer we de gelijkheid tussen twee geneste of meerdimensionale reeksen objecten of primitieve typen.

Zoals altijd is de volledige broncode van het artikel beschikbaar op GitHub.