Arrays in Java

Stel je kasten voor in een opslagruimte. Elk van hen heeft zijn eigen nummer en elk slaat een bagage-object op. Of een wijnkaart waar elke wijnsoort genummerd staat en je bestelt door het nummer van je drankje op te geven. Of een lijst met studenten waarin "Adams" op de eerste plaats staat en "Zimmer" op de laatste plaats. Of een lijst met passagiers in een vliegtuig, die elk een genummerde stoel toegewezen krijgen. In Java worden vaak arrays gebruikt om met dergelijke structuren te werken, dat wil zeggen sets van homogene gegevens.

Wat is een array?

Een array is een gegevensstructuur die elementen van hetzelfde type opslaat. Je kunt het zien als een reeks genummerde cellen. U kunt enkele gegevens in elke cel plaatsen (één gegevenselement per cel). Een specifieke cel is toegankelijk met behulp van zijn nummer. Het nummer van een element in de array wordt ook wel een index genoemd . In Java is een array homogeen, dat wil zeggen dat alle cellen elementen van hetzelfde type bevatten. Een array van gehele getallen bevat dus alleen gehele getallen ( int ), een array van strings — alleen strings, en een array van instanties van een Dog- klasse die we hebben gemaakt, bevat alleen Dog -objecten. Met andere woorden, Java laat ons geen integer in de eerste cel van de array plaatsen, een string in de tweede en een hond in de derde.

Een array declareren

Hoe declareer je een array?

Zoals elke variabele moet een array in Java worden gedeclareerd. Dit kan op twee manieren worden gedaan. Ze zijn gelijkwaardig, maar de eerste manier komt meer overeen met de Java-stijl. De tweede is een erfenis van de C-taal: veel C-programmeurs schakelden over op Java en voor hun gemak werd een alternatieve methode behouden. De tabel toont beide manieren om een ​​array in Java te declareren: In beide gevallen is dataType het type variabelen in de array. In de voorbeelden hebben we twee arrays gedeclareerd. De ene slaat int s op en de andere - Object- objecten. Een array-declaratie heeft dus een naam en type (het type van de elementen van de array). ArrayName is de naam van de array.

Een matrix maken

Hoe maak je een array aan?

Net als elk ander object kunt u een Java-array maken, dwz er een plaats in het geheugen voor reserveren, met behulp van de operator new . Dit is hoe het gedaan is:

new typeOfArray[length]; 

waarbij typeOfArray het type van de array is en length de lengte (dwz het aantal cellen) uitgedrukt als een geheel getal ( int). Maar merk op dat we hier alleen geheugen voor de array hebben toegewezen - we hebben de gedeclareerde array niet gekoppeld aan een eerder gedeclareerde variabele. Gewoonlijk wordt een array eerst gedeclareerd en vervolgens geïnstantieerd, bijvoorbeeld:

int[] myArray; // Array declaration
myArray = new int[10]; // Create (allocate memory for) an array of 10 ints

Hier hebben we een array van gehele getallen gemaakt, myArray genaamd , om de compiler te informeren dat deze uit 10 cellen bestaat (die elk een geheel getal zullen bevatten). Het is echter veel gebruikelijker om de volgende verkorte syntaxis te gebruiken om een ​​array onmiddellijk te maken wanneer deze wordt gedeclareerd:

int[] myArray = new int [10]; // Declare the array and allocate memory "in one blow"

Houd er rekening mee dat:Nadat een array is gemaakt met de nieuwe operator, bevatten de cellen standaardwaarden. Voor numerieke typen (zoals in ons voorbeeld) is de standaardwaarde 0, voor het booleaanse type is deze false en voor referentietypen is deze null . Dus na het uitvoeren van deze verklaring

int[] myArray = new int[10];

we krijgen een array van tien gehele getallen en totdat het programma iets doet om de waarden te veranderen, bevat elke cel 0.

Arraylengte in Java

Zoals we hierboven al zeiden, is de lengte van een array het aantal elementen waarvoor de array is ontworpen. De lengte van een array kan niet worden gewijzigd nadat deze is gemaakt. Houd er rekening mee datdat array-elementen worden genummerd vanaf nul in Java. Dus als we een array van 10 elementen hebben, dan is de index van het eerste element 0 en de index van het laatste 9. Je kunt de arraylengte krijgen met behulp van de lengtevariabele . Bijvoorbeeld:

int[] myArray = new int[10]; // Create an int array for 10 elements and name it myArray
System.out.println(myArray.length); // Display the array's length, i.e. the number of elements we can put into the array

Uitgang:

10

Een array initialiseren en toegang krijgen tot de elementen ervan

Nu weten we hoe we een array in Java kunnen maken. Het proces levert ons geen lege array op, maar een array gevuld met standaardwaarden. Voor een int- array is dit bijvoorbeeld 0, en als we een array van een willekeurig referentietype hebben, is de standaardwaarde in elke cel null . We hebben toegang tot een array-element (bijvoorbeeld om de waarde ervan in te stellen, het op het scherm weer te geven of er een bewerking mee uit te voeren) via de index. Array-initialisatie is het proces van het vullen van een array met specifieke waarden (anders dan de standaardwaarden). Voorbeeld: laten we een stringarray maken voor de 4 seizoenen en deze vullen met de namen van de seizoenen.

String[] seasons = new String[4]; /* Declare and create an array. Java allocates memory for an array of 4 strings, and each cell is set to null (since String is a reference type) */ 

seasons[0] = "Winter"; /* We set the first cell, i.e. the cell with index zero, to "Winter". Here we access the zeroth element of the array and write a specific value to it. */ 
seasons[1] = "Spring"; // We follow a similar procedure for the cell with index 1 (the second cell)
seasons[2] = "Summer"; // ... index 2
seasons[3] = "Autumn"; // and finally, index 3

Nu worden de namen van de seizoenen naar de vier cellen van onze array geschreven. We zouden de array op een andere manier kunnen initialiseren door de declaratie en initialisatie te combineren:

String[] seasons = new String[] {"Winter", "Spring", "Summer", "Autumn"};

Bovendien kan de nieuwe operator worden weggelaten:

String[] seasons = {"Winter", "Spring", "Summer", "Autumn"};

Hoe toon je een array op het scherm in Java?

U kunt array-elementen op het scherm (dwz op de console) weergeven met behulp van een for- lus. Een andere, kortere manier om een ​​array weer te geven wordt besproken in de paragraaf " Handige methoden voor het werken met arrays ". Bekijk in de tussentijd dit voorbeeld waarin een array wordt weergegeven met behulp van een lus:

String[] seasons = new String {"Winter", "Spring", "Summer", "Autumn"}; 
for (int i = 0; i < 4; i++) {
System.out.println(seasons[i]); 
}

Het programma zal het volgende weergeven:

Winter 
Spring 
Summer 
Autumn

Eendimensionale en multidimensionale arrays in Java

Maar wat als we geen reeks getallen, strings of andere objecten willen maken, maar een reeks reeksen? Java laat je dit doen. Het soort array waarmee we al vertrouwd zijn ( int[] myArray = new int[8] ) staat bekend als een eendimensionale array. Maar een array van arrays wordt een tweedimensionale array genoemd. Het is als een tabel met een rijnummer en een kolomnummer. Of, als je de basis van lineaire algebra hebt geleerd, kun je het zien als een matrix. Waarom hebben we zulke arrays nodig? Welnu, om matrices en tabellen te programmeren, evenals andere objecten met een vergelijkbare structuur. Een schaakbord kan bijvoorbeeld worden weergegeven door een 8x8-array. Een multidimensionale array wordt als volgt gedeclareerd en gemaakt:

Int[][] myTwoDimentionalArray = new int[8][8];

Deze array heeft precies 64 elementen: myTwoDimentionalArray[0][0] , myTwoDimentionalArray[0][1] , myTwoDimentionalArray[1][0] , myTwoDimentionalArray[1][1] enzovoort tot myTwoDimentionalArray[7][7] . Dus als we het gebruiken om een ​​schaakbord weer te geven, dan komt A1 overeen met myTwoDimentionalArray[0][0] en komt E2 overeen met myTwoDimentionalArray[4][1] . Maar hoe ver kunnen we dit drijven? In Java kun je een array van arrays specificeren... een array van arrays van arrays, enzovoort. Natuurlijk worden driedimensionale en hogerdimensionale arrays zeer zelden gebruikt. Dat gezegd hebbende, zou je bijvoorbeeld een driedimensionale array kunnen gebruiken om een ​​Rubiks kubus te programmeren.

Handige methoden voor het werken met arrays

