Szia ismét! :) A mai órán a Java Arrays osztályáról lesz szó. Az utolsó leckében egy ilyen, tömbnek nevezett adatszerkezetet ismerhettünk meg. Megtanultuk ezek létrehozását és adatokkal való feltöltését. És megnéztük, hogyan tárolódnak a memóriában. Ma megvizsgálunk néhány olyan feladatot és példát a tömbökkel való munkavégzésre, amelyeket gyakran látni fog a valós munkában. Képzeljük el például ezt a helyzetet: Van egy 10 véletlen számból álló tömbünk.
Az a feladatunk, hogy ezt a tömböt növekvő sorrendbe rendezzük: a legkisebbtől a legnagyobbig. Végül így kell kinéznie: [-234, -2, 16, 26, 35, 43, 92, 99, 167] Hogyan csináljuk? Ez a feladat nem triviális. Soha nem csináltunk még ilyet :/ Van ötletetek? Próbáld meg kitalálni. Íme egy megoldás:
Menj végig a tömb összes elemén. Hasonlítsa össze az egyes elemeket a következővel ([0] az [1]-el, [1] a [2]-vel, [2] a [3]-mal stb.). Ha az aktuális elem nagyobb, mint a következő, akkor felcseréljük őket, majd továbblépünk a következő elemre. Ha nem, hagyd őket úgy, ahogy vannak, és lépj tovább
Így az elemeken való első áthaladás után a legnagyobb érték (167) garantáltan az utolsó cellában lesz.
Most újra végigmegyünk az összes elemen, de ezúttal a [0] indexszel kezdjük az utolsó előtti elemig (a legnagyobb szám már a helyén van), és ugyanazokat az összehasonlításokat és cseréket hajtjuk végre. Ezt követően az utolsó előtti cellában lesz a második legnagyobb érték (99).
Ezt a folyamatot annyiszor ismételjük meg, ahány tömbelemünk van.
Megvan az ötlet. Most már csak a kódot kell megírnunk. Ez így néz ki:
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
for (int i = numbers.length - 1; i > 0; i--) {
for (int j = 0; j < i; j++) {
/* Compare the elements in pairs.
If they are not in the right order,
then swap them */
if (numbers[j] > numbers[j + 1]) {
int tmp = numbers[j];
numbers[j] = numbers[j + 1];
numbers[j + 1] = tmp;
}
}
}
}
}
Uh... Kicsit bonyolultnak tűnik -_- Még ha az általános elv érthető is, akkor is elég sok kódot kell írnunk egy ilyen egyszerű feladat megoldásához. Oké, talán csak túlbecsültük magunkat? A feladat, amellyel megbirkóztunk, valószínűleg még mindig túl bonyolult számunkra. Próbáljunk meg valami egyszerűbbet. Vegyük például ugyanazt a számtömböt.
A mi feladatunk, hogy a tartalmát átmásoljuk egy másik tömbbe.
int [] numbersCopy = new int[10];
Gondolja át, hogyan csinálná a tömbökről már ismert ismereteit felhasználva? Például végigmenhet a számtömbön egy ciklusban, és egymás után beírhatja elemeit a numbersCopy- ba :
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
int [] numbersCopy = new int[10];
for (int i = 0; i < numbers.length; i++) {
numbersCopy[i] = numbers[i];
}
}
}
Nos, itt lényegében megcsináltuk! Úgy tűnik, megoldottuk a problémát. Ha azonban ezt gyakran kell megtennie, akkor a kódban egy csomó azonos hurok található. Valójában ezeket (és egyéb) feladatokat már régóta megoldották a Java készítői. Nem kell „újra feltalálnunk a kereket” és kódolnunk a saját megoldásunkat. Létezik egy speciális statikus osztály ( Arrays ), amely segít a tömbökkel végzett munka során a gyakori feladatok elvégzésében. A Java programozók által leggyakrabban előforduló feladatok elvégzésére szolgáló módszereket hozzáadtuk ehhez az osztályhoz. Például egy tömb rendezési feladatát, amit megpróbáltunk kezelni, egyetlen sorban oldjuk meg:
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
Arrays.sort(numbers);
System.out.println(Arrays.toString(numbers));
}
}
Az Arrays.sort() metódus rendezi a tömböt. Az algoritmusa pedig sokkal hatékonyabb, mint az általunk írt kód. Konzol kimenet: [-234, -2, 16, 26, 35, 43, 80, 92, 99, 167] Megjegyzés: A tömb karakterláncsá alakításához az Arrays osztály másik módszerét használtuk : Arrays.toString() . A Java tömbök önmagukban nem írják felül a toString() metódust. Szóval, ha egyszerűen csak írsz
System.out.println(numbers.toString());
az Object osztály toString() függvénye lesz meghívva. Egy tömbnél a kimenet valami ilyesmi lesz: [I@4554617c Most nem részletezzük, hogy miért pont ez a kimenet. A lényeg az, hogy nyilvánvalóan nem erre van szükségünk. De az Arrays.toString() pontosan azt csinálja, amit akarunk. Egyébként a másolás is könnyen elvégezhető az Arrays osztállyal:
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
int [] numbersCopy = Arrays.copyOf(numbers, numbers.length);
System.out.println(Arrays.toString(numbersCopy));
}
}
Az Arrays.copyOf() metódusnak átadjuk az eredeti tömbünket (amelyből értékeket akarunk másolni) és az új tömb hosszát, amelybe adatokat másolunk. Ebben az esetben hosszként a numbers.length-t adtuk meg , mivel a teljes tömböt akarjuk másolni. Ha csak az első néhány elemet szeretnénk másolni, megadhatjuk egy új, kisebb tömb hosszát:
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
int [] numbersCopy = Arrays.copyOf(numbers, 4);
System.out.println(Arrays.toString(numbersCopy));
}
}
Itt 4-et adtunk meg az új tömb hosszának. Ennek megfelelően a számoknak csak az első 4 eleme lesz másolva az új tömbbe. Konzol kimenete: [167, -2, 16, 99] Egyébként az Arrays azt is lehetővé teszi, hogy egy tömb egy részét a tömb közepéről, nem pedig elejéről másoljuk:
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
int [] numbersCopy = Arrays.copyOfRange(numbers, 2,6);
System.out.println(Arrays.toString(numbersCopy));
}
}
Kimenet: [16, 99, 26, 92] A számok az új tömbbe másoltak be a második tömbből a második (beleértve) a hatodik (nem inkluzív) elembe. Lehet, hogy két tömböt is össze kell hasonlítanunk. A toString() metódushoz hasonlóan maguk a tömbök sem írják felül az equals() metódust. Tehát ha így próbáljuk összehasonlítani őket
public class Main {
public static void main(String[] args) {
int[] numbers = {1, 2, 3};
int[] numbers2 = {1, 2, 3};
System.out.println(numbers.equals(numbers2));
}
}
akkor hamisat kapunk. Ennek az az oka, hogy a hivatkozásokat összehasonlító Object.equals() meghívásra kerül. És nyilván különböznek egymástól! De amire szükségünk van, az az, hogy a tömb tartalmát hasonlítsuk össze, nem a hivatkozásokat. Az Arrays osztály felülírja az equals() metódust, hogy pontosan azt csinálja, amit szeretnénk:
public class Main {
public static void main(String[] args) {
int[] numbers = {1, 2, 3};
int[] numbers2 = {1, 2, 3};
System.out.println(Arrays.equals(numbers, numbers2));
}
}
Kimenet: igaz Egyébként az Arrays osztály nem csak közönséges, hanem kétdimenziós tömbökkel is működik:
public class Main {
public static void main(String[] args) {
int[][] numbers = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int[][] numbersCopy = Arrays.copyOf(numbers, numbers.length);
System.out.println("Are these two-dimensional arrays equal?");
System.out.println(Arrays.deepEquals(numbers, numbersCopy));
System.out.println(Arrays.deepToString(numbersCopy));
}
}
Kimenet: Ezek a kétdimenziós tömbök egyenlőek? igaz [[1, 2, 3], [4, 5, 6], [7, 8, 9]] Mint látható, az Arrays.copyOf() metódus képes volt egy kétdimenziós tömb másolására. Az osztálynak pedig speciális módszerei vannak a kétdimenziós tömbök összehasonlítására és megjelenítésére: deepEquals és deepToString() . A jövőben ismételten látni fogja (és ennek örülni fog), hogy a Java készítői sok olyan helyzetet előre láttak, amelyekkel a programozók gyakran szembesülnek, és kész megoldásokat vezettek be ezekre a nyelven. Ezeket a megoldásokat sokkal egyszerűbb és kényelmesebb használni, mint a kereket újra feltalálni, igaz? :) Mindenképpen olvasd el az Arrays osztály dokumentációját az Oracle weboldalán. Sok sikert a tanuláshoz!
GO TO FULL VERSION