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

"Amigo, remélem, mostanra rájöttél, mennyire hasznosak a tömbök a programozásban?"

– Mindenképpen, Rishi! Már több feladatot megoldottam.

"Volt a feladataiban ismétlődő cselekedetek? Olyanok, amelyeket újra és újra megtett."

"Ha jól értettem, akkor a különböző feladatokban végzett hasonló műveletekre gondolsz? Például mindenhol hurkot használva egy tömb tartalmának megjelenítésére – nagyon elegem van már ebből!"

"Igen, erre gondolok. A Java készítői észrevették, hogy a Java programozók gyakran ugyanazt a kódot írják le, amikor tömbökkel dolgoznak. Például olyan kóddal, amely egy tömb egy részét egy másik tömbbe másolja, vagy a tömb minden celláját ugyanazzal tölti ki. Vagy a példa: kód egy tömb tartalmának olvasható formában történő megjelenítéséhez a képernyőn.

"És az igazi programozóknak van egy nagyon fontos szabálya: ne ismételd magad. Egyetértesz azzal, hogy helytelen felesleges munkát végezni – nem kapsz érte fizetést. A hatékony munkát jól fizetik, hidd el. Mellesleg egy újonc kód azonnal felismerhető a nagy mennyiségű ismétlődő kódról.

"A Java készítői elgondolkodtak ezen, és létrehozták a speciális Arraysosztályt (a teljes neve java.util.Arrays), belerakva a legnépszerűbb tömbhöz kapcsolódó műveleteket."

"Hmm... Nagyon érdekes. Szóval mi van benne pontosan?

"Sok 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.

Arrays.toString()

"Az első módszer, amelyet megvizsgálunk, a következő Arrays.toString(). De először egy kis háttér.

"Minden Java tömbnek van egy toString()metódusa, amely "a tömb szöveges megjelenítését" adja vissza. Egy tömb szöveges megjelenítését a következő utasítással kaphatja meg:

String str = name.toString();

"Hol namevan a 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. Amigo, próbáltál már tömböt nyomtatni a képernyőre ezzel a módszerrel ?System.out.println(name)

Bevallom, ez megtörtént. Láttam valami halandzsát. Úgy döntöttem, kerülöm a veszélyt, és továbbra is használom a hurkokat.

"Valószínűleg valami ilyesmit láttál:

I@37afeb11

"Az első betű azt jelenti, hogy egy tömbről Ivan szó , az utána lévő szimbólumok pedig egyetlen objektum címét jelentik a memóriában. Felfoghatjuk úgy, mint a tömb címét a memóriában. Egyrészt pontosan ez az információ, amelyet a tömbváltozó, de másrészt valami másra számított, nem?int@

"Pontosan! Azt terveztem, hogy megnézem az értékeket a tömbben. Ez volt az utolsó dolog, amire számítottam."

"És pontosan ezért találták ki azt a Arrays.toString()módszert – egy tömb értékeinek megjelenítését. Ezt így hívjuk:

String str = Arrays.toString(name);

Példák:

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

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

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

Arrays.deepToString()

"A módszer azonban toString()nem megfelelő, ha kétdimenziós tömbökről van szó. Más szóval, ha megpróbálja meghívni a Arrays.toString(), valami ismerőst fog látni:

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

"Ennek az az oka, hogy a kétdimenziós tömb cellái egydimenziós tömbökre utalnak. És hogyan alakíthatók át az egydimenziós tömbök karakterláncokká? Pontosan úgy, ahogy fentebb látod.

"Mit tegyünk ilyenkor? Hogyan jelenítsünk meg helyesen egy kétdimenziós tömböt?"

"A Java készítői erre is számítottak. Ennek érdekében az Arraysosztálynak van egy másik speciális metódusa is – deepToString(). A hívás így néz ki:

String str = Arrays.deepToString(name);

"Ez a módszer átadható kétdimenziós, egydimenziós, háromdimenziós tömböknek vagy általában bármilyen dimenziónak, és mindig megjeleníti a tömb elemeit.

Példák:

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

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

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

Arrays.equals()

"Kitaláltuk, hogyan jelenítsük meg a tömböket a képernyőn. Mi a helyzet a tömbök összehasonlításával? Emlékszel, milyen módszereket használhatunk a karakterláncok összehasonlítására?"

"Általában ezt a módszert használom equals!

"Igen, equals, és equalsIgnoreCase(amely összehasonlítja a karakterláncokat, tekintet nélkül a nagy- és kisbetűkre).

"Jó hír: a metódus tömbökhöz is használható equals. Rossz hír: 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:

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

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

"Tehát mit tegyünk? Hogyan hasonlítsuk össze a tömböket tartalmuk alapján?"

"Ismét az Arraysosztály jön a segítségünkre. 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 a 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);

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 ( ) helyes összehasonlításához n = 1, 2, 3,... kitalálták a Arrays.deepEquals()módszert. A hívás így néz ki:

Arrays.deepEquals(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 akkor tér visszafalse. 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);

"Köszönöm, Rishi! Ez a lecke pont az, amire szükségem volt, hogy a jövőben könnyebbé és boldogabbá tegyem az életemet. Most az Arrays osztály módszereit fogom használni, és még gyorsabban írom meg a programjaimat.

"Ez az, amire számítottam, ha-ha. De ez nem minden érdekes módszer az Arrays osztályban. Legközelebb másokról fogok mesélni."