A Java-ban egy tömb egy fontos lineáris adatstruktúra, amely lehetővé teszi több azonos típusú érték tárolását.

• A Java tömbök olyan objektumok, mint a Java tömbök összes többi objektuma, amelyek implicit módon a java.lang.Object osztályból öröklődnek. Ez lehetővé teszi az Objectben definiált metódusok meghívását (például toString() equals() és hashCode()).
• A tömbök beépített hossz tulajdonsággal rendelkeznek, amely megadja a tömb elemeinek számát

   public     class   Geeks     {      public     static     void     main  (  String  []     args  )      {      // initializing array      int  []     arr     =     {  40       55       63       17       22  };      // size of array      int     n     =     arr  .  length  ;      // traversing array      for     (  int     i     =     0  ;     i      <     n  ;     i  ++  )      System  .  out  .  print  (  arr  [  i  ]     +     ' '  );      }   }   

40 55 63 17 22  

Az Arrays főbb jellemzői

• Primitívek és objektumok tárolása: A Java tömbök primitív típusokat (például int char boolean stb.) és objektumokat (például String Integer stb.) egyaránt tartalmazhatnak.
• Szomszédos memóriafoglalás Ha primitív típusú tömböket használunk, akkor az elemek összefüggő helyeken tárolódnak. A nem primitív típusok esetében az elemek hivatkozásait összefüggő helyeken tárolják.
• Nulla alapú indexelés: A tömb első eleme a 0 indexen található.
• Fix hossz: Egy tömb létrehozása után a mérete rögzített; nem tudjuk megváltoztatni.

A Java tömbök működésének alapjai

1. Tömb deklarálása

A tömbdeklaráció általános formája a 

1. módszer:
int arr[];

2. módszer:
int[] arr;

Az elem típusa határozza meg a tömböt alkotó minden egyes elem adattípusát. Az egész számok tömbjéhez hasonlóan más primitív adattípusok tömbjét is létrehozhatjuk, például char float double stb. vagy felhasználó által definiált adattípusokat (egy osztály objektumai).

Jegyzet: Csak úgy tudunk létrehozni egy tömbváltozót, hogy nem létezik tényleges tömb. Csak azt mondja a fordítónak, hogy ez a változó (int Array) egy egész típusú tömböt tartalmaz.

2. Tömb inicializálása Java nyelven

Egy tömb deklarálásakor csak egy tömb hivatkozása jön létre. Adott méretű tömb kiosztásához a new-t használjuk.

int arr[] = új int[méret];

• A tömb deklarációja általában statikus, de ha a méret nincs megadva, a tömb Dinamikus méretű.
• A tömbök memóriája mindig dinamikusan van lefoglalva (halomszegmensen) a Java nyelvben. Ez eltér a C/C++-tól, ahol a memória vagy statikusan, vagy dinamikusan lefoglalható.
• A tömb új által lefoglalt elemei automatikusan nullára (numerikus típusok esetén), false (logikai érték esetén) vagy nullára (hivatkozási típusok esetén) inicializálódnak.

Array Literal Java nyelven

Olyan helyzetben, amikor a tömb mérete és a tömb változói már ismertek, tömbliterálok használhatók. 

// Tömb literális deklarálása
int[] arr = új int[]{ 12345678910 };

• Ennek a tömbnek a hossza határozza meg a létrehozott tömb hosszát.
• A Java legújabb verzióiban nem kell megírni az új int[] részt.

3. Változtasson meg egy tömbelemet

Egy elem megváltoztatásához rendeljen új értéket egy adott indexhez. Az index 0-val kezdődik és (teljes tömbméret)-1-re végződik.

// Az első elem módosítása 90-re
arr[0] = 90;

4. Tömb hossza

Egy tömb hosszát a length tulajdonság segítségével kaphatjuk meg:

// A tömb hosszának lekérése
int n = arr.length;

5. Az összes tömbelem elérése és frissítése

• A tömb összes eleme elérhető a Java for Loop segítségével.
• A tömb minden eleme az indexén keresztül érhető el.

A Java program egész számokból álló tömb létrehozását szemlélteti, néhány értéket a tömbbe helyez, és minden értéket kiír a szabványos kimenetre

   class   Geeks     {      public     static     void     main  (  String  []     args  )      {      // declares an Array of integers.      int  []     arr  ;      // allocating memory for 5 integers.      arr     =     new     int  [  5  ]  ;      // initialize the elements of the array      // first to last(fifth) element      arr  [  0  ]     =     2  ;      arr  [  1  ]     =     4  ;      arr  [  2  ]     =     8  ;      arr  [  3  ]     =     12  ;      arr  [  4  ]     =     16  ;      // accessing the elements of the specified array      for     (  int     i     =     0  ;     i      <     arr  .  length  ;     i  ++  )      System  .  out  .  println  (  'Element at index '     +      i     +     ' : '     +     arr  [  i  ]  );      }   }   

Element at index 0 : 2 Element at index 1 : 4 Element at index 2 : 8 Element at index 3 : 12 Element at index 4 : 16  

Objektumtömbök Java nyelven

Az objektumok tömbje primitív típusú adatelemek tömbjeként jön létre

Példa : Itt veszünk egy tanulói osztályt, és létrehozunk egy tanulói tömböt, amelyben öt tanuló objektum van tárolva a tömbben. A Student objektumokat a Student osztály konstruktorával kell példányosítani, és a hivatkozásokat hozzá kell rendelni a tömbelemekhez.

   class   Student     {      public     int     roll_no  ;      public     String     name  ;          Student  (  int     roll_no       String     name  ){      this  .  roll_no     =     roll_no  ;      this  .  name     =     name  ;      }   }   public     class   Geeks     {      public     static     void     main  (  String  []     args  ){          // declares an Array of Student      Student  []     arr  ;      // allocating memory for 5 objects of type Student.      arr     =     new     Student  [  5  ]  ;      // initialize the elements of the array      arr  [  0  ]     =     new     Student  (  1       'aman'  );      arr  [  1  ]     =     new     Student  (  2       'vaibhav'  );      arr  [  2  ]     =     new     Student  (  3       'shikar'  );      arr  [  3  ]     =     new     Student  (  4       'dharmesh'  );      arr  [  4  ]     =     new     Student  (  5       'mohit'  );      // accessing the elements of the specified array      for     (  int     i     =     0  ;     i      <     arr  .  length  ;     i  ++  )      System  .  out  .  println  (  'Element at '     +     i     +     ' : { '      +     arr  [  i  ]  .  roll_no     +     ' '      +     arr  [  i  ]  .  name  +  ' }'  );      }   }   

Element at 0 : { 1 aman } Element at 1 : { 2 vaibhav } Element at 2 : { 3 shikar } Element at 3 : { 4 dharmesh } Element at 4 : { 5 mohit }  

Mi történik, ha a tömbméreten kívüli elemekhez próbálunk hozzáférni?

A JVM az ArrayIndexOutOfBoundsException kivételével jelzi, hogy a tömbhöz illegális indexszel fértek hozzá. Az index vagy negatív, vagy nagyobb, vagy egyenlő egy tömb méretével.

Az alábbi kód megmutatja, mi történik, ha a tömbméreten kívüli elemekhez próbálunk hozzáférni:

   public     class   Geeks     {      public     static     void     main  (  String  []     args  )      {      int  []     arr     =     new     int  [  4  ]  ;      arr  [  0  ]     =     10  ;      arr  [  1  ]     =     20  ;      arr  [  2  ]     =     30  ;      arr  [  3  ]     =     40  ;      System  .  out  .  println  (      'Trying to access element outside the size of array'  );      System  .  out  .  println  (  arr  [  5  ]  );      }   }   

Kimenet:

Tömbök átadása a módszereknek

A változókhoz hasonlóan tömböket is átadhatunk a metódusoknak. Például az alábbi program átadja a tömböt a sum metódusnak, hogy kiszámítsa a tömb értékeinek összegét.

Példa:

   public     class   Geeks     {      // Driver method      public     static     void     main  (  String     args  []  )      {      int     arr  []     =     {     3       1       2       5       4     };      // passing array to method m1      sum  (  arr  );      }      public     static     void     sum  (  int  []     arr  )      {      // getting sum of array values      int     sum     =     0  ;      for     (  int     i     =     0  ;     i      <     arr  .  length  ;     i  ++  )      sum     +=     arr  [  i  ]  ;      System  .  out  .  println  (  'sum of array values : '     +     sum  );      }   }   

sum of array values : 15  

Magyarázat

• Ez a Java program bemutatja, hogyan lehet tömböt átadni egy metódusnak.
• Az arr egész szám tömböt deklarálják és inicializálják a fő metódusban.
• A sum() metódus meghívása arr argumentum mellett történik.
• A sum() metóduson belül az összes tömbelemet egy for ciklus segítségével adjuk hozzá.
• A végső összeget ezután kinyomtatja a konzolra.

Tömbök visszaadása a metódusokból

Szokás szerint a metódusok visszaadhatnak egy tömböt is. Például az alábbi program egy tömböt ad vissza az m1 metódusból. 

Példa:

   class   Geeks     {      // Driver method      public     static     void     main  (  String     args  []  )      {      int     arr  []     =     m1  ();      for     (  int     i     =     0  ;     i      <     arr  .  length  ;     i  ++  )      System  .  out  .  print  (  arr  [  i  ]     +     ' '  );      }      public     static     int  []     m1  ()      {      // returning array      return     new     int  []     {     1       2       3     };      }   }   

1 2 3  

A Java tömbök előnyei

• Hatékony hozzáférés: Egy elemhez való hozzáférés az index alapján gyors és állandó időbonyolultságú O(1).
• Memóriakezelés: A tömbök rögzített méretűek, ami egyszerűvé és kiszámíthatóvá teszi a memóriakezelést.
• Adatszervezés: A tömbök segítenek az adatok strukturált rendezésében, megkönnyítve a kapcsolódó elemek kezelését.

A Java tömbök hátrányai

• Fix méret: Egy tömb létrehozása után a mérete nem módosítható, ami memóriapazarláshoz vezethet, ha a méretet túlbecsülik, vagy nem elegendő tárhelyet, ha alulbecsülik.
• Típus homogenitás: A tömbök csak azonos adattípusú elemeket tárolhatnak, ami további kezelést igényelhet vegyes típusú adatok esetén.
• Beillesztés és törlés: Az elemek beszúrása vagy törlése különösen egy tömb közepén költséges lehet, mivel az elemek eltolását igényelheti.

Kapcsolódó bejegyzések

• Jagged Array Java nyelven
• For-each Java-ban
• Arrays osztály Java nyelven