Arrays - een helperklasse

1. Arraysklasse

Zoals we eerder hebben opgemerkt, zijn arrays erg handig en worden ze vaak gebruikt bij het programmeren.

De makers van Java merkten al snel dat Java-programmeurs vaak dezelfde code schrijven wanneer ze met arrays werken. Kopieer bijvoorbeeld een deel van een array naar een andere array, codeer om elke cel van een array met dezelfde waarde te vullen, geef de inhoud van een array weer in een handig formaat, enz.

Daarom hebben ze de speciale Arraysklasse gemaakt (de volledige naam is java.util.Arrays), en hebben de meest populaire array-gerelateerde acties erin gestopt.

Het heeft veel methoden voor elke gelegenheid, maar eerst zullen we er slechts 10 bekijken - de eenvoudigste en meest gebruikte.

2.Arrays.toString()

De eerste methode die we zullen bekijken heet Arrays.toString(). Maar eerst een beetje achtergrond.

Elke array in Java heeft een toString()methode die een 'tekstuele weergave van de array' retourneert. U kunt een tekstuele weergave van een array krijgen met behulp van de volgende instructie:

String str = name.toString();

Waar nameis de naam van de arrayvariabele en stris de naam van de variabele waarin de tekenreeksrepresentatie van de array wordt opgeslagen.

Maar als u de array met de methode naar het scherm probeert af te drukken, ziet u waarschijnlijk zoiets als dit:System.out.println(name)

I@37afeb11

De eerste letter Ibetekent dat het een intarray is en de symbolen erna @zijn het adres van de array in het geheugen. Aan de ene kant is dit precies de informatie die is opgeslagen in de array-variabele, maar aan de andere kant hadden we iets anders verwacht, toch?

We wilden de waarden in de array zien! En dat is precies waarom ze de methode bedachten Arrays.toString()- om de waarden van een array weer te geven. We noemen het zo:

String str = Arrays.toString(name);

Voorbeelden:

int[] array = {1, 2, 3};
String str = Arrays.toString(array);

"[1, 2, 3]"

int[] array = {};
String str = Arrays.toString(array);

"[]"

String[] array = {"Hi", "How's", "life?"};
String str = Arrays.toString(array);

"[Hi, How's, life?]"

3.Arrays.deepToString()

Maar als je een tweedimensionale array probeert te converteren naar een string (om het weer te geven) using the Arrays.toString()methode, zie je iets bekends:

[I@37afeb11, I@37afeb21, I@37afeb31]

Dit komt allemaal omdat de cellen van een tweedimensionale array verwijzingen naar eendimensionale arrays opslaan. En hoe worden eendimensionale arrays omgezet in een string? Precies zoals je hierboven ziet.

Wat gedaan kan worden? Hoe geven we een tweedimensionale array correct weer?

Daartoe Arraysheeft de klasse nog een speciale methode — deepToString(). Bellen ziet er zo uit:

String str = Arrays.deepToString(name);

Deze methode kan arrays doorgeven die tweedimensionaal, eendimensionaal, driedimensionaal of, in het algemeen, elke dimensie zijn, en het zal altijd de elementen van de array weergeven.
Opmerking: de Arrays.deepToString()methode werkt niet met eendimensionale arrays van primitieven (bijvoorbeeld int[]).

Voorbeelden:

Integer[] array = {1, 2, 3};
String str = Arrays.deepToString(array);

"[1, 2, 3]"

int[][] array = { {1, 1}, {2, 2}, {3, 3} };
String str = Arrays.deepToString(array);

"[[1, 1], [2, 2], [3, 3]]"

int[][][] array = { {{1, 2, 3}, {1}}, {{}} };
String str = Arrays.deepToString(array);

"[[[1, 2, 3], [1]], [[]]]"

4.Arrays.equals()

We hebben ontdekt hoe we arrays op het scherm kunnen weergeven, maar hoe zit het met het vergelijken van arrays?

Om strings te vergelijken, hebben we equalsen equalsIgnoreCasemethoden, maar welke methoden hebben arrays?

Het goede nieuws is dat arrays een equalsmethode hebben. Het slechte nieuws is dat het de inhoud van de arrays niet vergelijkt. De equalsmethode van arrays doet hetzelfde als de ==operator: het vergelijkt referenties. Voorbeelden:

Voorbeelden:

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
boolean b = x1 == x2;

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
x1.equals(x2);

Wat gedaan kan worden? Hoe vergelijken we arrays op basis van hun inhoud?

En opnieuw Arrayskomt het ons te hulp, of meer specifiek, zijn Arrays.equals()methode. Zo noemen we het:

Arrays.equals(name1, name2)

De methode retourneert trueals de arrays even lang zijn en hun elementen gelijk zijn. Anders keert het terug false.

Voorbeelden:

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
x1.equals(x2);

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3};
Arrays.equals(x1, x2);

int[] x1 = {1, 2, 3};
int[] x2 = {1, 2, 3, 4};
Arrays.equals(x1, x2);

5.Arrays.deepEquals()

En, zoals je waarschijnlijk al vermoedde, Arrays.equalszal de methode niet correct werken voor tweedimensionale arrays: het behandelt tweedimensionale arrays als een eendimensionale array waarvan de elementen adressen zijn van eendimensionale arrays.

Dus om multidimensionale arrays ( n = 1, 2, 3,...) correct te vergelijken, bedachten ze de Arrays.deepEquals()methode. Bellen ziet er zo uit:

Arrays.deepEquals(name1, name2)

De methode keert terugtrueals de arrays even lang zijn en hun elementen gelijk zijn. Anders keert het terugfalse. Als de elementen in de array ook arrays zijn, Arrays.deepEquals()wordt de methode gebruikt om ze te vergelijken, enzovoort.

Voorbeelden:

int[][] x1 = {{1, 2, 3}, {4, 5, 6}};
int[][] x2 = {{1, 2, 3}, {4, 5, 6}};
x1.equals(x2);

int[][] x1 = {{1, 2, 3}, {4, 5, 6}};
int[][] x2 = {{1, 2, 3}, {4, 5, 6}};
Arrays.equals(x1, x2);

int[][] x1 = {{1, 2, 3}, {4, 5, 6}};
int[][] x2 = {{1, 2, 3}, {4, 5, 6}};
Arrays.deepEquals(x1, x2);