Vícerozměrná pole v java android. Pole v Javě - definice a tvorba, inicializace a plnění

pole (anglické pole) je to objekt, který ukládá pevný počet hodnot stejného typu. Jinými slovy, pole je očíslovaná kolekce proměnných. Zavolá se proměnná v poli prvek pole a jeho pozice v poli je dána vztahem index. Například potřebujeme uložit 50 různých jmen, jak vidíte, je nepohodlné vytvářet pro každé jméno samostatnou proměnnou, takže použijeme pole. Číslování prvků pole začíná od 0 a délka pole je nastavena v době jeho vytvoření a je pevná.

Pro názornost obrázek, ze kterého jsem pořídil Výukový program Java.

Abyste mohli vytvořit pole, musíte jej deklarovat, vyhradit pro něj paměť a inicializovat jej.

Deklarace pole v Javě

Při vytváření pole v Nejprve Java je třeba to oznámit. To lze provést takto:

Int myFirstArray;

Můžete také deklarovat pole takto:

int mySecondArray;

To však není vítáno konvencí kódování Java, protože závorky naznačují, že máme co do činění s polem, a dávají větší smysl, když jsou vedle typového označení.

Na základě tento příklad, deklarovali jsme 2 pole pojmenovaná myFirstArray A mySecondArray. Obě pole budou obsahovat prvky typu int.

Podobně můžete deklarovat pole libovolného typu:

Byte anArrayOfBytes; krátké anArrayOfShorts; long anArrayOfLongs; float anArrayOfloats; double anArrayOfDoubles; boolean anArrayOfBooleans; char anArrayOfChars; String anArrayOfStrings; ...

Typ pole je dán typem, kde typ je datový typ prvků, které obsahuje. Závorky jsou speciální označení, že proměnné jsou obsaženy v poli. Název pole může být jakýkoli, musí se však shodovat s .

Pole lze vytvářet nejen z proměnných základní typy, ale také z libovolných objektů.

Při deklaraci pole v jazyk Java jeho velikost není specifikována a není pro něj vyhrazena žádná paměť. Vytvoří pouze odkaz na pole.

Rezervace paměti pro pole a jeho inicializace.

Int myFirstArray; myFirstArray = new int;

V našem příkladu jsme vytvořili pole 15 prvků typu int a přiřadili ji k dříve deklarované proměnné myFirstArray.

Můžete také deklarovat název pole a vyhradit pro něj paměť na stejném řádku.

int myArray = new int;

Při vytváření pole pomocí klíčové slovo Nový, všechny prvky pole se automaticky inicializují na nulové hodnoty. Aby bylo možné přiřadit prvkům pole jejich počáteční hodnoty, je nutné jej provést inicializace. Inicializaci lze provést prvek po prvku

MyFirstArray = 10; // inicializace prvního prvku myFirstArray = 20; // inicializace druhého prvku myFirstArray = 30; // atd.

a ve smyčce pomocí indexu procházet všechny prvky pole a přiřazovat jim hodnoty.

For(int i = 0; i< 15; i++){ myFirstArray[i] = 10; }

Jak můžete vidět z předchozích příkladů, abyste mohli odkazovat na prvek pole, musíte zadat jeho název a poté v hranatých závorkách index prvku. Prvek pole na určitém indexu se chová stejně jako proměnná.

Zvažte vytvoření a inicializaci pole pomocí následujícího příkladu. V něm vytvoříme pole obsahující čísla 0-9 a vytiskneme hodnoty do konzole.

//vytvoření a inicializace pole int numberArray = new int; for(int i = 0; i< 10; i++){ numberArray[i] = i; } //вывод значений на консоль for(int i = 0; i < 10; i++){ System.out.println((i+1) + "-й элемент массива = " + numberArray[i]); }

Zjednodušený zápis

K vytvoření a inicializaci pole můžete také použít zjednodušený zápis. Neobsahuje slovo Nový a počáteční hodnoty pole jsou uvedeny v závorkách.

int myColor = (255, 255, 0);

Zde je délka pole určena počtem hodnot mezi závorkami oddělenými čárkami. Tento zápis je vhodnější pro vytváření malých polí.

Určení velikosti pole

