Arrays in Java: een naslaggids

1. Inleiding

In deze tutorial gaan we dieper in op een kernconcept in de Java-taal - arrays.

We zullen eerst zien wat een array is, en vervolgens hoe we ze kunnen gebruiken; in het algemeen bespreken we hoe u:

  • Ga aan de slag met arrays
  • Lees en schrijf arrays-elementen
  • Loop over een array
  • Transformeer arrays naar andere objecten, zoals Lijst of Streams
  • Sorteer, zoek en combineer arrays

2. Wat is een array?

Allereerst moeten we definiëren wat een array is? Volgens de Java-documentatie is een array een object met een vast aantal waarden van hetzelfde type. De elementen van een array zijn geïndexeerd, wat betekent dat we er toegang toe hebben met getallen (genaamd indices).

We kunnen een array beschouwen als een genummerde lijst met cellen, waarbij elke cel een variabele is met een waarde. In Java begint de nummering bij 0.

Er zijn arrays van het primitieve type en arrays van het objecttype. Dit betekent dat we arrays van int, float, boolean, ... Maar ook arrays van Tekenreeks, Object en aangepaste typen ook.

3. Een array opzetten

Nu de arrays goed zijn gedefinieerd, gaan we eens kijken naar hun gebruik.

We zullen veel onderwerpen behandelen die ons leren hoe we arrays moeten gebruiken. We zullen enkele basisprincipes leren, zoals het declareren en initialiseren van een array, maar we zullen ook meer geavanceerde onderwerpen behandelen, zoals sorteren en zoeken van arrays.

Laten we eerst beginnen met declareren en initialiseren.

3.1. Verklaring

We beginnen met de aangifte. Er zijn twee manieren om een ​​array in Java te declareren:

int [] anArray;

of:

int anOtherArray [];

De eerste wordt op grotere schaal gebruikt dan de laatste.

3.2. Initialisatie

Nu is het tijd om te zien hoe u arrays kunt initialiseren. Ook hier zijn er meerdere manieren om een ​​array te initialiseren. We zullen de belangrijkste hier zien, maar dit artikel behandelt de initialisatie van arrays in detail.

Laten we beginnen met een eenvoudige manier:

int [] anArray = nieuwe int [10];

Door deze methode te gebruiken, hebben we een array van tien geïnitialiseerd int elementen. Merk op dat we de grootte van de array moeten specificeren.

Bij gebruik van deze methode we initialiseren elk element naar zijn standaardwaarde, hier 0. Bij het initialiseren van een array van Voorwerp, elementen zijn nul standaard.

We zullen nu een andere manier zien die ons de mogelijkheid geeft om waarden direct in de array in te stellen bij het maken ervan:

int [] anArray = nieuwe int [] {1, 2, 3, 4, 5};

Hier hebben we een array met vijf elementen geïnitialiseerd die de nummers 1 tot 5 bevat. Bij gebruik van deze methode hoeven we de lengte van de array niet op te geven, het is het aantal elementen dat vervolgens tussen de accolades wordt gedeclareerd.

4. Toegang tot elementen

Laten we nu kijken hoe we toegang kunnen krijgen tot de elementen van een array. We kunnen dit bereiken door een matrixcelpositie te vereisen.

Dit kleine codefragment zal bijvoorbeeld 10 afdrukken naar de console:

anArray [0] = 10; System.out.println (anArray [0]);

Merk op hoe we indices gebruiken om toegang te krijgen tot de matrixcellen. Het getal tussen de haakjes is de specifieke positie van de array die we willen benaderen.

Als bij het openen van een cel de doorgegeven index negatief is of verder gaat dan de laatste cel, zal Java een ArrayIndexOutOfBoundException.

We moeten dan voorzichtig zijn Gebruik geen negatieve index, of een index die groter is dan of gelijk is aan de grootte van de array.

5. Itereren over een array

Elementen een voor een benaderen kan handig zijn, maar we willen misschien een array doorlopen. Laten we eens kijken hoe we dit kunnen bereiken.

De eerste manier is om de voor lus:

int [] anArray = nieuwe int [] {1, 2, 3, 4, 5}; voor (int i = 0; i <anArray.length; i ++) {System.out.println (anArray [i]); }

Dit zou de nummers 1 tot en met 5 naar de console moeten afdrukken. Zoals we kunnen zien hebben we gebruik gemaakt van de lengte eigendom. Dit is een openbare eigenschap die ons de grootte van de array geeft.

Het is natuurlijk mogelijk om andere lusmechanismen te gebruiken, zoals terwijl of doen terwijl. Maar wat betreft Java-verzamelingen, is het mogelijk om arrays te herhalen met behulp van de voor elk lus:

int [] anArray = nieuwe int [] {1, 2, 3, 4, 5}; for (int element: anArray) {System.out.println (element); }

Dit voorbeeld is gelijk aan het vorige, maar we hebben de boilerplate-code van de indices verwijderd. De voor elk loop is een optie wanneer:

  • we hoeven de array niet te wijzigen (door een andere waarde in een element te plaatsen, wordt het element in de array niet gewijzigd)
  • we hebben de indices niet nodig om iets anders te doen

6. Varargs

We hebben de basisprincipes al behandeld als het gaat om het maken en manipuleren van arrays. Nu gaan we dieper in op meer geavanceerde onderwerpen, te beginnen met varargs. Als een herinnering, varargs worden gebruikt om een ​​willekeurig aantal argumenten door te geven aan een methode:

void varargsMethod (String ... varargs) {}

Deze methode kan variëren van 0 tot een willekeurig aantal Draad argumenten. Een artikel over varargs vind je hier.

Wat we hier moeten weten, is dat in het lichaam van de methode een varargs parameter verandert in een array. Maar, we kunnen ook een array direct als argument doorgeven. Laten we eens kijken hoe door de hierboven gedeclareerde voorbeeldmethode te hergebruiken:

String [] anArray = nieuwe String [] {"Melk", "Tomaat", "Chips"}; varargsMethod (anArray);

Gedraagt ​​zich hetzelfde als:

varargsMethod ("Melk", "Tomaat", "Chips");

7. Een array omzetten in een lijst

Arrays zijn geweldig, maar soms kan het handiger zijn om ermee om te gaan Lijst in plaats daarvan. We zullen hier zien hoe u een array omzet in een Lijst.

We zullen het eerst op de naïeve manier doen, door een lege lijst te maken en de array te herhalen om de elementen aan de lijst toe te voegen:

int [] anArray = nieuwe int [] {1, 2, 3, 4, 5}; List aList = nieuwe ArrayList (); for (int element: anArray) {aList.add (element); }

Maar er is een andere manier, een beetje beknopter:

Geheel getal [] anArray = nieuw geheel getal [] {1, 2, 3, 4, 5}; Lijst aList = Arrays.asList (anArray);

De statische methode Arrays.asList duurt een varargs argument en maakt een lijst met de doorgegeven waarden. Helaas heeft deze methode enkele nadelen:

  • Het is niet mogelijk om een ​​reeks primitieve typen te gebruiken
  • We kunnen geen elementen toevoegen aan of verwijderen uit de gemaakte lijst, omdat deze een UnsupportedOperationException

8. Van een array naar een stream

We kunnen nu arrays omzetten in lijsten, maar sinds Java 8 hebben we toegang tot het Stream API en misschien willen we onze arrays veranderen in Stroom. Java biedt ons de Arrays.stream methode daarvoor:

String [] anArray = nieuwe String [] {"Melk", "Tomaat", "Chips"}; Stream aStream = Arrays.stream (anArray);

Bij het passeren van een Voorwerp array naar de methode zal het een Stroom van het overeenkomende type (bijv. Stroom voor een reeks Geheel getal). Bij het passeren van een primitieve zal het de corresponderende primitieve retourneren Stroom.

Het is ook mogelijk om de stream alleen op een subset van de array te maken:

Stream anotherStream = Arrays.stream (anArray, 1, 3);

Dit zal een Stroom met alleen ‘Tomaat’ en ‘Chips’ Snaren (de eerste index is inclusief terwijl de tweede exclusief is).

9. Arrays sorteren

Laten we nu eens kijken hoe we een array moeten sorteren, dat wil zeggen: de elementen in een bepaalde volgorde herschikken. De Arrays class biedt ons de soort methode. Een beetje zoals de stroom methode, soort heeft veel overbelastingen.

Er zijn overbelastingen om te sorteren:

  • Arrays van het primitieve type: die in oplopende volgorde worden gesorteerd
  • Voorwerp arrays (die Voorwerp moet het Vergelijkbaar interface): die zijn gesorteerd volgens de natuurlijke volgorde (afhankelijk van de vergelijk met methode van Vergelijkbaar)
  • Generieke arrays: die zijn gesorteerd op basis van een gegeven Comparator

Bovendien is het mogelijk om alleen een specifiek gedeelte van een array te sorteren (start- en eindindexen doorgeven aan de methode).

De algoritmen achter de soort methode zijn Snel sorteren en samenvoegen sorteren voor primitieve en andere arrays, respectievelijk.

