Arrays osztály

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.

int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

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.

int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};

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!