Velikost pole není vždy zřejmá, takže pro zjištění použijte vlastnost length, která vrací délku pole.

MyColor.length;

Tento kód nám pomůže zjistit, že délka pole myColor je 3.

Příklad: Jsou-li 4 čísla, musíte najít minimum

int čísla = (-9, 6, 0, -59); int min = čísla; for(int i = 0; i< numbers.length; i++){ if(min>čísla[i]) min = čísla[i]; ) System.out.println(min);

Cvičení na jednorozměrných polích v Javě:

1. Vytvořte pole obsahující prvních 10 lichých čísel. Vytiskněte prvky pole do konzoly na jednom řádku, oddělené čárkou.
2. Vzhledem k poli o rozměru N najděte nejmenší prvek pole a vytiskněte jej do konzoly (pokud existuje několik nejmenších prvků, vytiskněte je všechny).
3. V poli z úkolu 2 najděte největší prvek.
4. Zaměňte největší a nejmenší prvky pole. Příklad: Je dáno pole (4, -5, 0, 6, 8). Po výměně bude vypadat takto (4, 8, 0, 6, -5).
5. Najděte aritmetický průměr všech prvků pole.

Představte si buňky ve skladu. Každý z nich má své vlastní číslo a každý z nich ukládá nějaký předmět „Baggage“. Nebo vinný lístek, ve kterém jsou všechny druhy vín očíslovány a při objednávce stačí uvést číslo nápoje. Nebo seznam studentů ve skupině, ve kterém první buňka bude obsahovat studenta "Andreev" a poslední buňka - "Yakovlev". Nebo seznam cestujících v letadle, z nichž každý má přidělené sedadlo určitý počet. V Javě se pro práci s podobnými strukturami, tedy množstvím homogenních dat, často používají pole.

Co je pole?

Prohlášení pole

Jak deklarovat pole?

Vytvoření pole

Jak vytvořit pole?

Délka pole v Javě

Inicializace pole a přístup k jeho prvkům

Jak zobrazit pole v Javě?

Jednorozměrná a vícerozměrná pole Java

Užitečné metody pro práci s poli

Pole řazení

Vyhledejte v poli požadovaný prvek

Převod pole na řetězec

Příklad na sort, binarySearch a toString

To hlavní o polích

Hlavní charakteristiky pole jsou typ dat v něm umístěných, název a délka.
O tom druhém se rozhoduje během inicializace (alokace paměti pro pole), první dva parametry jsou určeny při deklaraci pole.

Velikost pole (počet buněk) musí být definována v int

Po vytvoření pole nelze změnit jeho délku.

K prvku pole lze přistupovat pomocí jeho indexu.

V polích, stejně jako jinde v Javě, jsou prvky číslovány od nuly.

Po proceduře vytvoření pole se pole vyplní výchozími hodnotami.

Pole v Javě je velmi odlišné od pole v C++. Je to však prakticky stejné jako ukazatel na dynamické pole.

Užitečné materiály o polích

Něco o polích - pěkný podrobný článek o polích

Třída Arrays a její použití - článek popisuje některé metody třídy Array

Pole je první lekcí JavaRush o polích.

Vraťte pole nulové délky, nikoli null – autor efektivního programování Joshua Bloch hovoří o nejlepším způsobu, jak vrátit prázdná pole

Poslední aktualizace: 09.11.2018

Pole představuje sadu hodnot stejného typu. Deklarace pole je jako deklarace běžné proměnné, která ukládá jednu hodnotu, a existují dva způsoby, jak deklarovat pole:

datový_typ název_pole; // nebo datový_typ název_pole;

Definujme například pole čísel:

int nums; int nums2;

Po deklaraci pole jej můžeme inicializovat:

int nums; nums = new int; // pole 4 čísel

Pole je vytvořeno pomocí následující konstrukce: new data_type[number_of_elements] , kde new je klíčové slovo, které alokuje paměť pro počet prvků zadaný v závorkách. Například nums = new int; - tento výraz vytvoří pole čtyř prvků int a každý prvek bude mít výchozí hodnotu - číslo 0.

Pole můžete také okamžitě inicializovat, když jej deklarujete:

int nums = nový int; // pole 4 čísel int nums2 = new int; // pole 5 čísel

