V Javě, Array je skupina proměnných podobného typu, na které se odkazuje společným názvem. Pole v Javě fungují jinak než v C/C++. Následuje několik důležitých bodů o polích Java.

Pole v Javě

• V Javě jsou všechna pole dynamicky alokována. (diskutované níže)
• Pole mohou být uložena v souvislé paměti [po sobě jdoucí místa v paměti].
• Protože pole jsou v Javě objekty, můžeme jejich délku zjistit pomocí vlastnosti object délka . To se liší od C/C++, kde délku zjišťujeme pomocí sizeof.
• Proměnnou pole Java lze také deklarovat jako jiné proměnné s [] za datovým typem.
• Proměnné v poli jsou seřazeny a každá má index začínající 0.
• Pole Java lze také použít jako statické pole, lokální proměnnou nebo parametr metody.

Pole může obsahovat primitiva (int, char atd.) a objektové (nebo neprimitivní) odkazy třídy v závislosti na definici pole. V případě primitivních datových typů mohou být skutečné hodnoty uloženy v souvislých paměťových místech (JVM toto chování nezaručuje). V případě objektů třídy, skutečné objekty jsou uloženy v segmentu haldy .

if příkaz java

Poznámka: Toto úložiště polí nám pomáhá náhodně přistupovat k prvkům pole [Support Random Access].

Vytváření, inicializace a přístup k polím

Jednorozměrná pole

Obecná forma deklarace jednorozměrného pole je

-- type var-name[]; -- type[] var-name;>

Deklarace pole má dvě složky: typ a název. typ deklaruje typ prvku pole. 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živatelem definované datové typy (objekty třídy). Typ prvku pro pole tedy určuje, jaký typ dat pole bude obsahovat.

Příklad:

// both are valid declarations int intArray[]; int[] intArray; // similar to int we can declare // byte , short, boolean, long, float // double, char // an array of references to objects of // the class MyClass (a class created by user) MyClass myClassArray[]; // array of Object Object[] ao, // array of Collection // of unknown type Collection[] ca;>

Ačkoli první deklarace stanoví, že int Array je proměnná pole, žádné skutečné pole neexistuje . Pouze říká kompilátoru, že tato proměnná (int Array) bude obsahovat pole typu integer. Chcete-li propojit int Array se skutečným fyzickým polem celých čísel, musíte jedno alokovat pomocí Nový a přiřadit jej k int Array.

Instantování pole v Javě

Když je pole deklarováno, vytvoří se pouze odkaz na pole. Chcete-li vytvořit nebo dát paměť do pole, vytvořte pole takto: Obecná forma Nový jak to platí pro jednorozměrná pole, vypadá následovně:

var-name = new type [size];>

Tady, typ určuje typ přidělovaných dat, velikost určuje počet prvků v poli a var-name je název proměnné pole, která je propojena s polem. Použít Nový alokovat pole, musíte zadat typ a počet prvků, které chcete přidělit.

Příklad:

//declaring array int intArray[]; // allocating memory to array intArray = new int[20]; // combining both statements in one int[] intArray = new int[20];>

Poznámka: Prvky v poli přidělené pomocí Nový se automaticky inicializuje na nula (pro číselné typy), Nepravdivé (pro boolean), popř nula (pro referenční typy). Odkazujte se výchozí hodnoty pole v Javě .

Získání pole je dvoufázový proces. Nejprve musíte deklarovat proměnnou požadovaného typu pole. Za druhé, musíte alokovat paměť pro uložení pole pomocí new a přiřadit ji k proměnné pole. Tím pádem, v Javě , všechna pole jsou dynamicky alokována.

Array Literal v Javě

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

// Declaring array literal int[] intArray = new int[]{ 1,2,3,4,5,6,7,8,9,10 };>

• 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[].

Přístup k prvkům Java Array pomocí for Loop

Ke každému prvku v poli se přistupuje přes jeho index. Index začíná 0 a končí na (celková velikost pole)-1. Ke všem prvkům pole lze přistupovat pomocí Java for Loop.

 // accessing the elements of the specified array for (int i = 0; i>

Implementace:

// Java program to illustrate creating an array // of integers, puts some values in the array, // and prints each value to standard output. class GFG { public static void main(String[] args) { // declares an Array of integers. int[] arr; // allocating memory for 5 integers. arr = new int[5]; // initialize the first elements of the array arr[0] = 10; // initialize the second elements of the array arr[1] = 20; // so on... arr[2] = 30; arr[3] = 40; arr[4] = 50; // 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 : 10 Element at index 1 : 20 Element at index 2 : 30 Element at index 3 : 40 Element at index 4 : 50>

