Valamit a tömbökről

Szia! Korábban a képzés során egyedi objektumokkal (és primitív típusokkal) dolgoztunk. De mi van akkor, ha objektumok egész csoportjával kell dolgoznunk egy helyett? Tegyük fel például, hogy szeretnénk létrehozni egy listát a cégünk összes alkalmazottjának születésnapjáról. 30 karakterláncot kell tartalmaznia, a következőképpen formázott: "Sarah Huffman, január 25." Hasznos lesz egy speciális adatstruktúra, az úgynevezett tömb . Ha egy tömböt egy valós objektumhoz hasonlítunk, akkor nagyon hasonlít a széfekkel ellátott banki trezorra: Egy tömb is "dobozokból" áll. Minden dobozba beletehet valamit (elemet). Egy elem eléréséhez ismernie kell a doboz számát (indexét). Így jön létre egy tömb:

public class Main {

   public static void main(String[] args) {

       String [] birthdays = new String[10];
      
   }
}

Itt létrehozunk egy tömböt, amely 10 elemet tartalmaz. Azonnal megjegyezheti a tömb néhány jellemzőjét:

1. Egy jól meghatározott adattípus elemeit tárolja . Ha létrehozunk egy String tömböt, abban mást nem tárolhatunk. Az adattípus a tömb létrehozásakor kerül megadásra . Ez itt különbözik a széftől (amiben a vásárló azt tárolhatja, amit akar).


2. A méretét a tömb létrehozásakor kell megadni . Nem jelezheti később, és nem módosíthatja a méretét a tömb létrehozása után .

Azt, hogy tömböt hozunk létre, a kifejezés mindkét oldalán lévő szögletes zárójelek jelzik. Megadhatók a referenciaváltozó neve előtt vagy után. Mindkét módszer működni fog:

String [] birthdays = new String[10];
String birthdays [] = new String[10];

Ha valamit egy tömbbe akarunk írni, akkor meg kell adni annak a doboznak az indexét, ahová az értéket írjuk. A tömbben lévő dobozok 0-tól kezdődően vannak számozva. A nullától kezdődő számolás nagyon elterjedt programozási gyakorlat. Minél gyorsabban megszokja, annál jobb :) Ez azt jelenti, hogy ha az első mezőbe valamilyen értéket szeretne tenni , tegye ezt:

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Jana Russell, March 12";
   }
}

Mostantól Jana születésnapja az alkalmazotti születésnapok tömbjének első cellájában van tárolva: Hasonló módon adhat hozzá más értékeket is:

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Jana Russell, March 12";
       birthdays[1] = "Landon Chan, May 18";
       birthdays[7] = "Rosie Mills, January 3";
   }
}

Ne feledje, hogy Rosie születésnapját hozzáadtuk a nyolcadik dobozhoz (nem felejtetted el, hogy a 7-es doboz miért a nyolcadik doboz, ugye?) . Láthatja, hogy nem töltöttük ki az összes többi cellát. Nem kell sorrendben értékeket írnunk egy tömbbe. Nincs ilyen követelmény. Természetesen az elemek sorrendbe írásával sokkal könnyebben nyomon követhető, hogy hány doboz van szabad és hány foglalt, és megakadályozza, hogy a tömbben "lyukak" legyenek. Ha valamelyik doboz tartalmát szeretné megszerezni, akkor (akárcsak egy széfnél) tudnia kell a számát. Ez így történik:

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Jana Russell, March 12";
       birthdays[1] = "Landon Chan, May 18";
       birthdays[7] = "Rosie Mills, January 3";

       String rosieBirthday = birthdays[7];
       System.out.println(rosieBirthday);
   }
}

Konzol kimenet: Rosie Mills, január 3. Létrehoztunk egy Stringváltozót, és azt mondtuk a fordítónak: "Keresse meg a 7-es indexű mezőt a születésnapi tömbben, és rendelje hozzá az ott található értéket a rosieBirthdayString " változóhoz . És pontosan ezt tette. Ha tömbökkel dolgozunk, egy speciális tulajdonság segítségével könnyen megtalálhatjuk a hosszukat: long .

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Jana Russell, March 12";
       birthdays[1] = "Landon Chan, May 18";
       birthdays[7] = "Rosie Mills, January 3";

       int birthdaysLength = birthdays.length;
       System.out.println(birthdaysLength);
   }
}

