Fejlett tömbkezelés

1. Stringtömb

Szeretnék egy rövid áttekintést adni Stringa tömbökről.

Mint korábban említettük, egy tömb bármilyen típusú lehet. Ez azt jelenti, hogy létrehozhat egy Strings tömböt. Ha olyan programot akarunk írni, amely "10 sort beolvas a billentyűzetről, és fordított sorrendben jeleníti meg", a kód így nézne ki:

Scanner console = new Scanner(System.in);
String[] array = new String[10];
for (int i = 0; i < 10; i++)
{
   array[i] = console.nextLine();
}
for (int i = 9; i >= 0; i--)
{
   System.out.println(array[i]);
}

A kód alig változott! A tömb létrehozásakor csak intezt kellett helyettesítenünk . StringNos, és a karakterlánc billentyűzetről történő beolvasásakor a nextInt()metódust is lecseréltük a -ra nextLine().

2. Stringtömb a memóriában

És még egy hasznos tény. Nézzünk 3 képet:

1. kép: Egy Stringobjektum elrendezése a memóriában:

Ez a kép az előző leckékről készült.

Kérjük, vegye figyelembe, hogy a karakterlánc szövege nem közvetlenül a változóban tárolódik: külön memóriablokk van lefoglalva neki. Egy Stringváltozó a szöveget tároló objektum címét (hivatkozását) tárolja.

2. kép Egy egész tömb elrendezése a memóriában:

Ez a kép is ismerős.

3. kép: Egy karakterlánc tömb elrendezése a memóriában:

A bal oldalon egy tömbváltozót látunk, melynek típusa String[](egy tömbobjektum címét tárolja).

Középen van Stringmaga a tömbobjektum.

A jobb oldalon pedig szöveges objektumok találhatók, amelyek valamilyen szöveget tárolnak.

A Stringtömb cellái nem tárolják magukat a karakterláncokat (a String objektumok szövegét). Ehelyett tárolják a címeiket (a rájuk való hivatkozásokat). Ugyanúgy, mint Stringa változók a karakterlánc objektumok címeit (ahol a szöveget tárolják).

Vegye figyelembe ezt a tömbcellák összehasonlításakor:

String[] array = new String[10];

array[1] = "Hello";
array[2] = array[1];
array[3] = new String("Hello");
// Compare
array[1] == array[2];
array[1] == array[3];
array[1].equals(array[3]);
array[1].equalsIgnoreCase(array[3]);

3. Gyors tömb inicializálás Java nyelven

A tömbök rendkívül hasznosak, ezért a Java készítői igyekeztek a lehető legkényelmesebbé tenni a velük való munkát.

Az első dolog, amit megtettek, az volt, hogy egyszerűsítsék a tömb inicializálását, azt a folyamatot, amellyel megadják a tömb kezdeti értékeit.

Hiszen a valahonnan kiolvasott adatok mellett egy programnak gyakran saját belső adataira is szüksége van a működéshez. Tegyük fel például, hogy minden hónap hosszát egy tömbben kell tárolnunk. Így nézhet ki a kód:

int[] months = new int[12];
months[0] = 31; // January
months[1] = 28; // February
months[2] = 31; // March
months[3] = 30; // April
months[4] = 31; // May
months[5] = 30; // June
months[6] = 31; // July
months[7] = 31; // August
months[8] = 30; // September
months[9] = 31; // October
months[10] = 30; // November
months[11] = 31; // December

De hála a Java készítőinek, van mód arra, hogy ezt tömörebben írjuk le:

// Lengths of months of the year
int[] months = new int[] { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

Egyszerűen felsorolhatja a tömb összes értékét, vesszővel elválasztva!

Kényelmes, igaz? De ez még nem minden.

Ennek megfelelően a fordító a tömb értékeinek típusa alapján meg tudja határozni a tároló (tömbobjektum) típusát. A tömb hosszának meghatározásához pedig triviális a kapcsos kapcsos zárójelbe írt elemek számát megszámolni.

Ez azt jelenti, hogy ez a kód még rövidebbre is írható:

// Lengths of months of the year
int[] months = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

Szépség, nem? 🙂

Ezt "gyors tömb inicializálásnak" hívják. Ez egyébként más típusoknál is működik, mint int...

// Names of months of the year
String[] months = {"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November ", "December"};