Složitost výše uvedené metody:

Časová složitost: O(n)
Pomocný prostor: O(1)

Můžete také přistupovat k java polím pomocí pro každou smyčku .

datové struktury v Javě

Pole objektů v Javě

Pole objektů se vytvoří jako pole datových položek primitivního typu následujícím způsobem.

Student[] arr = new Student[5]; //student is a user-defined class>

Syntax:

-- data type[] arrName; -- datatype arrName[]; -- datatype [] arrName;>

Příklad polí objektů

Příklad 1:

Níže je implementace výše uvedeného tématu:

import java.io.*; class GFG { public static void main (String[] args) { int [] arr=new int [4]; // 4 is the size of arr System.out.println('Array Size:'+arr.length); } }>

Array Size:4>

Student Array obsahuje pět paměťových prostorů, každý o velikosti třídy studenta, do kterého lze uložit adresu pěti objektů Student. 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 následujícím způsobem.

Příklad 2:

Níže je implementace výše uvedeného tématu:

// Java program to illustrate creating // an array of objects class Student { public int roll_no; public String name; Student(int roll_no, String name) { this.roll_no = roll_no; this.name = name; } } // Elements of the array are objects of a class Student. public class GFG { public static void main(String[] args) { // declares an Array of Students Student[] arr; // allocating memory for 5 objects of type Student. arr = new Student[5]; // initialize the first elements of the array arr[0] = new Student(1, 'aman'); // initialize the second elements of the array arr[1] = new Student(2, 'vaibhav'); // so on... 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>

Složitost výše uvedené metody:

Časová složitost: O(n)
Pomocný prostor: O(1)

Příklad 3

Vytvoří se také pole objektů jako:

// Java program to illustrate creating // an array of objects class Student { public String name; Student(String name) { this.name = name; } @Override public String toString(){ return name; } } // Elements of the array are objects of a class Student. public class GFG { public static void main (String[] args) { // declares an Array and initializing the elements of the array Student[] myStudents = new Student[]{new Student('Dharma'),new Student('sanvi'),new Student('Rupa'),new Student('Ajay')}; // accessing the elements of the specified array for(Student m:myStudents){ System.out.println(m); } } }>

Dharma sanvi Rupa Ajay>

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

JVM hází Výjimka ArrayIndexOutOfBounds označující, ž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:

// Code for showing error 'ArrayIndexOutOfBoundsException' public class GFG { 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

Trying to access element outside the size of array Exception in thread 'main' java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 4 at GFG.main(GFG.java:13)>

Příklad (Iterace pole):

public class GFG { public static void main(String[] args) { int[] arr = new int[2]; arr[0] = 10; arr[1] = 20; for (int i = 0; i < arr.length; i++) System.out.println(arr[i]); } }>

10 20>

Složitost výše uvedené metody:

Časová složitost: O(n), zde n je velikost pole.
Pomocný prostor: O(1) , protože není potřeba žádné další místo.

Vícerozměrná pole v Javě

Vícerozměrná pole jsou pole polí přičemž každý prvek pole drží odkaz na jiná pole. Tyto jsou také známé jako Zubaté pole . Vícerozměrné pole se vytvoří připojením jedné sady hranatých závorek ([]) na dimenzi.

Syntaxe Java Multidimensional Array

Existují 2 způsoby, jak deklarovat Java Multidimenzionální pole, jak je uvedeno níže:

-- datatype [][] arrayrefvariable; -- datatype arrayrefvariable[][];>

Příklad:

statický v c

// Java Program to demonstrate // Java Multidimensional Array import java.io.*; // Driver class class GFG { public static void main(String[] args) { // Syntax int[][] arr = new int[3][3]; // 3 row and 3 column // Number of Rows System.out.println('Number of Rows:'+ arr.length); // Number of Columns System.out.println('Number of Columns:'+ arr[0].length); } }>

Number of Rows:3 Number of Columns:3>

Deklarace vícerozměrného pole

int[][] intArray = new int[10][20]; //a 2D array or matrix int[][][] intArray = new int[10][20][10]; //a 3D array>

Příklad Muilti Dimensional Array v Javě

Příklad 1:

Níže je uvedena implementace výše uvedené metody:

// Java Program to Multidimensional Array // Driver Class public class multiDimensional { // main function public static void main(String args[]) { // declaring and initializing 2D array int arr[][] = { { 2, 7, 9 }, { 3, 6, 1 }, { 7, 4, 2 } }; // printing 2D array for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) System.out.print(arr[i][j] + ' '); System.out.println(); } } }>

2 7 9 3 6 1 7 4 2>

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ě součet pro výpočet součtu hodnot pole.

// Java program to demonstrate // passing of array to method public class Test { // 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>

Složitost výše uvedené metody:

Časová náročnost: Na)
Pomocný prostor: O(1)

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 .

// Java program to demonstrate // return of array from method class Test { // 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>

Složitost výše uvedené metody:

Časová složitost: O(n)
Pomocný prostor: O(1)

Objekty třídy pro pole

Každé pole má přidružený objekt Class, sdílený se všemi ostatními poli se stejným typem komponenty.

// Java program to demonstrate // Class Objects for Arrays class Test { public static void main(String args[]) { int intArray[] = new int[3]; byte byteArray[] = new byte[3]; short shortsArray[] = new short[3]; // array of Strings String[] strArray = new String[3]; System.out.println(intArray.getClass()); System.out.println( intArray.getClass().getSuperclass()); System.out.println(byteArray.getClass()); System.out.println(shortsArray.getClass()); System.out.println(strArray.getClass()); } }>

class [I class java.lang.Object class [B class [S class [Ljava.lang.String;>

Vysvětlení výše uvedené metody:

1. Řetězec [I je podpis typu běhu pro pole objektů třídy s typem komponenty int .
2. Jediná přímá nadtřída typu pole je java.lang.Object .
3. Řetězec [B je podpis typu běhu pro pole objektů třídy s typem komponenty byte .
4. Řetězec [S je podpis typu běhu pro pole objektů třídy s typem komponenty krátký .
5. Řetězec [L je podpis typu run-time pro pole objektů třídy s typem komponenty třídy. Následuje název třídy.

Členové pole Java

Nyní, jak víte, pole jsou objekty třídy a přímá nadtřída polí je třída Object. Členy typu pole jsou všechny následující:

• Veřejné finále délka obsahuje počet součástí pole. Délka může být kladná nebo nulová.
• Všechny členy jsou zděděny z třídy Object; jediná metoda objektu, která se nedědí, je jeho klon metoda.
• Veřejná metoda klon() přepíše metodu clone ve třídě Object a vyvolá no zaškrtnuté výjimky .

Typy polí a jejich povolené typy prvků

Klonování jednorozměrného pole v Javě

Když klonujete jednorozměrné pole, jako je Object[], provede se hluboká kopie s novým polem obsahujícím kopie prvků původního pole na rozdíl od odkazů.

10 z 60

Níže je uvedena implementace výše uvedené metody:

// Java program to demonstrate // cloning of one-dimensional arrays class Test { public static void main(String args[]) { int intArray[] = { 1, 2, 3 }; int cloneArray[] = intArray.clone(); // will print false as deep copy is created // for one-dimensional array System.out.println(intArray == cloneArray); for (int i = 0; i < cloneArray.length; i++) { System.out.print(cloneArray[i] + ' '); } } }>

false 1 2 3>

Klonování vícerozměrného pole v Javě

Klon vícerozměrného pole (jako Object[][]) je však mělká kopie, což znamená, že vytváří pouze jediné nové pole s každým polem prvků odkazem na původní pole prvků, ale podpole jsou sdílené.

// Java program to demonstrate // cloning of multi-dimensional arrays class Test { public static void main(String args[]) { int intArray[][] = { { 1, 2, 3 }, { 4, 5 } }; int cloneArray[][] = intArray.clone(); // will print false System.out.println(intArray == cloneArray); // will print true as shallow copy is created // i.e. sub-arrays are shared System.out.println(intArray[0] == cloneArray[0]); System.out.println(intArray[1] == cloneArray[1]); } }>

false true true>

Často kladené otázky v Java Arrays

1. Můžeme zadat velikost pole tak dlouho?

Ne, nemůžeme určit velikost pole jako dlouhé, ale můžeme ho zadat jako int nebo short.

2. Která je přímá nadtřída pole v Javě?

An Objekt je přímá nadtřída pole v Javě.

3. Která rozhraní jsou implementována pomocí polí v Javě?

Každý typ pole implementuje rozhraní Cloneable a java.io.Serializovatelný .

4. Můžeme změnit velikost pole?

Velikost pole nelze změnit (po inicializaci). Nicméně odkaz na pole lze provést tak, aby ukazoval na jiné pole.

Související články k tématu

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