Konzolkimenet: 10 Megjegyzés: A lengthtulajdonság a tömb méretét tárolja, nem a megtelt dobozok számát. Tömbünk csak 3 értéket tárol, de a méretét 10-ben jeleztük, amikor létrehoztuk. És pontosan ezt az értéket lengthadja vissza a mező. Miért jönne ez jól? Nos, tegyük fel, hogy meg szeretné jeleníteni az összes születésnap listáját (annak ellenőrzésére, hogy senkit sem felejtettek el). Ezt egyetlen egyszerű ciklusban teheti meg:

public class Main {

   public static void main(String[] args) {

       String birthdays [] = new String[10];
       birthdays[0] = "Jana Russell, March 12";
       birthdays[1] = "Landon Chan, May 18";
       birthdays[2] = "Jeremiah Leonard, July 12";
       birthdays [3] = "Kenny Russo, September 7";
       birthdays[4] = "Tommie Barnes, November 9";
       birthdays [5] = "Roman Baranov, August 14";
       birthdays [6] = "Chanice Andersen, April 1";
       birthdays[7] = "Rosie Mills, January 3";
       birthdays [8] = "Keenan West, October 19";
       birthdays [9] = "Abraham McArthur, May 3";

       for (int i = 0; i < birthdays.length; i++) {
           System.out.println(birthdays[i]);
       }
   }
}

A ciklusban deklaráljuk a változót i, amely nullára van inicializálva. Minden lépésnél megkapjuk az i indexű elemet a tömbünkből, és megjelenítjük az értékét. A ciklus 10 iterációt fog végrehajtani, és az i értéke 0-ról 9-re nő, és a számok a tömbünk elemeinek indexei! Ennek eredményeként az összes értéket megjelenítjük a születésnapoktól[0] a születésnapokig [9] Valójában van egy másik módja is egy tömb létrehozásának. Létrehozhat például egy ints-tömböt, így:

public class Main {

   public static void main(String[] args) {
       int numbers [] = {7, 12, 8, 4, 33, 79, 1, 16, 2};
   }
}

Ezt a technikát "parancsikon inicializálásnak" nevezik. Nagyon kényelmes, mert egyszerre készítünk egy tömböt és töltünk fel értékekkel. A tömb méretét nem kell kifejezetten megadnunk: parancsikon inicializálással a lengthmező automatikusan beáll.

public class Main {

   public static void main(String[] args) {
       int numbers [] = {7, 12, 8, 4, 33, 79, 1, 16, 2};
       System.out.println(numbers.length);
   }
}

Konzol kimenet: 9 Most egy kicsit a tömbök memóriában való tárolásáról. Tegyük fel, hogy van egy három Catobjektumból álló tömbünk:

public class Cat {

   private String name;

   public Cat(String name) {
       this.name = name;
   }

   public static void main(String[] args) {

       Cat[] cats = new Cat[3];
       cats[0] = new Cat("Thomas");
       cats[1] = new Cat("Behemoth");
       cats[2] = new Cat("Lionel Messi");
   }
}

Itt meg kell értened néhány dolgot:

1. Primitívek esetén egy tömb meghatározott értékek halmazát tárolja (pl. ints). Objektumok esetén egy tömb hivatkozások halmazát tárolja .
   A catstömb három elemből áll, amelyek mindegyike egy objektumra való hivatkozásCat . Mindegyik hivatkozás arra a memóriacímre mutat, ahol a megfelelő objektum tárolva van.

2. A tömbelemek egyetlen blokkba vannak elrendezve a memóriában. Ez azért történik, hogy gyorsan és hatékonyan lehessen hozzájuk férni.

