V Javě je pole důležitou lineární datovou strukturou, která nám umožňuje ukládat více hodnot stejného typu.

• Pole v Javě jsou objekty jako všechny ostatní objekty v Java polích, které implicitně dědí z třídy java.lang.Object. To vám umožní vyvolat metody definované v Object (jako je toString() equals() a hashCode()).
• Pole mají vestavěnou vlastnost length, která poskytuje počet prvků 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  

Klíčové vlastnosti Arrays

• Store Primitives and Objects: Pole Java mohou obsahovat jak primitivní typy (jako int char boolean atd.), tak objekty (jako String Integer atd.)
• Souvislá alokace paměti Když používáme pole primitivních typů, prvky jsou uloženy na souvislých místech. U neprimitivních typů jsou odkazy na položky uloženy na souvislých místech.
• Indexování založené na nule: První prvek pole je na indexu 0.
• Pevná délka: Po vytvoření pole je jeho velikost pevná; nemůžeme to změnit.

Základy operace na polích v Javě

1. Vyhlášení pole

Obecná forma deklarace pole je 

// Metoda 1:
int arr[];

// Metoda 2:
int[] arr;

Typ prvku určuje datový typ každého prvku, který obsahuje pole. Stejně jako pole celých čísel můžeme také vytvořit pole dalších primitivních datových typů, jako je char float double atd. nebo uživatelsky definované datové typy (objekty třídy).

Poznámka: Je to jen to, jak můžeme vytvořit proměnnou pole, žádné skutečné pole neexistuje. Pouze říká kompilátoru, že tato proměnná (int Array) bude obsahovat pole typu integer.

2. Inicializace pole v Javě

Když je pole deklarováno, vytvoří se pouze odkaz na pole. New používáme k alokaci pole dané velikosti.

int arr[] = new int[velikost];

• Deklarace pole je obecně statická, ale pokud není velikost definována, pole má dynamickou velikost.
• Paměť pro pole je v Javě vždy dynamicky alokována (na segmentu haldy). To se liší od C/C++, kde může být paměť alokována staticky nebo dynamicky.
• Prvky v poli přidělené pomocí new budou automaticky inicializovány na nulu (pro číselné typy), false (pro booleovské) nebo null (pro referenční typy).

Array Literal v Javě

V situaci, kdy velikost pole a proměnné pole jsou již známé, lze použít literály pole. 

// Deklarace literálu pole
int[] arr = new int[]{ 12345678910 };

• Délka tohoto pole určuje délku vytvořeného pole.
• V nejnovějších verzích Javy není potřeba psát novou část int[].

3. Změňte prvek pole

Chcete-li změnit prvek, přiřaďte konkrétnímu indexu novou hodnotu. Index začíná 0 a končí na (celková velikost pole)-1.

// Změna prvního prvku na 90
arr[0] = 90;

4. Délka pole

Délku pole můžeme získat pomocí vlastnosti length:

// Získání délky pole
int n = arr.length;

5. Přístup a aktualizace všech prvků pole

• Ke všem prvkům pole lze přistupovat pomocí Java for Loop.
• Ke každému prvku v poli se přistupuje přes jeho index.

Java program pro ilustraci vytváření pole celých čísel vloží do pole nějaké hodnoty a každou hodnotu vypíše na standardní 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 objektů v Javě

Pole objektů je vytvořeno jako pole datových položek primitivního typu

Příklad : Zde vedeme studentskou třídu a vytváříme pole Student s pěti objekty Student uloženými v poli. Objekty Student musí být vytvořeny pomocí konstruktoru třídy Student a jejich reference by měly být přiřazeny prvkům pole.

   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 }  

Co se stane, když se pokusíme získat přístup k prvkům mimo velikost pole?

JVM vyvolá výjimku ArrayIndexOutOfBoundsException, která označuje, že k poli bylo přistupováno s neplatným indexem. Index je buď záporný, nebo větší nebo roven velikosti pole.

Níže uvedený kód ukazuje, co se stane, když se pokusíme získat přístup k prvkům mimo velikost pole:

   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:

Předávání polí metodám

Stejně jako proměnné můžeme také předávat pole metodám. Například níže uvedený program předá pole metodě sum pro výpočet součtu hodnot pole.

Pří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  

Vysvětlení

• Tento program Java ukazuje, jak předat pole metodě.
• Celočíselné pole arr je deklarováno a inicializováno v hlavní metodě.
• Metoda sum() se volá s argumentem arr.
• Uvnitř metody sum() jsou všechny prvky pole přidány pomocí cyklu for.
• Konečný součet je pak vytištěn na konzoli.

Vrácení polí z metod

Jako obvykle může metoda také vrátit pole. Například níže uvedený program vrací pole z metody m1. 

Pří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

• Efektivní přístup: Přístup k prvku pomocí jeho indexu je rychlý a má konstantní časovou složitost O(1).
• Správa paměti: Pole mají pevnou velikost, díky čemuž je správa paměti přímočará a předvídatelná.
• Organizace dat: Pole pomáhají organizovat data strukturovaným způsobem, což usnadňuje správu souvisejících prvků.

Nevýhody Java Arrays

• Pevná velikost: Jakmile je pole vytvořeno, nelze jeho velikost změnit, což může vést k plýtvání pamětí, pokud je velikost nadhodnocena, nebo nedostatečnému úložišti, pokud je podhodnocena.
• Homogenita typu: Pole mohou ukládat pouze prvky stejného datového typu, což může vyžadovat další zpracování pro smíšené typy dat.
• Vkládání a mazání: Vkládání nebo mazání prvků zejména uprostřed pole může být nákladné, protože může vyžadovat posunutí prvků.

Související příspěvky

• Jagged Array v Javě
• Pro každou smyčku v Javě
• Třída Arrays v Javě