Tömbök Java nyelven

Képzeljen el szekrényeket egy raktárban. Mindegyiknek megvan a saját száma, és mindegyik tárol valamilyen poggyász tárgyat. Vagy egy borlap, ahol minden bor meg van számozva, és az ital számának megadásával rendel. Vagy azoknak a tanulóknak a listája, amelyekben az "Adams" az első helyen, a "Zimmer" pedig az utolsó helyen szerepel. Vagy egy repülőgép utasainak listája, akik mindegyikéhez egy számozott ülés tartozik. A Java-ban gyakran használnak tömböket az ilyen struktúrákkal, azaz homogén adathalmazokkal való együttműködésre.

Mi az a tömb?

A tömb olyan adatstruktúra, amely azonos típusú elemeket tárol. Számozott cellák halmazaként is felfoghatja. Minden cellába elhelyezhet néhány adatot (cellánként egy adatelemet). Egy adott cella a számával érhető el. A tömbben lévő elem számát indexnek is nevezik . Java nyelven egy tömb homogén, azaz minden cellája azonos típusú elemeket tartalmaz. Így egy egész számok tömbje csak egész számokat ( int ), karakterláncok tömbje csak karakterláncokat tartalmaz, és egy általunk létrehozott Dog osztály példányainak tömbje csak Dog objektumokat tartalmaz. Más szóval, a Java nem engedi, hogy a tömb első cellájába egész számot, a másodikba karakterláncot , a harmadikba pedig egy kutyát helyezzünk.

Tömb deklarálása

Hogyan deklarálunk egy tömböt?

Mint minden változót, a tömböt is Java nyelven kell deklarálni. Ezt kétféleképpen lehet megtenni. Egyenértékűek, de az első mód jobban megfelel a Java stílusnak. A második a C nyelv öröksége: sok C programozó váltott Java-ra, és a kényelmük érdekében megtartottak egy alternatív módszert. A táblázat bemutatja a Java tömbök deklarálásának mindkét módját: Mindkét esetben a dataType a tömbben lévő változók típusa. A példákban két tömböt deklaráltunk. Az egyik int s, a másik pedig az objektum objektumokat fogja tárolni . Így a tömbdeklarációnak van neve és típusa (a tömb elemeinek típusa). A tömbnév a tömb neve.

Tömb létrehozása

Hogyan hozz létre egy tömböt?

Mint minden objektumhoz, itt is létrehozhatunk Java tömböt, azaz helyet foglalhatunk a memóriában az új operátor segítségével. Ez így történik:

new typeOfArray[length]; 

ahol a typeOfArray a tömb típusa, a hossza pedig a hossza (azaz a cellák száma) egész számként kifejezve ( int). De vegye figyelembe, hogy itt csak memóriát foglaltunk le a tömb számára – a deklarált tömböt nem társítottuk semmilyen korábban deklarált változóhoz. Általában egy tömböt először deklarálnak, majd példányosítanak, például:

int[] myArray; // Array declaration
myArray = new int[10]; // Create (allocate memory for) an array of 10 ints

Itt létrehoztunk egy myArray nevű egész számokból álló tömböt , amely tájékoztatja a fordítót, hogy 10 cellából áll (mindegyik egy egész számot tartalmaz). Sokkal gyakoribb azonban a következő rövidített szintaxis használata egy tömb azonnali létrehozásához, amikor deklarálásra kerül:

int[] myArray = new int [10]; // Declare the array and allocate memory "in one blow"

Kérjük, vegye figyelembe:Miután egy tömb az új operátorral létrejött , a cellái alapértelmezett értékeket tartalmaznak. Numerikus típusoknál (mint a példánkban) az alapértelmezett érték 0, a logikai típusnál false , referenciatípusoknál pedig null . Így ennek az utasításnak a végrehajtása után

int[] myArray = new int[10];

kapunk egy tíz egész számból álló tömböt, és amíg a program nem tesz valamit az értékek megváltoztatására, minden cella 0-t tartalmaz.

Tömb hossza Java nyelven

Ahogy fentebb említettük, egy tömb hossza azon elemek száma, amelyek tárolására a tömböt tervezték. Egy tömb hossza létrehozása után nem módosítható. Kérjük, vegye figyelembehogy a tömbelemek számozása nullától kezdődően történik a Java-ban. Így ha van egy 10 elemű tömbünk, akkor az első elem indexe 0, az utolsóé pedig 9. A tömb hosszát a hossz változó segítségével kaphatjuk meg . Például:

int[] myArray = new int[10]; // Create an int array for 10 elements and name it myArray
System.out.println(myArray.length); // Display the array's length, i.e. the number of elements we can put into the array

