Arrays - en hjælperklasse

1. Arraysklasse

Som vi bemærkede tidligere, er arrays et meget nyttigt og ofte brugt i programmering.

Javas skabere bemærkede meget hurtigt, at Java-programmører ofte skriver den samme kode, når de arbejder med arrays. Kopier for eksempel en del af et array til et andet array, kode for at udfylde hver celle i et array med den samme værdi, vis indholdet af et array i et praktisk format osv.

Det er derfor, de oprettede specialklassen Arrays(den fulde navn er java.util.Arrays), og satte de mest populære array-relaterede handlinger ind i den.

Det har en masse metoder til enhver lejlighed, men først vil vi overveje kun 10 af dem - de enkleste og mest brugte.

2.Arrays.toString()

Den første metode, vi vil se på, hedder Arrays.toString(). Men først lidt baggrund.

Hvert array i Java har en toString()metode, som returnerer en 'tekstlig repræsentation af arrayet'. Du kan få en tekstlig repræsentation af et array ved hjælp af følgende sætning:

String str = name.toString();

Hvor nameer navnet på array-variablen, og strer navnet på den variabel, der gemmer strengrepræsentationen af ​​arrayet.

Men hvis du prøver at udskrive arrayet til skærmen ved hjælp af metoden , vil du højst sandsynligt se noget som dette:System.out.println(name)

I@37afeb11

Det første bogstav Ibetyder, at det er et intarray, og symbolerne efter @er adressen på arrayet i hukommelsen. På den ene side er det netop den information, der er gemt i array-variablen, men på den anden side forventede vi noget andet, ikke?

Vi ønskede at se værdierne i arrayet! Og det er netop derfor, de fandt frem til metoden Arrays.toString()- at vise værdierne af et array. Vi kalder det sådan her:

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 at konvertere en todimensional matrix til en streng (for at vise den) using the Arrays.toString()metode, vil du se noget velkendt:

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

Alt dette skyldes, at cellerne i et todimensionelt array lagrer referencer til endimensionelle arrays. Og hvordan konverteres endimensionelle arrays til en streng? Præcis som du ser ovenfor.

Hvad kan gøres? Hvordan viser vi et todimensionelt array korrekt?

Til dette formål Arrayshar klassen en anden speciel metode - deepToString(). At kalde det ser sådan ud:

String str = Arrays.deepToString(name);

Denne metode kan bestå arrays, der er todimensionelle, endimensionelle, tredimensionelle eller generelt en hvilken som helst dimension, og den vil altid vise elementerne i arrayet.
Bemærk: metoden Arrays.deepToString()virker ikke med endimensionelle arrays af primitiver (f.eks. 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 fandt ud af, hvordan man viser arrays på skærmen, men hvad med at sammenligne arrays?

For at sammenligne strenge har vi equalsog equalsIgnoreCasemetoder, men hvilke metoder har arrays?

Den gode nyhed er, at arrays har en equalsmetode. Den dårlige nyhed er, at den ikke sammenligner indholdet af arrays. Metoden equalsmed arrays gør det samme som ==operatøren - den sammenligner referencer. 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);

Hvad kan gøres? Hvordan sammenligner vi arrays baseret på deres indhold?

Og igen Arrayskommer den os til undsætning, eller mere specifikt dens Arrays.equals()metode. Sådan kalder vi det:

Arrays.equals(name1, name2)

Metoden returnerer true, hvis arrays er lige lange og deres elementer er ens. Ellers vender den tilbage 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 gættet, Arrays.equalsvil metoden ikke fungere korrekt for to-dimensionelle arrays: den behandler to-dimensionelle arrays som en en-dimensional array, hvis elementer er adresser til en-dimensionelle arrays.

For korrekt at sammenligne multidimensionelle arrays ( n = 1, 2, 3,...), kom de frem til Arrays.deepEquals()metoden. At kalde det ser sådan ud:

Arrays.deepEquals(name1, name2)

Metoden vender tilbagetruehvis arrays er lige lange og deres elementer er ens. Ellers vender den tilbagefalse. Hvis elementerne inde i arrayet også er arrays, så Arrays.deepEquals()bruges metoden til at 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);