Tömbök Java-ban: Útmutató

1. Bemutatkozás

Ebben az oktatóanyagban elmélyülünk a Java nyelv - tömbök alapkoncepciójában.

Először meglátjuk, mi a tömb, majd hogyan kell használni őket; Összességében kitérünk a következőkre:

  • Kezdje el a tömbökkel
  • Tömbök elemeinek olvasása és írása
  • Hurok egy tömb fölé
  • Tömbök átalakítása más objektumokká, például Lista vagy Patakok
  • Tömbök rendezése, keresése és kombinálása

2. Mi a tömb?

Először is meg kell határoznunk, hogy mi egy tömb? A Java dokumentációja szerint egy tömb objektum, amely rögzített számú azonos típusú értéket tartalmaz. A tömb elemei indexálva vannak, ami azt jelenti, hogy számokkal (ún indexek).

A tömböt a cellák számozott listájának tekinthetjük, mindegyik cella egy értéket tartalmazó változó. Java-ban a számozás 0-tól kezdődik.

Vannak primitív tömbök és objektumtípusok tömbök. Ez azt jelenti, hogy a int, lebegő, logikai… De tömbök is Karakterlánc, Tárgy és egyedi típusok is.

3. Tömb beállítása

Most, hogy a tömbök jól körülhatárolhatók, merüljünk el azok használatában.

Sok olyan témát fogunk bemutatni, amelyek megtanítanak minket a tömbök használatára. Megtanulunk néhány alapot, például egy tömb deklarálását és inicializálását, de kitérünk olyan fejlettebb témákra is, mint a tömbök rendezése és keresése.

Menjünk először deklarációval és inicializálással.

3.1. Nyilatkozat

Kezdjük a nyilatkozattal. Kétféle módon lehet deklarálni egy tömböt a Java-ban:

int [] anArray;

vagy:

int anOtherArray [];

Az előbbit szélesebb körben használják, mint az utóbbit.

3.2. Inicializálás

Most itt az ideje, hogy lássa, hogyan lehet inicializálni a tömböket. Ismét többféle módon lehet egy tömböt inicializálni. Itt láthatjuk a legfontosabbakat, de ez a cikk részletesen ismerteti a tömbök inicializálását.

Kezdjük egy egyszerű módszerrel:

int [] anArray = új int [10];

Ezzel a módszerrel egy tízes tömböt inicializáltunk int elemek. Ne feledje, hogy meg kell adnunk a tömb méretét.

Ha ezt a módszert használja, minden elemet inicializálunk az alapértelmezett értékére, itt 0. Tömb inicializálásakor Tárgy, az elemek vannak nulla alapértelmezés szerint.

Most egy másik módot fogunk látni, amely lehetőséget ad számunkra a tömb értékeinek közvetlen beállítására a létrehozásakor:

int [] anArray = új int [] {1, 2, 3, 4, 5};

Itt egy öt elemből álló tömböt inicializáltunk, amely 1 és 5 közötti számokat tartalmaz. Ha ezt a módszert alkalmazzuk, akkor nem kell megadnunk a tömb hosszát, ez a zárójelek között deklarált elemek száma.

4. Elemek elérése

Most nézzük meg, hogyan lehet elérni egy tömb elemeit. Ezt úgy érhetjük el, hogy megkövetelünk egy tömb cellapozíciót.

Például ez a kis kódrészlet 10-et nyomtat a konzolra:

anArray [0] = 10; System.out.println (anArray [0]);

Vegye figyelembe, hogyan használjuk az indexeket a tömb cellák eléréséhez. A zárójelek közötti szám a tömb konkrét helyzete, amelyhez hozzáférni akarunk.

Cella elérésekor, ha a továbbított index negatív, vagy meghaladja az utolsó cellát, a Java dob egy ArrayIndexOutOfBoundException.

Akkor óvatosnak kell lennünk ne használjon negatív indexet, vagy a tömb méreténél nagyobb vagy azzal egyenlő indexet.

5. Iterálás egy tömb felett

Az elemek egyesével történő elérése hasznos lehet, de érdemes egy tömbön keresztül iterálni. Lássuk, hogyan érhetjük el ezt.

Az első módszer a mert hurok:

int [] anArray = új int [] {1, 2, 3, 4, 5}; mert (int i = 0; i <anArray.length; i ++) {System.out.println (anArray [i]); }

Ennek 1-től 5-ig kell nyomtatnia a konzolra. Mint láthatjuk, használtuk a hossz ingatlan. Ez egy köztulajdon, amely megadja nekünk a tömb méretét.