Laten we eens kijken hoe dit allemaal werkt door middel van enkele voorbeelden:

int [] anArray = nieuwe int [] {5, 2, 1, 4, 8}; Arrays.sort (anArray); // anArray is nu {1, 2, 4, 5, 8} Integer [] anotherArray = new Integer [] {5, 2, 1, 4, 8}; Arrays.sort (anotherArray); // anotherArray is nu {1, 2, 4, 5, 8} String [] yetAnotherArray = new String [] {"A", "E", "Z", "B", "C"}; Arrays.sort (yetAnotherArray, 1, 3, Comparator.comparing (String :: toString) .reversed ()); // yetAnotherArray is nu {"A", "Z", "E", "B", "C"}

10. Zoeken in een array

Het doorzoeken van een array is vrij eenvoudig, we kunnen door de array heen lopen en ons element tussen de array-elementen doorzoeken:

int [] anArray = nieuwe int [] {5, 2, 1, 4, 8}; for (int i = 0; i <anArray.length; i ++) {if (anArray [i] == 4) {System.out.println ("Gevonden in index" + i); breken; }}

Hier zochten we naar nummer 4 en vonden het bij index 3.

Als we echter een gesorteerde array hebben, kunnen we een andere oplossing gebruiken: de binaire zoekopdracht. Het principe van binair zoeken wordt in dit artikel uitgelegd.

Gelukkig biedt Java ons de Arrays.binarySearch methode. We moeten het een array en een element geven om te zoeken.

In het geval van een generieke array, moeten we deze ook de Comparator dat werd in de eerste plaats gebruikt om de array te sorteren. Er is weer de mogelijkheid om de methode op een subset van de array aan te roepen.

Laten we een voorbeeld bekijken van het gebruik van de binaire zoekmethode:

int [] anArray = nieuwe int [] {1, 2, 3, 4, 5}; int index = Arrays.binarySearch (anArray, 4); System.out.println ("Gevonden in index" + index);

Omdat we nummer 4 in de vierde cel hebben opgeslagen, geeft dit index 3 als resultaat. Merk op dat we een reeds gesorteerde array hebben gebruikt.

11. Arrays aaneenschakelen

Laten we tot slot kijken hoe we twee arrays kunnen samenvoegen. Het idee is om een ​​array te maken waarvan de lengte de som is van de twee arrays die moeten worden samengevoegd. Daarna moeten we voeg de elementen van de eerste toe en vervolgens de elementen van de tweede:

int [] anArray = nieuwe int [] {5, 2, 1, 4, 8}; int [] anotherArray = new int [] {10, 4, 9, 11, 2}; int [] resultArray = nieuwe int [anArray.length + anotherArray.length]; for (int i = 0; i <resultArray.length; i ++) {resultArray [i] = (i <anArray.length? anArray [i]: anotherArray [i - anArray.length]); }

Zoals we kunnen zien, voegen we elementen uit die array toe als de index nog steeds kleiner is dan de lengte van de eerste array. Vervolgens voegen we elementen uit de tweede toe. We kunnen gebruik maken van de Arrays.setAll methode om het schrijven van een lus te vermijden:

int [] anArray = nieuwe int [] {5, 2, 1, 4, 8}; int [] anotherArray = new int [] {10, 4, 9, 11, 2}; int [] resultArray = nieuwe int [anArray.length + anotherArray.length]; Arrays.setAll (resultArray, i -> (i <anArray.length? AnArray [i]: anotherArray [i - anArray.length]));

Met deze methode worden alle array-elementen ingesteld volgens de opgegeven functie. Deze functie koppelt een index aan een resultaat.

Hier is een derde optie om samen te voegen met arrays: System.arraycopy. Deze methode heeft een bron nodig array, een bronpositie, een bestemming array, een bestemmingspositie en een int het aantal te kopiëren elementen definiëren:

System.arraycopy (anArray, 0, resultArray, 0, anArray.length); System.arraycopy (anotherArray, 0, resultArray, anArray.length, anotherArray.length);

Zoals we kunnen zien, kopiëren we de eerste array en vervolgens de tweede (na het laatste element van de eerste).

12. Conclusie

In dit gedetailleerde artikel hebben we het basisgebruik en enkele geavanceerde toepassingen van arrays in Java behandeld.

We zagen dat Java veel methoden biedt om met arrays om te gaan via het Arrays hulpprogramma klasse. Er zijn ook hulpprogramma-klassen om arrays in bibliotheken zoals Apache Commons of Guava te manipuleren.

De volledige code voor dit artikel is te vinden op onze GitHub.