Arrays — en hjälparklass

1. Arraysklass

Som vi noterade tidigare är arrayer mycket användbara och används ofta i programmering.

Javas skapare märkte mycket snabbt att Java-programmerare ofta skriver samma kod när de arbetar med arrayer. Till exempel kopiera en del av en array till en annan array, kod för att fylla varje cell i en array med samma värde, visa innehållet i en array i ett bekvämt format, etc.

Det är därför de skapade specialklassen Arrays(dess fullständiga namn är java.util.Arrays), och lade in de mest populära array-relaterade åtgärderna i den.

Den har många metoder för varje tillfälle, men först ska vi överväga bara 10 av dem - de enklaste och mest använda.

2.Arrays.toString()

Den första metoden vi ska titta på kallas Arrays.toString(). Men först lite bakgrund.

Varje array i Java har en toString()metod som returnerar en "textuell representation av arrayen". Du kan få en textrepresentation av en array med följande uttalande:

String str = name.toString();

Var nameär namnet på arrayvariabeln och strär namnet på variabeln som kommer att lagra strängrepresentationen av arrayen.

Men om du försöker skriva ut arrayen till skärmen med metoden, kommer du troligen att se något så här:System.out.println(name)

I@37afeb11

Den första bokstaven Ibetyder att det är en intarray, och symbolerna efter @är adressen till arrayen i minnet. Å ena sidan är detta just den information som lagras i arrayvariabeln, men å andra sidan förväntade vi oss något annat, eller hur?

Vi ville se värdena i arrayen! Och det är precis därför de kom på metoden Arrays.toString()- att visa värdena för en array. Vi kallar det så här:

String str = Arrays.toString(name);

Exempel:

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 om du försöker konvertera en tvådimensionell array till en strängmetod (för att visa den) using the Arrays.toString()kommer du att se något bekant:

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

Allt detta beror på att cellerna i en tvådimensionell array lagrar referenser till endimensionella arrayer. Och hur konverteras endimensionella arrayer till en sträng? Precis som du ser ovan.

Vad kan göras? Hur visar vi en tvådimensionell array korrekt?

För detta ändamål Arrayshar klassen en annan speciell metod — deepToString(). Att kalla det ser ut så här:

String str = Arrays.deepToString(name);

Denna metod kan överföras arrayer som är tvådimensionella, endimensionella, tredimensionella eller i allmänhet vilken dimension som helst, och den kommer alltid att visa elementen i arrayen.
Obs: metoden Arrays.deepToString()fungerar inte med endimensionella arrayer av primitiver (till exempel ) int[].

Exempel:

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 kom på hur man visar arrayer på skärmen, men hur är det med att jämföra arrayer?

För att jämföra strängar har vi equalsoch equalsIgnoreCasemetoder, men vilka metoder har arrayer?

Den goda nyheten är att arrayer har en equalsmetod. Den dåliga nyheten är att den inte jämför innehållet i arrayerna. Metoden equalsför arrayer gör samma sak som ==operatören - den jämför referenser. Exempel:

Exempel:

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

Vad kan göras? Hur jämför vi arrayer baserat på deras innehåll?

Och återigen Arrayskommer den till vår räddning, eller mer specifikt, dess Arrays.equals()metod. Så här kallar vi det:

Arrays.equals(name1, name2)

Metoden returnerar trueom arrayerna är lika långa och deras element är lika. Annars kommer den tillbaka false.

Exempel:

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

Och, som du förmodligen redan gissat, Arrays.equalskommer metoden inte att fungera korrekt för tvådimensionella arrayer: den behandlar tvådimensionella arrayer som en endimensionell array vars element är adresser till endimensionella arrayer.

För att korrekt jämföra flerdimensionella arrayer ( n = 1, 2, 3,...) kom de alltså på Arrays.deepEquals()metoden. Att kalla det ser ut så här:

Arrays.deepEquals(name1, name2)

Metoden återkommertrueom arrayerna är lika långa och deras element är lika. Annars kommer det tillbakafalse. Om elementen inuti arrayen också är arrayer, Arrays.deepEquals()används metoden för att jämföra dem, och så vidare.

Exempel:

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