Java heeft de klasse java.util.Arrays voor het werken met arrays. Over het algemeen zijn de meest voorkomende bewerkingen die op arrays worden uitgevoerd initialisatie (vullen met elementen), ophalen van een element (op index), sorteren en zoeken. Arrays zoeken en sorteren zijn onderwerpen voor een andere dag. Aan de ene kant is het een goede gewoonte om zelf verschillende zoek- en sorteeralgoritmen te schrijven. Aan de andere kant zijn de beste algoritmen al geïmplementeerd en opgenomen in de standaard Java-bibliotheken, en u kunt ze legaal gebruiken. Hier zijn drie handige methoden in deze klasse.

Een array sorteren

De methode void sort(int[] myArray, int fromIndex, int toIndex) sorteert een integer-array of subarray in oplopende volgorde.

Zoeken naar een element in een array

int binarySearch(int[] myArray, int fromIndex, int toIndex, int key) . Deze methode zoekt naar het sleutelelement in een gesorteerde myArray- array of subarray, van fromIndex tot toIndex . Als het item wordt gevonden, retourneert het zijn index. Anders retourneert het (-fromIndex)-1 .

Een array converteren naar een string

De methode String toString(int[] myArray) converteert een array naar een string. In Java overschrijven arrays toString() niet . Dit betekent dat als u een hele array in één keer probeert weer te geven (System.out.println(myArray)) in plaats van één element tegelijk, zoals in de paragraaf getiteld " Geef een array op het scherm weer ", u de naam van de klasse en de hexadecimale hash van de array (gedefinieerd door Object.toString() ). Als je een beginner bent, begrijp je de uitleg over de toString -methode misschien niet. In eerste instantie hoeft dat niet, maar door deze methode te gebruiken, wordt het gemakkelijker om een ​​array weer te geven. Met Java kunt u eenvoudig een array weergeven zonder een lus te gebruiken. Onderstaand voorbeeld toont dit aan.

Een voorbeeld met sort, binarySearch en toString

Laten we een reeks gehele getallen maken, deze weergeven met toString , sorteren met behulp van de sorteermethode en er dan een getal in vinden.

class Main {
    public static void main(String[] args) {
        int[] array = {1, 5, 4, 3, 7}; // Declare and initialize the array
        System.out.println(array); // Try to display our array without using the toString method — the result is a hexadecimal number
        System.out.println(Arrays.toString(array)); // Display the array correctly 
        Arrays.sort(array, 0, 4); // Sort the entire array from the zeroth to the fourth element
        System.out.println(Arrays.toString(array)); // Display the sorted array
        int key = Arrays.binarySearch(array, 5); // Look for the number 5 in the sorted array. 
        // The binarySearch method will return the index of the array element we are searching for
        System.out.println(key); // Display the index of the number we searched for 
System.out.println(Arrays.binarySearch(array, 0)); // Now try to find a number that isn't in the array, 
        // and immediately display the result

    }
}

Uitgang:

[I@1540e19d 
[1, 5, 4, 3, 7] 
[1, 3, 4, 5, 7] 
3 
-1

De eerste string is een poging om de array weer te geven zonder toString te gebruiken . De tweede is de array die wordt weergegeven met toString . De derde is de gesorteerde array. De vierde is de index van het getal waarnaar we zochten (5) in de gesorteerde array (onthoud dat we vanaf nul tellen, dus de index van het vierde element van de array is 3). In de vijfde snaar zien we -1. Dit is een ongeldige array-index. Het geeft aan dat het nummer waarnaar we zochten (in dit geval 0) niet in de array staat.

Array in een notendop

• Essentiële kenmerken van een array: het type gegevens dat erin is geplaatst, de naam en de lengte.
  De laatste eigenschap wordt bepaald wanneer de array wordt gemaakt (wanneer er geheugen voor de array wordt toegewezen). De eerste twee eigenschappen worden bepaald wanneer de array wordt gedeclareerd.

• De matrixgrootte (aantal cellen) moet een geheel getal zijn

• Het is onmogelijk om de lengte van een array te wijzigen nadat deze is gemaakt.

• Een array-element is toegankelijk via zijn index.

• Elementen in arrays worden, net als al het andere in Java, genummerd vanaf nul.

• Nadat een array is gemaakt, wordt deze gevuld met standaardwaarden.

• Arrays in Java zijn niet hetzelfde als arrays in C++. Ze zijn bijna als verwijzingen naar dynamische arrays.

Nuttig materiaal over arrays

Meer weten over arrays? Bekijk de onderstaande artikelen. Er is veel interessant en nuttig materiaal over dit onderwerp.