S touto inicializací mají všechny prvky pole výchozí hodnotu. Pro číselné typy(včetně pro typu char) je číslo 0, pro boolean je nepravda a pro ostatní objekty je null . Například pro typ int je výchozí hodnotou číslo 0, takže pole nums definované výše se bude skládat ze čtyř nul.

Je však také možné nastavit konkrétní hodnoty pro prvky pole, když je vytvořeno:

// tyto dva způsoby jsou ekvivalentní int nums = new int ( 1, 2, 3, 5 ); int nums2 = (1, 2, 3, 5);

Stojí za zmínku, že v tomto případě není velikost pole uvedena v hranatých závorkách, protože se počítá podle počtu prvků ve složených závorkách.

Po vytvoření pole můžeme odkazovat na kterýkoli z jeho prvků indexem, který je předán v hranatých závorkách za názvem proměnné pole:

int nums = nový int; // nastavení hodnot prvků pole nums = 1; nums = 2; nums = 4; čísla = 100; // získání hodnoty třetího prvku pole System.out.println(nums); // 4

Indexování prvků pole začíná na 0, takže v tomto případě, abychom odkazovali na čtvrtý prvek v poli, musíme použít výraz nums.

A protože je naše pole definováno pouze pro 4 prvky, nemůžeme odkazovat například na šestý prvek: nums = 5; . Pokud se o to pokusíme, dostaneme chybu.

Délka pole

Nejdůležitější vlastností, kterou pole mají, je vlastnost length, která vrací délku pole, tedy počet jeho prvků:

int nums = (1, 2, 3, 4, 5); int délka = nums délka; // 5

Není neobvyklé, že poslední index je neznámý a pro získání posledního prvku pole můžeme použít tuto vlastnost:

int last = nums;

Vícerozměrná pole

Dříve jsme zvažovali jednorozměrná pole, která mohou být reprezentována jako řetězec nebo řetězec hodnot stejného typu. Ale kromě jednorozměrných polí existují i ​​vícerozměrná. Nejznámější vícerozměrné pole je tabulka, která představuje dvourozměrné pole:

int nums1 = new int ( 0, 1, 2, 3, 4, 5); int nums2 = (( 0, 1, 2), ( 3, 4, 5));

Vizuálně lze obě pole reprezentovat následovně:

Jednorozměrné pole nums1

Dvourozměrné pole nums2

Protože pole nums2 je dvourozměrné, ano jednoduchý stůl. Dalo by se také vytvořit takto: int nums2 = new int; . Množství hranaté závorky označuje velikost pole. A čísla v závorkách - počet řádků a sloupců. A také pomocí indexů můžeme v programu použít prvky pole:

// nastavíme prvek prvního sloupce druhého řádku nums2=44; System.out.println(čísla2);

Deklarace trojrozměrného pole může vypadat takto:

int nums3 = new int;

zubaté pole

Vícerozměrná pole mohou být také reprezentována jako "zubatá pole". Ve výše uvedeném příkladu mělo 2D pole 3 řádky a 3 sloupce, takže jsme skončili s plochou tabulkou. Ale můžeme každému prvku ve dvourozměrném poli přiřadit samostatné pole jiná částka Prvky:

int nums = nový int; nums = new int; nums = new int; nums = new int;

pro každého

Speciální verze cyklu for je navržena pro iteraci prvků v sadách prvků, jako jsou pole a kolekce. Je podobná smyčce foreach v jiných programovacích jazycích. Formální oznámení:

For (datatype variable_name: container)( // actions )

Například:

pole int = new int ( 1, 2, 3, 4, 5 ); for (int i: pole)( System.out.println(i); )

Kontejner je v tomto případě pole dat typu int . Poté je proměnná deklarována s typem int

Totéž by se dalo udělat s běžná verze pro:

pole int = new int ( 1, 2, 3, 4, 5 ); for (int i = 0; i< array.length; i++){ System.out.println(array[i]); }

Zároveň je tato verze cyklu for flexibilnější než for (int i: array) . Zejména v této verzi můžeme měnit prvky:

pole int = new int ( 1, 2, 3, 4, 5 ); for (int i=0; i

Iterace přes vícerozměrná pole ve smyčce

Nejprve se vytvoří smyčka pro iteraci řádků a poté se uvnitř první smyčky vytvoří vnitřní smyčka pro iteraci přes sloupce konkrétního řádku. Podobně můžete iterovat přes trojrozměrná pole a sady s velkým počtem dimenzí.

pole je datová struktura, která je navržena pro ukládání dat stejného typu. Pole v Javě fungují jinak než v C/C++. Zvláštnosti:

• Protože pole jsou objekty, můžeme zjistit jejich délku. To se liší od C/C++, kde zjišťujeme délku pomocí sizeof.
• Proměnná pole může být také .
• Proměnné jsou seřazeny a mají index začínající od 0.
• Může být také použit jako statické pole, lokální proměnná nebo parametr metody.
• Velikost pole musí být int, nikoli dlouhá nebo krátká.
• Přímá nadtřída typu pole je Object.
• Každý typ pole implementuje rozhraní Cloneable a java.io.Serializable.

Inicializace a přístup k poli

Jednorozměrná pole: Obecný formulář prohlášení

Zadejte var-name; nebo zadejte var-name;

Deklarace má dvě složky: typ a název. type deklaruje typ prvku pole. Typ prvku určuje datový typ každého prvku.

Kromě typu int můžeme vytvořit i pole dalších datových typů, jako je char, float, double nebo uživatelsky definovaný datový typ (objekty třídy) Typ prvku tedy určuje, jaký typ dat bude v poli uložen. Například:

// obě jsou platné deklarace int intArray; nebo pole int; byte byteArray; shortsArray; boolean booleanArray; dlouhé dlouhé pole; float floatArray; double doubleArray; char charArray; // pole odkazů na objekty // třídy MyClass (třída vytvořená // uživatelem) MyClass myClassArray; Object ao, // pole Object Collection ca; // pole kolekce // neznámého typu

Ačkoli první deklarace výše uvádí skutečnost, že intArray je proměnná pole, pole ve skutečnosti neexistuje. Jednoduše řekne kompilátoru, že tato proměnná je typu integer.

Chcete-li přiřadit pole int ke skutečnému fyzickému poli celých čísel, musíte jej označit new a přiřadit jej k int.

Jak vytvořit pole v Javě

Když je pole deklarováno, vytvoří se pouze odkaz na pole. Chcete-li skutečně vytvořit nebo alokovat úložiště k poli, vytvořili byste takové pole: obecná forma nového při použití na jednorozměrné pole je následující:
var-name = novy typ ;

Zde type určuje datový typ, velikost určuje počet prvků v poli a var-name je název proměnné pole.

pole int; //deklarace intArray = new int; // alokace paměti

int intArray = nový int; // Svaz

Je důležité vědět, že prvky pole alokované pomocí new jsou automaticky inicializovány na nulu (pro číselné typy), false (pro booleovské typy) nebo nulu (pro referenční typy).
Získání pole je dvoufázový proces. Nejprve musíte deklarovat proměnnou požadovaného typu. Za druhé, musíte alokovat paměť, která bude obsahovat pole pomocí new a přiřadit ji k proměnné. V Javě jsou tedy všechna pole dynamicky alokována.

Array literály

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

int intArray = new int( 1,2,3,4,5,6,7,8,9,10); // Deklarace literálu pole

• Délka tohoto pole určuje délku vytvořeného pole.
• V posledních verzích Javy není třeba psát int

Přístup k prvkům Java Array pomocí smyčky for

Ke každému prvku pole se přistupuje prostřednictvím jeho indexu. Index začíná na 0 a končí na (celková velikost)-1. Všechny prvky jsou přístupné pomocí smyčky for.

Pro (int i = 0; i< arr.length; i++) System.out.println("Element at index " + i + " : "+ arr[i]);

// Příklad pro ilustraci vytvoření pole
// celá čísla, vloží některé hodnoty do pole,
// a vypíše každou hodnotu.

třída GFG
{
{
int arr;

// alokace paměti pro 5 celých čísel.
arr = nový int;

arr = 10;

arr = 20;

//již brzy...
arr = 30;
arr = 40;
arr=50;

// přístup k prvkům zadaného pole
for (int i = 0; i< arr.length; i++)
System.out.println("Prvek na indexu " + i +
" : "+ arr[i]);
}
}
V důsledku toho získáme:

Prvek na indexu 0: 10 Prvek na indexu 1: 20 Prvek na indexu 2: 30 Prvek na indexu 3: 40 Prvek na indexu 4: 50

Pole objektů

Pole objektů se vytvoří stejným způsobem jako datové prvky, a to následovně:

Student arr = nový student;

StudentArray obsahuje sedm úložných prvků každý ze studentské třídy, do kterých lze uložit adresy sedmi objektů Student. Objekty studentů musí být vytvořeny pomocí konstruktoru třídy student a jejich odkazy musí být přiřazeny k prvkům pole takto:

Student arr = nový student;

// Java program pro ilustraci vytváření pole
// objekty

třídní žák
{
public int roll_no;
public Stringname;
Student(int roll_no, název řetězce)
{
this.roll_no = roll_no;
this.name = jméno;
}
}

// Prvky pole jsou objekty třídy Student.
veřejná třída GFG
{
public static void main (string args)
{
// deklaruje pole celých čísel.
student arr;

// alokace paměti pro 5 objektů typu Student.
arr = nový student;

// inicializuje první prvky pole
arr = new Student(1,"aman");

// inicializuje druhé prvky pole
arr = nový student(2,"vaibhav");

// již brzy...
arr = nový student(3,"shikar");
arr = nový student(4,"dharmesh");
arr = new Student(5,"mohit");

// přístup k prvkům zadaného pole
for (int i = 0; i< arr.length; i++)
System.out.println("Prvek na " + i + " : " +
arr[i].roll_no +" "+ arr[i].name);
}
}

Dostaneme:

Element v 0:1 aman Element v 1:2 vaibhav Element v 2:3 shikar Element v 3:4 dharmesh Element v 4:5 mohit

Co se stane, když se pokusíme získat přístup k prvku mimo pole?
Kompilátor 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.

Multidimenzionální

Vícerozměrná pole jsou pole polí, kde každý prvek obsahuje odkaz na jiné pole. Vytvořeno přidáním jedné sady hranatých závorek () pro každý rozměr. Zvažte příklad:

int intArray = nový int; //2D pole nebo matice int intArray = new int; // 3D pole

Třída vícerozměrná
{
public static void main (Stringargs)
{
// deklarace a inicializace 2D pole
int arr = ((2,7,9),(3,6,1),(7,4,2));

// tisk 2D pole
for (int i=0; i< 3 ; i++)
{
pro (int j=0; j< 3 ; j++)
System.out.print(arr[i][j] + " ");

System.out.println();
}
}
}

Výstup: 2 7 9 3 6 1 7 4 2

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

Stejně jako proměnné můžeme předávat pole metodám.

// Java program pro demonstraci // předání pole třídě metody Test ( // metoda ovladače public static void main(String args) ( int arr = (3, 1, 2, 5, 4); // předání pole metodě m1 sum(arr); ) public static void sum(int arr) ( // získání součtu hodnot pole pro (int sumint i = 0;< arr.length; i++) sum+=arr[i]; System.out.println("sum of array values: " + sum); } }

Na výstupu dostaneme:

součet hodnot pole: 15

Vrácení polí z metod

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

// Java program pro demonstraci // návrat pole z metody třídy Test ( // metoda ovladače 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}; } }

objekty třídy

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

// Program Java k demonstraci // Objekty třídy pro pole třída Test ( public static void main(String args) ( int intArray = nový int; byte byteArray = nový byte; short shortsArray = nový krátký; // pole řetězců String strArray = nový řetězec; System.out.println(intArray.getuClassprint(Array).ray.getuClass. )); System.out.println(byteArray.getClass ()); System.out.println(shortsArray.getClass()); System.out.println(strArray.getClass()); ) )

třída+""); )))

