Tömbök — segítő osztály

1. Arraysosztály

Amint azt korábban megjegyeztük, a tömbök nagyon hasznosak és gyakran használtak a programozásban.

A Java készítői nagyon hamar észrevették, hogy a Java programozók gyakran ugyanazt a kódot írják le, amikor tömbökkel dolgoznak. Például egy tömb egy részét másolja át egy másik tömbbe, kódolja a tömb minden celláját ugyanazzal az értékkel, egy tömb tartalmát jelenítse meg kényelmes formátumban stb.

Ezért hozták létre a speciális Arraysosztályt (teljes neve java.util.Arrays), belerakva a legnépszerűbb tömbhöz kapcsolódó műveleteket.

Számos módszert tartalmaz minden alkalomra, de először csak 10-et veszünk figyelembe ezek közül – a legegyszerűbb és leggyakrabban használt.

2.Arrays.toString()

Az első módszer, amelyet megvizsgálunk, az ún Arrays.toString(). De először egy kis háttér.

A Java minden tömbjének van egy toString()metódusa, amely „a tömb szöveges megjelenítését” adja vissza. Egy tömb szöveges ábrázolását a következő utasítással kaphatja meg:

String str = name.toString();

Ahol namea tömbváltozó neve, és strannak a változónak a neve, amely a tömb karakterlánc-reprezentációját fogja tárolni.

De ha a módszerrel megpróbálja kinyomtatni a tömböt a képernyőre , akkor valószínűleg valami ilyesmit fog látni:System.out.println(name)

I@37afeb11

Az első betű Iazt jelenti, hogy ez egy inttömb, az utána lévő szimbólumok@ pedig a tömb címét jelentik a memóriában. Egyrészt pontosan ez a tömbváltozóban tárolt információ, másrészt viszont másra számítottunk, nem?

Szerettük volna látni az értékeket a tömbben! És pontosan ezért találták ki a Arrays.toString()módszert – egy tömb értékeinek megjelenítésére. Mi így hívjuk:

String str = Arrays.toString(name);

Példák:

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

De ha megpróbál egy kétdimenziós tömböt karakterláncos metódussá konvertálni (megjeleníteni) using the Arrays.toString(), valami ismerős dolgot fog látni:

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

Mindez azért van, mert egy kétdimenziós tömb cellái egydimenziós tömbökre utalnak. És hogyan konvertálhatók az egydimenziós tömbök karakterláncokká? Pontosan úgy, ahogy fentebb látod.

Mit lehet tenni? Hogyan jelenítsünk meg helyesen egy kétdimenziós tömböt?

Ennek érdekében az Arraysosztálynak van egy másik speciális metódusa - deepToString(). A hívás így néz ki:

String str = Arrays.deepToString(name);

Ezzel a módszerrel kétdimenziós, egydimenziós, háromdimenziós vagy általában bármilyen dimenziós tömbök adhatók át, és mindig megjeleníti a tömb elemeit.
Megjegyzés: a Arrays.deepToString()módszer nem működik primitívek egydimenziós tömbjeivel (például int[]).

Példák:

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

Kitaláltuk, hogyan jelenítsük meg a tömböket a képernyőn, de mi a helyzet a tömbök összehasonlításával?

A karakterláncok összehasonlításához equalsés equalsIgnoreCasemetódusaink vannak, de milyen metódusai vannak a tömböknek?

A jó hír az, hogy a tömböknek van equalsmódszerük. A rossz hír az, hogy nem hasonlítja össze a tömbök tartalmát. A equalstömbök metódusa ugyanazt teszi, mint az ==operátor – összehasonlítja a hivatkozásokat. Példák:

Példák:

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

Mit lehet tenni? Hogyan hasonlítsuk össze a tömböket tartalmuk alapján?

És megint a Arrayssegítségünkre van, pontosabban a módszere Arrays.equals(). Így hívjuk:

Arrays.equals(name1, name2)

A metódus akkor tér vissza true, ha a tömbök egyenlő hosszúak és az elemeik egyenlőek. Ellenkező esetben visszatér false.

Példák:

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

És ahogy valószínűleg már sejtette, a Arrays.equalsmódszer nem fog megfelelően működni kétdimenziós tömbök esetén: a kétdimenziós tömböket úgy kezeli, mint egy egydimenziós tömböt, amelynek elemei egydimenziós tömbök címei.

Így a többdimenziós tömbök ( n = 1, 2, 3,...) helyes összehasonlításához kitalálták a Arrays.deepEquals()módszert. A hívás így néz ki:

Arrays.deepEquals(name1, name2)

A metódus visszatértrueha a tömbök egyenlő hosszúak és elemeik egyenlőek. Ellenkező esetben visszatérfalse. Ha a tömbön belüli elemek egyben tömbök is, akkor a Arrays.deepEquals()metódus segítségével hasonlítjuk össze őket, és így tovább.

Példák:

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