V Jave je pole dôležitou lineárnou dátovou štruktúrou, ktorá nám umožňuje ukladať viacero hodnôt rovnakého typu.

• Polia v jazyku Java sú objekty ako všetky ostatné objekty v poliach Java implicitne dedia z triedy java.lang.Object. To vám umožňuje vyvolať metódy definované v Object (napríklad toString() equals() a hashCode()).
• Polia majú vstavanú vlastnosť dĺžky, ktorá poskytuje počet prvkov v poli

   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  

Kľúčové vlastnosti polí

• Skladujte primitíva a predmety: Polia Java môžu obsahovať primitívne typy (ako int char boolean atď.) a objekty (ako String Integer atď.)
• Súvislá alokácia pamäte Keď používame polia primitívnych typov, prvky sú uložené na súvislých miestach. Pre neprimitívne typy sú odkazy na položky uložené na súvislých miestach.
• Indexovanie založené na nule: Prvý prvok poľa je na indexe 0.
• Pevná dĺžka: Po vytvorení poľa je jeho veľkosť pevná; nemôžeme to zmeniť.

Základy operácie na poliach v Jave

1. Vyhlásenie poľa

Všeobecná forma deklarácie poľa je 

// Metóda 1:
int arr[];

// Metóda 2:
int[] arr;

Typ prvku určuje typ údajov každého prvku, ktorý obsahuje pole. Podobne ako pole celých čísel môžeme vytvoriť aj pole iných primitívnych dátových typov ako char float double atď. alebo užívateľom definované dátové typy (objekty triedy).

Poznámka: Je to len to, ako môžeme vytvoriť premennú poľa, žiadne skutočné pole neexistuje. Prekladač iba informuje, že táto premenná (int Array) bude obsahovať pole typu celé číslo.

2. Inicializácia poľa v jazyku Java

Keď je pole deklarované, vytvorí sa iba odkaz na pole. New používame na pridelenie poľa danej veľkosti.

int arr[] = new int[veľkosť];

• Deklarácia poľa je vo všeobecnosti statická, ale ak nie je definovaná veľkosť, pole má dynamickú veľkosť.
• Pamäť pre polia je v jazyku Java vždy dynamicky alokovaná (na segmente haldy). Toto sa líši od C/C++, kde môže byť pamäť alokovaná staticky alebo dynamicky.
• Prvky v poli pridelené new budú automaticky inicializované na nulu (pre číselné typy), false (pre boolean) alebo null (pre referenčné typy).

Array Literal v jazyku Java

V situácii, keď veľkosť poľa a premenné poľa sú už známe, možno použiť literály poľa. 

// Deklarovanie literálu poľa
int[] arr = new int[]{ 12345678910 };

• Dĺžka tohto poľa určuje dĺžku vytvoreného poľa.
• Nie je potrebné písať novú časť int[] v najnovších verziách Java.

3. Zmeňte prvok poľa

Ak chcete zmeniť prvok, priraďte ku konkrétnemu indexu novú hodnotu. Index začína 0 a končí na (celková veľkosť poľa) -1.

// Zmena prvého prvku na 90
arr[0] = 90;

4. Dĺžka poľa

Dĺžku poľa môžeme získať pomocou vlastnosti length:

// Získanie dĺžky poľa
int n = arr.length;

5. Prístup a aktualizácia všetkých prvkov poľa

• Všetky prvky poľa sú prístupné pomocou Java for Loop.
• Ku každému prvku v poli sa pristupuje cez jeho index.

Program Java na ilustráciu vytvárania poľa celých čísel vloží do poľa nejaké hodnoty a každú hodnotu vytlačí na štandardný výstup

   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  

Pole objektov v Jave

Pole objektov je vytvorené ako pole údajových položiek primitívneho typu

Príklad : Tu vedieme študentskú triedu a vytvárame pole Študent s piatimi študentskými objektmi uloženými v poli. Objekty Student musia byť vytvorené pomocou konštruktora triedy Student a ich referencie by mali byť priradené k prvkom poľa.

   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 }  

Čo sa stane, ak sa pokúsime získať prístup k prvkom mimo veľkosti poľa?

JVM vyvolá výnimku ArrayIndexOutOfBoundsException, aby naznačil, že k poľu sa pristupovalo s nelegálnym indexom. Index je buď záporný, alebo väčší alebo rovný veľkosti poľa.

Nižšie uvedený kód ukazuje, čo sa stane, ak sa pokúsime získať prístup k prvkom mimo veľkosti poľa:

   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  ]  );      }   }   

výstup:

Odovzdávanie polí metódam

Podobne ako premenné môžeme aj polia odovzdávať metódam. Napríklad nižšie uvedený program odovzdá pole metóde sum na výpočet súčtu hodnôt poľa.

Príklad:

   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  

Vysvetlenie

• Tento program Java ukazuje, ako odovzdať pole metóde.
• V hlavnej metóde je deklarované a inicializované celočíselné pole arr.
• Metóda sum() sa volá s argumentom arr.
• Vo vnútri metódy sum() sú všetky prvky poľa pridané pomocou cyklu for.
• Konečná suma sa potom vytlačí na konzolu.

Vrátenie polí z metód

Ako obvykle, metóda môže vrátiť aj pole. Napríklad nižšie uvedený program vráti pole z metódy m1. 

Príklad:

   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  

Výhody Java Arrays

• Efektívny prístup: Prístup k prvku pomocou jeho indexu je rýchly a má konštantnú časovú zložitosť O(1).
• Správa pamäte: Polia majú pevnú veľkosť, vďaka čomu je správa pamäte jednoduchá a predvídateľná.
• Organizácia údajov: Polia pomáhajú organizovať údaje štruktúrovaným spôsobom, čo uľahčuje správu súvisiacich prvkov.

Nevýhody Java Arrays

• Pevná veľkosť: Po vytvorení poľa už nie je možné zmeniť jeho veľkosť, čo môže viesť k strate pamäte, ak je veľkosť nadhodnotená, alebo nedostatočnému úložisku, ak je podhodnotená.
• Homogenita typu: Polia môžu ukladať iba prvky rovnakého typu údajov, čo môže vyžadovať ďalšie spracovanie pre zmiešané typy údajov.
• Vkladanie a mazanie: Vkladanie alebo odstraňovanie prvkov, najmä v strede poľa, môže byť nákladné, pretože môže vyžadovať posunutie prvkov.

Súvisiace príspevky

• Jagged Array v jazyku Java
• Pre každú slučku v jazyku Java
• Trieda polí v jazyku Java