Kimenet:

10

Tömb inicializálása és elemeinek elérése

Most már tudjuk, hogyan hozhatunk létre tömböt Java nyelven. A folyamat nem egy üres tömböt kap, hanem egy alapértelmezett értékekkel megtöltött tömböt. Például egy int tömbnél ez 0, és ha bármilyen referencia típusú tömbünk van, akkor minden cellában az alapértelmezett null . Egy tömbelemet az indexével érünk el (például az értékének beállításához, a képernyőn való megjelenítéséhez vagy valamilyen művelet végrehajtásához). A tömb inicializálása egy tömb meghatározott értékekkel való feltöltésének folyamata (az alapértelmezetttől eltérő). Példa: hozzunk létre egy karakterlánc-tömböt a 4 évszakhoz, és töltsük ki az évszakok nevével.

String[] seasons = new String[4]; /* Declare and create an array. Java allocates memory for an array of 4 strings, and each cell is set to null (since String is a reference type) */ 

seasons[0] = "Winter"; /* We set the first cell, i.e. the cell with index zero, to "Winter". Here we access the zeroth element of the array and write a specific value to it. */ 
seasons[1] = "Spring"; // We follow a similar procedure for the cell with index 1 (the second cell)
seasons[2] = "Summer"; // ... index 2
seasons[3] = "Autumn"; // and finally, index 3

Most az évszakok neveit a tömbünk négy cellájába írjuk. A tömböt más módon is inicializálhatjuk, kombinálva a deklarációt és az inicializálást:

String[] seasons = new String[] {"Winter", "Spring", "Summer", "Autumn"};

Sőt, az új operátor elhagyható:

String[] seasons = {"Winter", "Spring", "Summer", "Autumn"};

Hogyan jeleníthet meg egy tömböt a képernyőn Java nyelven?

A tömbelemeket a képernyőn (azaz a konzolon) for ciklus segítségével jelenítheti meg . A tömb megjelenítésének egy másik, rövidebb módját a " Tömbökkel végzett munka hasznos módszerei " című bekezdés tárgyalja . Addig is nézze meg ezt a példát, ahol egy tömb hurok segítségével jelenik meg:

String[] seasons = new String {"Winter", "Spring", "Summer", "Autumn"}; 
for (int i = 0; i < 4; i++) {
System.out.println(seasons[i]); 
}

A program a következőket jeleníti meg:

Winter 
Spring 
Summer 
Autumn

Egydimenziós és többdimenziós tömbök Java nyelven

De mi van akkor, ha nem számokból, karakterláncokból vagy más objektumokból álló tömböt akarunk létrehozni, hanem tömbök tömbjét? A Java lehetővé teszi ezt. Az általunk már ismert tömbtípus ( int[] myArray = new int[8] ) egydimenziós tömbként ismert. De a tömbök tömbjét kétdimenziós tömbnek nevezzük. Olyan, mint egy táblázat, amelynek van sorszáma és oszlopszáma. Vagy ha megtanulta a lineáris algebra alapjait, akkor mátrixként is felfoghatja. Miért van szükségünk ilyen tömbökre? Nos, mátrixok és táblázatok, valamint más hasonló szerkezetű objektumok programozására. Például egy sakktábla ábrázolható egy 8x8-as tömbbel. Egy többdimenziós tömb deklarálása és létrehozása a következőképpen történik:

Int[][] myTwoDimentionalArray = new int[8][8];

Ez a tömb pontosan 64 elemből áll: myTwoDimentionalArray[0][0] , myTwoDimentionalArray[0][1] , myTwoDimentionalArray[1][0] , myTwoDimentionalArray[1][1] és így tovább egészen myTwoDimentionalArray[7][7] . Tehát ha egy sakktábla ábrázolására használjuk, akkor az A1 a myTwoDimentionalArray[0][0] -nak, az E2 pedig a myTwoDimentionalArray[4][1] -nek felel meg . De meddig tudjuk ezt tolni? Java-ban megadhat egy tömböt... egy tömbtömböt stb. Természetesen háromdimenziós és magasabb dimenziós tömböket nagyon ritkán használnak. Ennek ellenére használhat egy háromdimenziós tömböt például egy Rubik-kocka programozásához.

Hasznos módszerek a tömbökkel való munkavégzéshez