Természetesen lehetséges más hurokmechanizmusok, például míg vagy csinálni, miközben. De ami a Java gyűjteményeket illeti, a tömbök között is lehet hurkolni a az egyes hurok:

int [] anArray = új int [] {1, 2, 3, 4, 5}; for (int elem: anArray) {System.out.println (elem); }

Ez a példa egyenértékű az előzővel, de megszabadultunk az indexek kazánlap kódjától. A az egyes A loop akkor választható, ha:

  • nem kell módosítanunk a tömböt (ha egy másik értéket egy elembe teszünk, az nem módosítja a tömb elemét)
  • nincs szükségünk az indexekre, hogy valami mást tegyünk

6. Varargs

A tömbök létrehozásának és manipulálásának alapjairól már volt szó. Most kezdjük a fejlettebb témákat varargs. Emlékeztetőül, varargs tetszőleges számú argumentum átadására szolgálnak egy módszerhez:

void varargsMethod (String ... varargs) {}

Ez a módszer 0-tól tetszőleges számúig tarthat Húr érvek. Cikk borító varargs itt található.

Amit itt tudnunk kell, hogy a módszer testén belül a varargs A paraméter egy tömbré válik. De, egy tömböt is átadhatunk érvként. Lássuk, hogy a fent deklarált példa módszer újrafelhasználásával:

Karakterlánc [] anArray = új húr [] {"Tej", "Paradicsom", "Chips"}; varargsMethod (anArray);

Ugyanúgy fog viselkedni, mint:

varargsMethod ("tej", "paradicsom", "chips");

7. Tömb átalakítása listává

A tömbök nagyszerűek, de néha praktikusabb lehet kezelni Lista helyette. Itt láthatjuk, hogyan lehet átalakítani egy tömböt a Lista.

Először naiv módon fogjuk megtenni, létrehozva egy üres listát, és iterálva a tömbön, hogy hozzáadjuk az elemeket a listához:

int [] anArray = új int [] {1, 2, 3, 4, 5}; List aList = new ArrayList (); for (int elem: anArray) {aList.add (elem); }

De van egy másik mód, egy kicsit tömörebb:

Egész szám [] anArray = új egész szám [] {1, 2, 3, 4, 5}; List aList = Arrays.asList (anArray);

A statikus módszer Tömbök.asList vesz egy varargs argumentumot, és létrehoz egy listát az átadott értékekkel. Sajnos ez a módszer hátrányokkal jár:

  • Nem lehet primitív tömböt használni
  • Nem adhatunk hozzá elemeket vagy távolíthatunk el őket a létrehozott listáról, mivel ez egy elemet dob UnsupportedOperationException

8. Egy tömbből a patakba

Most átalakíthatjuk a tömböket listákká, de a Java 8 óta hozzáférünk a Stream API és érdemes lehet tömbjeinket átalakítani Folyam. A Java biztosítja számunkra a Tömbök.folyam módszer erre:

Karakterlánc [] anArray = új húr [] {"Tej", "Paradicsom", "Chips"}; Stream aStream = Tömbök.stream (anArray);

Amikor elhalad egy Tárgy tömb a metódusra visszaadja a Folyam megfelelő típusú (pl. Folyam tömbjére Egész szám). Egy primitív elhaladásakor visszaadja a megfelelő primitívet Folyam.

Az adatfolyam csak a tömb egy részhalmazán hozható létre:

Stream anotherStream = Tömbök.stream (anArray, 1, 3);

Ez létrehozza a Folyam csak „Paradicsommal” és „Chipszel” Húrok (az első index befogadó, míg a második exkluzív).

9. Tömbök rendezése

Most nézzük meg, hogyan lehet rendezni egy tömböt, amely bizonyos sorrendben átrendezi az elemeit. A Tömbök osztály biztosítja számunkra a fajta módszer. Kicsit olyan, mint a folyam módszer, fajta sok a túlterhelése.

Rendezésre vannak túlterhelések:

  • Primitív tömbök: amelyek növekvő sorrendbe vannak rendezve
  • Tárgy tömbök (azok Tárgy végre kell hajtania a Hasonló interfész): amelyeket a természetes sorrend szerint rendezünk (a összehasonlítani módszer től Hasonló)
  • Általános tömbök: amelyek egy adott szerint vannak rendezve Összehasonlító

Ezen túlmenően a tömbnek csak egy meghatározott részét lehet rendezni (a kezdő és a vég indexek átadása a metódusnak).