Klon vícerozměrného pole (jako Object ) je kopie, což znamená, že vytvoří pouze jedno nové pole s každým prvkem a odkazem na původní pole prvků, ale vnořená pole jsou běžná.

// Java program pro demonstraci // klonování vícerozměrných polí třída Test ( public static void main(String args) ( int intArray = ((1,2,3),(4,5)); int cloneArray = intArray.clone(); // vytiskne false System.out.println(intArray == klonopole.e. kopíruje se true. System. // bude vytvořena kopie systému jako-out. i. println(intArray == cloneArray); System.out. println(intArray == cloneArray); ) )

Nepravdivé
skutečný
skutečný

je uspořádaná kolekce nebo číslovaný seznam hodnot odkaz který se provádí pod běžným názvem. Mohou to být primitivní hodnoty, objekty nebo dokonce jiná pole, ale všechny hodnoty pole musí být stejného typu. Typ pole je identický s typem hodnot, které obsahuje.

Pole jsou referenční datové typy, vlastně jako všechny ostatní typy, kromě primitivních. Ještě jednou připomenu, že v Javě je vše objekt, jedinou výjimkou jsou primitivní typy.

Pole mohou být jednorozměrná nebo vícerozměrná.

Proces vytváření pole lze rozdělit do tří kroků:

• Oznámení ( prohlášení)
• Stvoření ( instantizace)
• inicializace ( inicializace)

Prohlášení pole

Pouze v této fázi typ proměnné odkaz (odkaz) na pole A obsahující typ pole. K tomu se zapíše název typu prvků pole, hranaté závorky to naznačují je deklarován odkaz na pole , není jednoduchá proměnná, a názvy proměnných typu odkazu jsou uvedeny, například:

čísla ; // čísla je odkaz na pole ints
Tětiva str ; // str je odkaz na pole řetězců
byte dva bajty ; // twoBytes odkaz na dvourozměrné pole bajtů
char písmena , číslic ; //písmena a číslice jsou odkazy na pole znaků

V podstatě je deklarace polí úplně stejná operace jako deklarace jakýchkoli jiných datových typů, i když má trochu jinou syntaxi, protože se jedná o stejná pole.

Java podporuje další syntaxi pro deklarování proměnných pole, což zajišťuje kompatibilitu s C a C++. Podle této syntaxe následuje jeden nebo více párů hranatých závorek za názvem proměnné, nikoli za názvem typu:

arrayOfBytes ; // Stejné jako byte arrayOfBytes
byte arrayOfArrayOfBytes ; // Stejné jako byte arrayOfArrayOfBytes
byte arrayOfArrayOfBytes ; // Stejné jako byte arrayOfArrayOfBytes

Tato syntaxe je však často matoucí a je třeba se jí vyhnout. V následujícím příkladu je snadné zaměnit, co je myšleno:

sazby , maxRate ; // možná jste chtěli deklarovat dvě pole?

Tato syntaxe se nedoporučuje, protože již bylo řečeno, že je matoucí, navíc v konvencích pro návrh kódu Java se doporučuje syntaxe, která byla uvedena jako první, tedy hranaté závorky bezprostředně následují za typem deklarovaného pole.

V tomto případě je deklarováno pole plovoucích hodnot s názvem rate a proměnná typu float maxRate.

To znamená, že pokud jsou hranaté závorky hned za typem deklarovaného pole, pak všechny proměnné, které jsou deklarovány v tomto řádku, jsou odkazy na pole deklarovaného typu, a pokud jsou hranaté závorky napravo od proměnné, pak se jedná pouze o odkaz na pole deklarovaného typu.

Tomu je třeba rozumět tato operace deklarace pole ještě nevytváří pole, ale pouze deklaruje proměnnou, která je na něj odkazem, který nelze v programu použít bez inicializace, protože kompilátor zobrazí chybu, že proměnná pole není inicializována.

Dokud není deklarovaná proměnná pole definována, může obsahovat (pokud přiřadíte) hodnotu nula. A teprve po definici bude obsahovat odkaz na konkrétní objekt.

Při deklaraci proměnné pole není možné určit délku pole, protože velikost je striktně funkcí objektu pole, nikoli odkazem na něj..

Instantování pole

V této fázi je indikován počet prvků pole, nazývaný jeho velikost, pro pole je přiděleno místo v paměti RAM, referenční proměnná je přiřazena operátorem = adresa pole. Všechny tyto úkony provádí operátor Nový následován typ prvky pole. Například:

= Nový char [ 10 ] ;

Ještě jednou je ale vhodné poznamenat, že předtím musí být proměnná písmen deklarována jako pole. Aby to bylo jasnější, může být reprezentován takto:

písmena ; // deklarovaná písmena jako odkaz na pole znaků
písmena = Nový char [ 10 ] ; // vytvořilo pole znaků o velikosti 10 prvků

Při vytváření pole s touto syntaxí se všechny prvky pole automaticky inicializují s výchozími hodnotami. Je nepravda pro booleovské hodnoty, "\u0000" pro hodnoty znaků, 0 pro celočíselné hodnoty, 0,0 pro hodnoty s plovoucí desetinnou čárkou a null pro objekty nebo pole.

V Javě je velikost pole pevná. Vytvořené pole nelze zvětšit ani zmenšit. Požadovaná velikost vytvořeného pole je dána nezáporným celým číslem. Ale kdykoli lze proměnné typu pole přiřadit nové pole jiné velikosti. To znamená, že lze přiřadit odkaz na jiné pole stejného typu jako deklarovaná proměnná.

Indexy polí vždy začínají na 0.

První dvě operace: deklarace a vytvoření pole lze spojit do jednoho příkazu. Například:

písmena = Nový char [ 10 ] ;

Tento operátor je ekvivalentní dvěma výše uvedeným.

Po této operaci bude proměnná písmen již obsahovat odkaz na pole a pokud se pokusíme zobrazit jeho hodnotu, dostaneme hodnotu, něco jako ;
int b = A;

Je ale třeba mít na paměti, že proměnné A A b ukažte na stejné pole. Zpočátku to může být matoucí, ale pokud si pamatujete, že máme co do činění s referenčními datovými typy, pak vše zapadne na své místo. Pokud tento bod není jasný, o něco později to vše analyzujeme na příkladech.

= nula ;

Poté se pole, na které odkazuje tento odkaz, ztratí, pokud na něj nebyly žádné jiné odkazy..

Velikost nebo délku pole lze získat pomocí konstanty délka , který je definován pro každé pole a vrací jeho délku. Už jsme to nejednou použili v příkladech, kdy jsme pracovali s argumenty předávanými na příkazovém řádku.

Můžete vytvářet a používat pole nulové délky (prázdné pole). Například:

bitů = Nový booleovský [ 0 ] ;

Takové pole není možné inicializovat, protože jednoduše nemá prvky, které lze inicializovat. Okamžitě vyvstává otázka, proč sakra potom potřebují tato prázdná pole? Ale jsou nezbytné a dokonce velmi užitečné!

Prázdné pole se obvykle používá na těch místech v programu, kde není předem známo, zda tam budou prvky nebo ne. Jsou-li prvky, je vráceno neprázdné pole, pokud nejsou žádné prvky, je vráceno prázdné pole. Příkladem je pole řetězců, které je předáno metodě main() a obsahuje argumenty příkazového řádku, a pokud žádné nejsou, vrátí se prázdné pole.

Prázdné pole je lepší než nula, protože nevyžaduje samostatné if "a pro zpracování. Totéž platí pro seznamy a další kolekce. Proto existují metody Collections.emptyList, emptySet, emptyMap.

Inicializace pole

V této fázi získávají prvky pole počáteční hodnoty. Existuje několik způsobů, jak inicializovat prvky pole s hodnotami:

1. Každému prvku pole přiřaďte konkrétní hodnotu (lze to provést např. ve smyčce, ale předtím musí být pole již deklarováno a vytvořeno)
2. Inicializujte pole uvedením hodnot jeho prvků ve složených závorkách (toto lze provést jak ve fázi deklarace, tak ve fázi vytváření, ale syntaxe je odlišná)

Odkazuje na konkrétní prvek pole podle jeho indexu, která začíná od nuly, jak již bylo zmíněno.

Indexy lze zadat libovolnými celočíselnými výrazy kromě typu dlouho , například a , a , a[++i] . Runtime systém Java zajišťuje, že hodnoty těchto výrazů nepřekročí délku pole. Pokud k ukončení stále dojde, překladač Java poté zastaví provádění programu a zobrazí na konzole zprávu o tom, že index pole překračuje hranice své definice ( Výjimka ArrayIndexOutOfBounds).

Zvažte příklad prvního způsobu inicializace:

ar = Nový int [ 2 ] ;
ar[ 0 ] = 1 ;
ar[ 1 ] = 2 ;

