Arrays in Java vergelijken

1. Overzicht

In deze tutorial gaan we kijken naar verschillende manieren om arrays in Java te vergelijken. We behandelen conventionele methoden en we zullen ook enkele voorbeelden zien met behulp van lambdauitdrukkingen.

2. Arrays vergelijken

We gaan arrays in Java vergelijken, en zoals we weten, zijn dit objecten. Laten we daarom enkele basisconcepten vernieuwen:

  • Objecten hebben verwijzingen en waarden
  • Twee gelijke verwijzingen moeten naar dezelfde waarde verwijzen
  • Twee verschillende waarden moeten verschillende verwijzingen hebben
  • Twee gelijke waarden hebben niet noodzakelijk dezelfde verwijzingen
  • Primitieve waarden worden alleen per waarde vergeleken
  • Letterlijke tekenreeksen worden alleen per waarde vergeleken

2.1. Objectverwijzingen vergelijken

Als we twee verwijzingen naar dezelfde array hebben, zouden we altijd een resultaat moeten krijgen waar in een gelijkwaardige vergelijking met de == operator.

Laten we naar een voorbeeld kijken:

String [] planes1 = nieuwe String [] {"A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332"}; String [] planes2 = planes1;

Eerst hebben we een reeks vliegtuigmodellen gemaakt waarnaar wordt verwezen door vliegtuigen 1. We creëren dan vliegtuigen 2, welke referenties vliegtuigen 1. Door dit te doen, zijn we twee referenties aanmakennaar dezelfde array in het geheugen. Daarom, de "Planes1 == planes2" uitdrukking zal terugkeren waar.

Voor arrays is het is gelijk aan () methode is hetzelfde als de == operator. Zo, planes1.equals (planes2) geeft terug waar omdat beide verwijzingen naar hetzelfde object verwijzen. In het algemeen, array1.eqauls (array2) zal terugkeren waar als en slechts als de uitdrukking “array1 == array2 ″ geeft terug waar.

Laten we stellen of de twee referenties hetzelfde zijn:

assertThat (planes1) .isSameAs (planes2);

Laten we er nu zeker van zijn dat de waarden waarnaar wordt verwezen door vliegtuigen 1 zijn eigenlijk dezelfde als die waarnaar wordt verwezen door vliegtuigen 2. Daarom kunnen we de array wijzigen waarnaar wordt verwezen vliegtuigen2, en controleer of de wijzigingen enige invloed hebben op de array waarnaar wordt verwezen door vliegtuigen 1:

planes2 [0] = "747";

Laten we, om dit eindelijk te zien werken, onze beweringen doen:

assertThat (planes1) .isSameAs (planes2); assertThat (planes2 [0]). isEqualTo ("747"); assertThat (planes1 [0]). isEqualTo ("747");

Met deze unit-test konden we twee arrays vergelijken door middel van referentie.

Dat hebben we echter alleen bewezen een referentie, eenmaal toegewezen aan de waarde van een andere, zal naar dezelfde waarde verwijzen.

We gaan nu twee verschillende arrays maken met dezelfde waarden:

String [] planes1 = nieuwe String [] {"A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332"}; String [] planes2 = nieuwe String [] {"A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332"};

Omdat het verschillende objecten zijn, weten we zeker dat ze niet hetzelfde zijn. We kunnen ze daarom vergelijken:

assertThat (planes1) .isNotSameAs (planes2);

Samenvattend hebben we in dit geval twee arrays in het geheugen die hetzelfde bevatten Draad waarden in exact dezelfde volgorde. De arrays waarnaar wordt verwezen, verschillen echter niet alleen qua inhoud, maar de verwijzingen zelf zijn ook verschillend.

2.2. Array-lengtes vergelijken

De lengte van de arrays kan hoe dan ook worden vergeleken van hun elementtypen, of hun waarden al dan niet zijn ingevuld.

Laten we twee arrays maken:

final String [] planes1 = nieuwe String [] {"A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332"}; definitief geheel getal [] hoeveelheden = nieuw geheel getal [] {10, 12, 34, 45, 12, 43, 5, 2};

Dit zijn twee verschillende arrays met verschillende elementtypes. In deze dataset registreren we bijvoorbeeld hoeveel vliegtuigen van elk model er in het magazijn zijn opgeslagen. Laten we er nu unit-tests op uitvoeren:

assertThat (planes1) .hasSize (8); assertThat (hoeveelheden) .hasSize (8);

Hiermee hebben we bewezen dat beide arrays acht elementen hebben en dat de lengte eigenschap retourneert het juiste aantal elementen voor elke array.

2.3. Arrays vergelijken met Arrays.equals

Tot dusver hebben we arrays alleen vergeleken op basis van hun objectidentiteiten. Aan de andere kant, Om te controleren of twee arrays qua inhoud gelijk zijn, biedt Java de Arrays.equals statische methode. Deze methode doorloopt de arrays, per positie parallel, en past de == operator toe,voor elk paar elementen.

Laten we twee verschillende arrays maken met hetzelfde Draad letterlijke letters in exact dezelfde volgorde:

String [] planes1 = nieuwe String [] {"A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332"}; String [] planes2 = nieuwe String [] {"A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332"};