Az algoritmusok a fajta módszer gyors rendezés és egyesítés rendezés primitív, illetve más tömbökhöz.

Nézzük meg, hogyan működik ez az egész néhány példán keresztül:

int [] anArray = új int [] {5, 2, 1, 4, 8}; Tömbök.rendezés (anArray); // az anArray most {1, 2, 4, 5, 8} egész szám [] anotherArray = új egész szám [] {5, 2, 1, 4, 8}; Tömbök.rendezés (anotherArray); // a anotherArray most {1, 2, 4, 5, 8} karakterlánc [] yetAnotherArray = új karakterlánc [] {"A", "E", "Z", "B", "C"}; Arrays.sort (yetAnotherArray, 1, 3, Comparator.comparing (String :: toString) .reversed ()); // yetAnotherArray most {"A", "Z", "E", "B", "C"}

10. Keresés egy tömbben

A tömb keresése nagyon egyszerű, áttekinthetjük a tömböt, és megkereshetjük az elemünket a tömb elemek között:

int [] anArray = új int [] {5, 2, 1, 4, 8}; for (int i = 0; i <anArray.length; i ++) {if (anArray [i] == 4) {System.out.println ("Az indexen található" + i); szünet; }}

Itt kerestük a 4. számot, és megtaláltuk a 3. indexen.

Ha mégis van egy rendezett tömbünk, használhatunk egy másik megoldást: a bináris keresést. A bináris keresés elvét ez a cikk ismerteti.

Szerencsére a Java biztosítja nekünk a Arrays.binarySearch módszer. Meg kell adnunk neki egy tömböt és egy elemet a kereséshez.

Általános tömb esetén nekünk is meg kell adnunk a Összehasonlító amelyet elsősorban a tömb rendezésére használtak. Ismét lehetőség nyílik a metódus meghívására a tömb egy részhalmazán.

Lássunk egy példát a bináris keresési módszer használatára:

int [] anArray = új int [] {1, 2, 3, 4, 5}; int index = tömbök. bináris keresés (anArray, 4); System.out.println ("Indexnél található" + index);

Mivel a negyedik cellában tároltuk a 4-es számot, ez eredményezi a 3-as indexet. Vegye figyelembe, hogy egy már rendezett tömböt használtunk.

11. Összekötő tömbök

Végül nézzük meg, hogyan lehet két tömböt összefűzni. Az ötlet egy tömb létrehozása, amelynek hossza a két összefűzendő tömb összege. Utána muszáj add hozzá az első, majd a második elemeit:

int [] anArray = új int [] {5, 2, 1, 4, 8}; int [] anotherArray = új int [] {10, 4, 9, 11, 2}; int [] resultArray = új int [anArray.length + anotherArray.length]; mert (int i = 0; i <resultArray.length; i ++) {resultArray [i] = (i <anArray.length? anArray [i]: anotherArray [i - anArray.length]); }

Mint láthatjuk, amikor az index még mindig kisebb, mint az első tömb hossza, akkor hozzáadunk elemeket abból a tömbből. Ezután elemeket adunk a másodikból. Használhatjuk a Arrays.setAll módszer a ciklus írásának elkerülésére:

int [] anArray = új int [] {5, 2, 1, 4, 8}; int [] anotherArray = új int [] {10, 4, 9, 11, 2}; int [] resultArray = új int [anArray.length + anotherArray.length]; Arrays.setAll (resultArray, i -> (i <anArray.length? AnArray [i]: anotherArray [i - anArray.length]));

Ez a módszer az összes tömb elemet a megadott függvény szerint állítja be. Ez a függvény indexet társít egy eredményhez.

Itt van egy harmadik lehetőség a tömbökbe való egyesítésre: Rendszer.arraycopy. Ez a módszer forrást igényel sor, forrás pozíció, cél sor, rendeltetési hely és egy int a másolandó elemek számának meghatározása:

System.arraycopy (anArray, 0, resultArray, 0, anArray.length); System.arraycopy (anotherArray, 0, resultArray, anArray.length, anotherArray.length);

Mint láthatjuk, lemásoljuk az első tömböt, majd a másodikat (az első utolsó eleme után).

12. Következtetés

Ebben a részletes cikkben a Java tömbök alapvető és néhány speciális használatát ismertettük.

Láttuk, hogy a Java rengeteg módszert kínál a tömbök kezelésére a Tömbök hasznossági osztály. Vannak segédosztályok is a tömbök kezelésére olyan könyvtárakban, mint az Apache Commons vagy a Guava.

A cikk teljes kódja megtalálható a GitHub oldalán.