Így catsarra a memóriablokkra hivatkozik, ahol az összes objektum (tömbelem) tárolva van. Cats[0]egy adott címre hivatkozik ebben a blokkban. Fontos megérteni, hogy egy tömb nem csak objektumokat tárol, hanem maga is egy objektum. Ez felvet minket a kérdés, hogy nem csak karakterláncokból vagy számokból álló tömböt hozhatunk létre, hanem tömbtömböket is . És a válasz: igen, megtehetjük! Egy tömb bármilyen objektumot tárolhat, beleértve a többi tömböt is. Az ilyen tömböt kétdimenziósnak nevezzük . Ha vizuálisan ábrázolnánk, nagyon hasonlítana egy közönséges asztalhoz. Tegyük fel, hogy szeretnénk létrehozni egy 3 tömbbőlint álló tömböt, amelyek mindegyike 10 másodpercet tud tárolni . Így nézne ki: Minden sor egy tömböt jelöl int. Az első tömb 1 és 10 közötti számokat tartalmaz, a második tömb -1 és -10 között, a harmadik pedig véletlen számok halmaza. Ezen tömbök mindegyikét a kétdimenziós tömbünk dobozaiban tároljuk. A kódban a kétdimenziós tömb inicializálása így néz ki:

public static void main(String[] args) {
   Cat[][] cats = new Cat[3][5];
}

Kétdimenziós tömbmacskáink 3 tömböt tárolnak, mindegyik tömbben 5 dobozzal. Ha egy objektumot szeretnénk a második tömb harmadik mezőjébe tenni, akkor ezt tegyük:

public static void main(String[] args) {
   Cat[][] cats = new Cat[3][5];
   cats[1][2] = new Cat("Fluffy");
}

[1]jelzi a második tömböt, és [2]jelzi ennek a tömbnek a harmadik dobozát. Mivel egy kétdimenziós tömb több tömbből áll, az iterációhoz és az összes érték megjelenítéséhez (vagy az összes elem feltöltéséhez) szükségünk van egy beágyazott ciklusra:

for (int i = 0; i < cats.length; i++) {
   for (int j = 0; j < cats[i].length; j++) {
       System.out.println(cats[i][j]);
   }
}

A külső ciklusban (változó i) a kétdimenziós tömb összes tömbjét iteráljuk. A belső ciklusban (változó j) minden tömb összes elemén áthaladunk. Ennek eredményeként a cats[0][0] (első tömb, első elem) jelenik meg először, majd a cats[0][1] (első tömb, második elem). Miután végigmentünk az első tömbön, megjelenítjük a macskákat[1][0] , macskákat[1][1] , macskákat[1][2] stb. Egyébként a kétdimenziós tömbök is támogatják gyorsírás inicializálás:

int[][] numbers = {{1,2,3}, {4,5,6}, {7,8,9}};

numbersNormális esetben a kétdimenziós tömböt deklaráljuk int[3][3], de ez a rövidítés lehetővé teszi, hogy azonnal megadjuk az értékeket. Miért van szükség kétdimenziós tömbre? Nos, használhatja az egyiket a híres "Battleship" játék egyszerű újraalkotásához: A "Battleship" játékban a játéktér szerkezete könnyen leírható: egy 10 tömbből álló kétdimenziós tömb, egyenként 10 elemmel. Ebből a tömbből kettőt hozol létre (egyet neked és egyet az ellenfelednek)

int[][] battleshipBoard1 = new int[10][10];
int[][] battleshipBoard2 = new int[10][10];

használjon bizonyos értékeket (pl. számokat vagy szimbólumokat) a hajók helyének megfelelő elemek kitöltéséhez, majd felváltva hívja ki az egyes elemek koordinátáit:

• csatahajóBoard1[0][2]!
• Hiányzik! csatahajóBoard2[2][4]!
• Találat!
• csatahajóBoard2[2][5]!
• Találat!
• csatahajóBoard2[2][6]!,
• Elsüllyedt!

Ezzel befejeztük a tömbök első bemutatását, de ez csak a kezdete a velük való interakciónak. A következő leckékben érdekes felhasználási módokat fogunk látni, és azt is megtudjuk, milyen beépített funkciókkal rendelkezik a Java, hogy kényelmesebben dolgozhassunk ezzel az adatstruktúrával :)