En laten we nu beweren dat ze gelijk zijn:

assertThat (Arrays.equals (planes1, planes2)). isTrue ();

Als we de volgorde van de waarden van de tweede array wijzigen:

String [] planes1 = nieuwe String [] {"A320", "B738", "A321", "A319", "B77W", "B737", "A333", "A332"}; String [] planes2 = nieuwe String [] {"B738", "A320", "A321", "A319", "B77W", "B737", "A333", "A332"}; 

We krijgen een ander resultaat:

assertThat (Arrays.equals (planes1, planes2)). isFalse ();

2.4. Arrays vergelijken met Arrays.deepEquals

De ... gebruiken == operator is eenvoudig als we eenvoudige typen in Java gebruiken. Dit kunnen primitieve typen zijn of Draad letterlijke. Een vergelijking tussen arrays van Voorwerps kan ingewikkelder zijn. De reden hiervoor wordt volledig uitgelegd in ons Arrays.deepEquals artikel. Laten we een voorbeeld bekijken.

Laten we eerst beginnen met een Vliegtuig klasse:

public class Plane {private final String naam; privé definitief String-model; // getters en setters}

En laten we het hashCode en is gelijk aan methoden:

@Override public boolean is gelijk aan (Object o) if (this == o) retourneert true; if (o == null @Override public int hashCode () {return Objects.hash (naam, model);}

Ten tweede maken we de volgende arrays met twee elementen:

Vliegtuig [] [] planes1 = nieuw vliegtuig [] [] {nieuw vliegtuig [] {nieuw vliegtuig ("Vliegtuig 1", "A320")}, nieuw vliegtuig [] {nieuw vliegtuig ("Vliegtuig 2", "B738") }}; Vliegtuig [] [] planes2 = nieuw vliegtuig [] [] {nieuw vliegtuig [] {nieuw vliegtuig ("Vliegtuig 1", "A320")}, nieuw vliegtuig [] {nieuw vliegtuig ("Vliegtuig 2", "B738") }}; 

Laten we nu kijken of het echte, zeer gelijke arrays zijn:

assertThat (Arrays.deepEquals (planes1, planes2)). isTrue ();

Om er zeker van te zijn dat onze vergelijking werkt zoals verwacht, gaan we nu de volgorde van onze laatste array wijzigen:

Vliegtuig [] [] planes1 = nieuw vliegtuig [] [] {nieuw vliegtuig [] {nieuw vliegtuig ("Vliegtuig 1", "A320")}, nieuw vliegtuig [] {nieuw vliegtuig ("Vliegtuig 2", "B738") }}; Vliegtuig [] [] planes2 = nieuw vliegtuig [] [] {nieuw vliegtuig [] {nieuw vliegtuig ("Vliegtuig 2", "B738")}, nieuw vliegtuig [] {nieuw vliegtuig ("Vliegtuig 1", "A320") }};

Laten we tot slot testen of ze inderdaad niet meer gelijk zijn:

assertThat (Arrays.deepEquals (planes1, planes2)). isFalse ();

2.5. Arrays met verschillende orden van elementen vergelijken

Om te controleren of arrays gelijk zijn, ongeacht de volgorde van de elementen, moeten we definiëren wat maakt een voorbeeld van onze Vliegtuig uniek. In ons geval is een andere naam of model voldoende om te bepalen dat het ene vlak verschilt van het andere. We hebben dit vastgesteld door beide al te hebben geïmplementeerd hashCode en is gelijk aan methoden. Dit houdt in dat voordat we onze arrays kunnen vergelijken, we ze moeten sorteren. Daarvoor hebben we een Comparator:

Comparator planeComparator = (o1, o2) -> {if (o1.getName (). Equals (o2.getName ())) {retourneer o2.getModel (). CompareTo (o1.getModel ()); } retourneer o2.getName (). CompareTo (o1.getName ()); };

In deze Comparator, we geven voorrang aan de naam. Als de namen gelijk zijn, lossen we de dubbelzinnigheid op door naar het model te kijken. We vergelijken strings met behulp van de vergelijk met methode van het type Draad.

We willen kunnen achterhalen of arrays gelijk zijn, ongeacht de sorteervolgorde. Om dat te doen, laten we nu onze arrays sorteren:

Arrays.sort (planes1 [0], planeComparator); Arrays.sort (planes2 [0], planeComparator);

En tot slot, laten we ze testen:

assertThat (Arrays.deepEquals (planes1, planes2)). isTrue ();

Nadat we de arrays eerst in dezelfde volgorde hebben gesorteerd, staan ​​we de deepEquals methode om te bepalen of deze twee arrays gelijk zijn.

3. Conclusie

In deze zelfstudie hebben we verschillende manieren gezien om arrays te vergelijken. Ten tweede zagen we het verschil tussen het vergelijken van referenties en waarden. Daarnaast hebben we onderzocht hoe we arrays diep kunnen vergelijken. Ten slotte zagen we het verschil tussen een normale vergelijking en een diepe vergelijking met is gelijk aan en deepEquals, respectievelijk.

Zoals altijd is de volledige broncode voor de voorbeelden beschikbaar op GitHub.