Nuances van het werken met arrays

1. Arrays in het geheugen

In de voorgaande voorbeelden waren de illustraties een beetje onnauwkeurig.

Bij het maken van arrays (zoals bij het maken van strings) worden twee afzonderlijke geheugenblokken toegewezen: een voor het opslaan van de array (container) zelf en een tweede blok voor de variabele die het adres ervan opslaat . Onderstaande afbeelding geeft deze verduidelijking weer:

Het geheugen dat is toegewezen aan de array van 10 intelementen en de int[]variabele die het adres van de intarray opslaat, wordt in groen weergegeven.

Ter vergelijking wordt een gewone intvariabele die de waarde opslaat 199in blauw weergegeven.

Dit doet een beetje denken aan het opslaan van strings in het geheugen, vind je niet?

Dat klopt, touwtjes. En net zoals wanneer u met strings werkt, kunt u arrayvariabelen aan elkaar toewijzen:

int[] a = new int[10];
a[2] = 4;
a[7] = 9;
int[] b = a;

a[9] = b[2] + a[7];

Het array-object blijft waar het was en de avariabelen ben slaan hetzelfde adres (referentie) op naar hetzelfde object. Kijk naar de foto:

2. Meer details over het werken met arrays

U kunt een reeks elementen van absoluut elk type maken. Schrijf hiervoor gewoon vierkante haken achter de typenaam. Over het algemeen ziet het maken van een array er als volgt uit:

type[] name = new type[number];

Waar type het type is van de elementen die we in de array zullen opslaan. Naam is de naam van de variabele die we zullen gebruiken om naar de array te verwijzen, en nummer is het aantal cellen in de array.

Het bovenstaande voorbeeld is de canonieke vorm voor het maken van een arrayvariabele en een arrayobject. In werkelijkheid zijn dit twee afzonderlijke entiteiten.

U kunt een array-variabele afzonderlijk van een array-object maken:

type[] name;
name = new type[number];

En nog een punt dat niet onbelangrijk is:

Voorbeelden:

int n = 100;
int[] a = new int[n];

int n = 100;
int[] a = new int[n * 2 + 3];

int n = 100;
int[] a = new int[n];
a[n-1] = 2;
a[n-2] = 3;
a[n/5] = a[n-1] + a[n-2]

// a[99] = 2;
// a[98] = 3;
// a[20] = a[99] + a[98];

3. Array-lengte

Zoals je in het vorige voorbeeld hebt gezien, kun je zelf een arrayvariabele maken en er later ergens in de code een waarde aan toewijzen (een verwijzing naar een arrayobject). Je kunt zelfs dit doen:

int[] array;
if (a < 10)
   array = new int[10];
else
   array = new int[20];

En wat kun je nu nog meer doen met zo'n array? Hoe weet je hoeveel elementen erin zitten?

Om hierbij te helpen hebben arrays een speciale eigenschap (variabele) genaamd length. U kunt de lengte van een array vinden met behulp van deze uitdrukking:

array.length;

Hier arrayis de naam van de arrayvariabele en lengthde naam van de eigenschap van de array. De waarde van de lengtheigenschap kan niet worden gewijzigd: de lengtheigenschap zelf kan aan andere variabelen worden toegewezen, maar er kan niets aan worden toegewezen (als u dit probeert, zal het programma gewoon niet compileren).

We kunnen zo doorgaan met het vorige voorbeeld:

int[] array;
if (a < 10)
   array = new int[10];
else
   array = new int[20];
for (int i = 0; i < array.length; i++)
{
   System.out.println(array[i]);
}

4. Samenvatting van feiten over arrays in Java

Laten we samenvatten wat we weten over arrays:

Feit 1. Een array bestaat uit veel cellen.

Feit 2. U krijgt toegang tot een specifieke cel door het nummer (index) te gebruiken.

Feit 3. Alle cellen zijn van hetzelfde type.

Feit 4. De beginwaarde van alle cellen is 0 (als de cellen getallen opslaan), null(als de cellen objectreferenties opslaan) of false(als de cellen waarden opslaan boolean). In dit hoofdstuk leert u meer over standaardwaarden .

Feit 5. String[] list is slechts de declaratie van een variabele. Hierdoor wordt de container (array-object) zelf niet gemaakt. Om de variabele te gebruiken, moet u eerst een array (container) maken en deze aan de variabele toewijzen. Zie onderstaand voorbeeld.

Feit 6. Wanneer we een array-object (container) maken, moeten we aangeven hoe groot het is, dwz hoeveel cellen het bevat. Dit wordt gedaan met een statement als: new TypeName[n];

Feit 7. De lengte van een array kan worden gevonden met behulp van de .lengtheigenschap.

Feit 8. Nadat u een array hebt gemaakt, kunt u het type elementen of het aantal elementen dat wordt opgeslagen niet meer wijzigen.

String s;
String[] list;

list = new String[10];
int n = list.length;

list = new String[0];

list = null;
System.out.println(list[1]);

list = new String[10];
System.out.println(list[10]);