A Java a java.util.Arrays osztályt használja a tömbökkel való munkavégzéshez. Általánosságban elmondható, hogy a tömbökön végzett leggyakoribb műveletek az inicializálás (elemekkel való kitöltés), az elem lekérése (index alapján), a rendezés és a keresés. A tömbök keresése és rendezése egy másik nap témája. Egyrészt jó gyakorlat, ha több keresési és rendezési algoritmust saját maga ír meg. Másrészt az összes legjobb algoritmust már implementálták és beépítették a szabványos Java-könyvtárakba, és legálisan használhatod őket. Íme három hasznos módszer ebben az osztályban.

Tömb rendezése

A void sort(int[] myArray, int fromIndex, int toIndex) metódus növekvő sorrendbe rendezi az egész tömböt vagy altömböt.

Elem keresése egy tömbben

int binarySearch(int[] myArray, int fromIndex, int toIndex, int kulcs) . Ez a módszer a kulcselemet egy rendezett myArray tömbben vagy altömbben keresi , fromIndextől Indexig . Ha az elem megtalálható, akkor visszaadja az indexét. Ellenkező esetben a (-fromIndex)-1 értéket adja vissza .

Tömb átalakítása stringgé

A String toString(int[] myArray) metódus egy tömböt karaktersorozattá alakít át. Java nyelven a tömbök nem írják felül a toString() függvényt . Ez azt jelenti, hogy ha egy egész tömböt próbál egyszerre megjeleníteni (System.out.println(myArray)), nem pedig egy elemet egyszerre, mint a " Tömb megjelenítése a képernyőn " című bekezdésben, akkor a az osztály neve és a tömb hexadecimális hash-je ( az Object.toString() definíciója ). Ha Ön kezdő, előfordulhat, hogy nem érti a toString metódus magyarázatát. Kezdetben nem kell, de ezzel a módszerrel könnyebben megjeleníthető egy tömb. A Java segítségével egyszerűen megjeleníthet egy tömböt hurok használata nélkül. Az alábbi példa ezt szemlélteti.

Példa a sort, a binarySearch és a toString használatára

Hozzunk létre egy egész számokból álló tömböt, jelenítsük meg a toString segítségével , rendezzük a rendezési módszerrel, majd keressünk benne egy számot.

class Main {
    public static void main(String[] args) {
        int[] array = {1, 5, 4, 3, 7}; // Declare and initialize the array
        System.out.println(array); // Try to display our array without using the toString method — the result is a hexadecimal number
        System.out.println(Arrays.toString(array)); // Display the array correctly 
        Arrays.sort(array, 0, 4); // Sort the entire array from the zeroth to the fourth element
        System.out.println(Arrays.toString(array)); // Display the sorted array
        int key = Arrays.binarySearch(array, 5); // Look for the number 5 in the sorted array. 
        // The binarySearch method will return the index of the array element we are searching for
        System.out.println(key); // Display the index of the number we searched for 
System.out.println(Arrays.binarySearch(array, 0)); // Now try to find a number that isn't in the array, 
        // and immediately display the result

    }
}

Kimenet:

[I@1540e19d 
[1, 5, 4, 3, 7] 
[1, 3, 4, 5, 7] 
3 
-1

Az első karakterlánc egy kísérlet a tömb megjelenítésére a toString használata nélkül . A második a toString segítségével megjelenített tömb . A harmadik a rendezett tömb. A negyedik a keresett szám indexe (5) a rendezett tömbben (ne felejtsük el, hogy nullától számolunk, tehát a tömb negyedik elemének indexe 3). Az ötödik karakterláncban -1-et látunk. Ez egy érvénytelen tömbindex. Azt jelzi, hogy a keresett szám (jelen esetben 0) nincs a tömbben.

Tömbök dióhéjban

• Egy tömb lényeges jellemzői: a benne elhelyezett adatok típusa, neve, hossza.
  Az utolsó tulajdonság a tömb létrehozásakor kerül meghatározásra (amikor memóriát foglalnak le a tömb számára). Az első két tulajdonság a tömb deklarálásakor kerül meghatározásra.

• A tömb méretének (cellák számának) int értéknek kell lennie

• Egy tömb hosszát a létrehozás után nem lehet megváltoztatni.

• Egy tömbelem az indexe alapján érhető el.

• A tömbök elemei, mint minden más Java-ban, nullától kezdődően vannak számozva.

• A tömb létrehozása után az alapértelmezett értékekkel lesz feltöltve.

• A Java tömbök nem ugyanazok, mint a C++ tömbök. Szinte olyanok, mint a dinamikus tömbök mutatói.

Hasznos anyagok a tömbökről

Szeretne többet tudni a tömbökről? Tekintse meg az alábbi cikkeket. Sok érdekes és hasznos anyag található ebben a témában.