Druhý způsob inicializace lze implementovat různými způsoby.

Inicializaci pole lze kombinovat s krokem vytvoření, ale před touto operací musí být pole již deklarováno. Například:

ar ; // deklarace pole
ar = Nový int { 1 , 2 } ; // vytvoření a inicializace

Před vytvořením a inicializací pole ar už to bylo oznámeno.

Pole můžete také inicializovat ve fázi jeho deklarace s následující syntaxí:

ar = { 1 , 2 } ; // deklarace, vytvoření a inicializace pole

Pozornost! Tato syntaxe inicializace pole funguje pouze v případě, že je pole deklarováno a kombinuje všechny tři operace najednou: deklaraci, vytvoření a inicializaci. Pokud je pole již deklarováno, nelze tuto syntaxi použít. Kompilátor vyvolá chybu. to je:

int ar ; // deklarace pole
ar = { 1 , 2 } ; // CHYBA!!! vytváření a inicializace pole

Taková akce nebude fungovat.

Můžete také inicializovat ve fázi deklarace a trochu jinak:

ar = Nový int { 1 , 2 } ; // deklarace, vytvoření a inicializace

I když tato syntaxe je delší. Pokud si všimnete, pak tato syntaxe je také kombinací všech tří operací: deklarace, vytvoření a inicializace.

Java poskytuje syntaxi, která podporuje anonymní pole (nejsou přiřazena k proměnným, a proto nemají jména). Někdy pole stačí použít pouze jednou (například předat metodě), takže nechcete ztrácet čas jeho přiřazením k proměnné, takže můžete výsledek příkazu použít hned. Nový. Například:

. ven . println( Nový char { "H", "E", "l", "l", "Ó"}) ;

Syntaxe pro inicializaci polí se složenými závorkami se nazývá literál, protože k inicializaci se používá pole literál.

Je důležité pochopit, že doslovná pole se vytvářejí a inicializují za běhu, nikoli v době kompilace.. Zvažte následující literál pole:

PerfectNumbers = { 6 , 28 } ;

Zkompiluje se do tohoto bytekódu Java:

PerfectNumbers = Nový int [ 2 ] ;
PerfectNumbers[ 0 ] = 6 ;
PerfectNumbers[ 1 ] = 28 ;

Pokud tedy potřebujete do programu Java vložit velké množství dat, je nejlepší je nezahrnout přímo do pole, protože kompilátor Java bude muset vytvořit mnoho inicializačního bajtkódu pole a interpret jazyka Java pak bude muset celý tento kód pracně spustit. V takových případech je lepší uložit data do externího souboru a načíst je do programu za běhu.

Nicméně skutečnost, že Java inicializuje pole za běhu, má důležité důsledky. To znamená, že prvky doslovného pole jsou libovolné výrazy vyhodnocené za běhu, nikoli konstantní výrazy vyhodnocené kompilátorem.. Například:

body = { circle1.getCenterPoint () , circle2.getCenterPoint () } ;

Teď si trochu zacvičíme.

Známá metoda main() využívá schopnost vrátit pole nulové délky, pokud na příkazovém řádku nejsou žádné argumenty, což vám umožňuje vyhnout se použití příkazu if ke kontrole null, abyste se vyhnuli chybě během provádění programu.

To znamená, že můžeme pole okamžitě použít ve smyčce, i když dodržujeme pravidla, abychom nepřekročili maximální index.

Na začátku programu vytiskneme hodnotu délky pole a poté v první smyčce postupně vytiskneme všechny hodnoty prvků pole. Druhá smyčka dělá totéž, ale zvráceným způsobem.

Druhý příklad je ahoj, abyste potěšili svůj mozek, abyste rozšířili své vědomí, nenudilo vás vědět, jak to udělat, ale jak to nedělat, no, čistě pro vzdělávací a vzdělávací účely. Možná ve volném čase přijdete na to, jak funguje druhý cyklus.

Tento program generuje následující výstup:

V prvním případě jsme nezadali žádné argumenty, takže jsme dostali pole nulové délky, které nebylo v cyklech zpracováno, protože nesplňuje podmínky cyklů.

Ve druhém případě jsme předali argumenty na příkazovém řádku a následně bylo pole zpracováno v cyklech.