Arrays - en hjelperklasse

1. Arraysklasse

Som vi bemerket tidligere, er arrays en svært nyttig og ofte brukt i programmering.

Javas skapere la veldig raskt merke til at Java-programmerere ofte skriver den samme koden når de jobber med arrays. For eksempel, kopier en del av en matrise til en annen matrise, kode for å fylle hver celle i en matrise med samme verdi, vis innholdet i en matrise i et praktisk format, etc.

Det er derfor de opprettet spesialklassen Arrays(dens fulle navn er java.util.Arrays), og la de mest populære array-relaterte handlingene inn i den.

Den har mange metoder for enhver anledning, men først skal vi vurdere bare 10 av dem - de enkleste og mest brukte.

2.Arrays.toString()

Den første metoden vi skal se på heter Arrays.toString(). Men først, litt bakgrunn.

Hver array i Java har en toString()metode som returnerer en 'tekstlig representasjon av arrayen'. Du kan få en tekstlig representasjon av en matrise ved å bruke følgende setning:

String str = name.toString();

Hvor nameer navnet på matrisevariabelen, og strer navnet på variabelen som vil lagre strengrepresentasjonen til matrisen.

Men hvis du prøver å skrive ut matrisen til skjermen ved hjelp av metoden, vil du mest sannsynlig se noe slikt:System.out.println(name)

I@37afeb11

Den første bokstaven Ibetyr at det er en intmatrise, og symbolene etter @er adressen til matrisen i minnet. På den ene siden er dette nettopp informasjonen som er lagret i array-variabelen, men på den andre siden forventet vi noe annet, ikke sant?

Vi ønsket å se verdiene i matrisen! Og det er nettopp derfor de kom opp med metoden Arrays.toString()- å vise verdiene til en matrise. Vi kaller det slik:

String str = Arrays.toString(name);

Eksempler:

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()

Men hvis du prøver å konvertere en todimensjonal matrise til en streng (for å vise den) using the Arrays.toString()metode, vil du se noe kjent:

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

Dette er alt fordi cellene i en todimensjonal matrise lagrer referanser til endimensjonale matriser. Og hvordan konverteres endimensjonale arrays til en streng? Akkurat som du ser ovenfor.

Hva kan bli gjort? Hvordan viser vi en todimensjonal matrise riktig?

For dette formål Arrayshar klassen en annen spesiell metode - deepToString(). Å kalle det ser slik ut:

String str = Arrays.deepToString(name);

Denne metoden kan bestå matriser som er todimensjonale, endimensjonale, tredimensjonale eller generelt en hvilken som helst dimensjon, og den vil alltid vise elementene i matrisen.
Merk: metoden Arrays.deepToString()fungerer ikke med endimensjonale arrays av primitiver (for eksempel int[]).

Eksempler:

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()

Vi fant ut hvordan vi skulle vise arrays på skjermen, men hva med å sammenligne arrays?

For å sammenligne strenger har vi equalsog equalsIgnoreCasemetoder, men hvilke metoder har arrays?

Den gode nyheten er at arrays har en equalsmetode. Den dårlige nyheten er at den ikke sammenligner innholdet i arrayene. Metoden equalsfor arrays gjør det samme som ==operatøren - den sammenligner referanser. Eksempler:

Eksempler:

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);

Hva kan bli gjort? Hvordan sammenligner vi matriser basert på innholdet deres?

Og igjen Arrayskommer den til unnsetning, eller mer spesifikt Arrays.equals()metoden. Dette er hvordan vi kaller det:

Arrays.equals(name1, name2)

Metoden returnerer truehvis matrisene er like lange og elementene deres er like. Ellers kommer den tilbake false.

Eksempler:

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()

Og, som du sikkert allerede har gjettet, Arrays.equalsvil ikke metoden fungere riktig for todimensjonale matriser: den behandler todimensjonale matriser som en endimensjonal matrise hvis elementer er adresser til endimensjonale matriser.

For å korrekt sammenligne flerdimensjonale arrays ( n = 1, 2, 3,...), kom de opp med Arrays.deepEquals()metoden. Å kalle det ser slik ut:

Arrays.deepEquals(name1, name2)

Metoden kommer tilbaketruehvis matrisene er like lange og elementene deres er like. Ellers kommer den tilbakefalse. Hvis elementene inne i matrisen også er matriser, Arrays.deepEquals()brukes metoden for å sammenligne dem, og så videre.

Eksempler:

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);