Geavanceerde array-afhandeling

1. Stringreeks

Ik wil u een kort overzicht geven van Stringarrays.

Zoals we eerder zeiden, kan een array van elk type zijn. Dit betekent dat u een array van s kunt maken String. Als we een programma willen schrijven dat "10 regels van het toetsenbord leest en ze in omgekeerde volgorde weergeeft", ziet de code er als volgt uit:

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

De code is amper veranderd! We hoefden alleen te vervangen intdoor Stringbij het maken van de array. Nou, en bij het lezen van de string van het toetsenbord hebben we de nextInt()methode ook vervangen door nextLine().

2. Stringarray in het geheugen

En nog een nuttig feit. Laten we 3 foto's bekijken:

Afbeelding 1. Hoe een Stringobject in het geheugen is gerangschikt:

Deze foto is genomen uit eerdere lessen.

Houd er rekening mee dat de tekst van de string niet direct in de variabele wordt opgeslagen: er wordt een apart geheugenblok voor toegewezen. Een Stringvariabele slaat het adres (referentie) op naar een object dat de tekst opslaat.

Afbeelding 2. Hoe een integer-array in het geheugen is gerangschikt:

Ook deze foto is bekend.

Afbeelding 3. Hoe een stringarray in het geheugen is gerangschikt:

Aan de linkerkant zien we een array-variabele waarvan het type is String[](het slaat het adres op van een array-object).

In het midden hebben we Stringhet array-object zelf.

En aan de rechterkant zijn stringobjecten die wat tekst opslaan.

De cellen van de Stringarray slaan de strings zelf niet op (de tekst van de String-objecten). In plaats daarvan slaan ze hun adressen op (referenties daarnaar). Op dezelfde manier waarop Stringvariabelen de adressen van tekenreeksobjecten opslaan (waar de tekst wordt opgeslagen).

Houd hier rekening mee wanneer u matrixcellen vergelijkt:

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. Snelle array-initialisatie in Java

Arrays zijn superhandig, dus de makers van Java probeerden het werken met ze zo gemakkelijk mogelijk te maken.

Het eerste wat ze deden was het vereenvoudigen van de array-initialisatie, het proces waarbij je de beginwaarden van een array opgeeft.

Naast gegevens die ergens vandaan worden gelezen, heeft een programma immers vaak ook eigen interne gegevens nodig om te kunnen werken. Stel dat we de lengte van elke maand in een array moeten opslaan. Dit is hoe de code eruit zou kunnen zien:

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

Maar dankzij de makers van Java is er een manier om dit beknopter te schrijven:

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

U kunt eenvoudig alle waarden van de array weergeven, gescheiden door komma's!

Handig toch? Maar dat is niet alles.

De compiler kan namelijk het type container (array-object) bepalen op basis van het type waarden van de array. En om de lengte van de array te bepalen, is het triviaal om het aantal elementen te tellen dat tussen de accolades staat.

Dat betekent dat deze code nog korter kan worden geschreven:

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

Een ding van schoonheid, is het niet? 🙂

Dit wordt "snelle array-initialisatie" genoemd. Dit werkt trouwens voor andere typen dan int...

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