Multidimensionale arrays in Java

1. Overzicht

Een meerdimensionale array in Java is een array die arrays van verschillende grootten als elementen omvat. Het wordt ook wel "een array van arrays" of "ragged array" of "jagged array" genoemd.

In deze korte tutorial gaan we dieper in op het definiëren van en werken met multidimensionale arrays.

2. Creëren van een multidimensionale array

Laten we beginnen met kijken naar manieren waarop we een multidimensionale array kunnen maken:

2.1. De steno-vorm

Een gemakkelijke manier om een ​​multidimensionale array te definiëren is:

int [] [] multiDimensionalArr = {{1, 2}, {3, 4, 5}, {6, 7, 8, 9}};

Hier hebben we verklaard en geïnitialiseerd multiDimensionalArr in een enkele stap.

2.2. Verklaring en vervolgens initialisatie

We beginnen met het declareren van een multidimensionale array van grootte drie:

int [] [] multiDimensionalArr = nieuwe int [3] [];

Hier, we hebben de tweede dimensie weggelaten omdat deze zal variëren.

Laten we vervolgens verder gaan door zowel de respectievelijke elementen binnenin te declareren als te initialiseren multiDimensionalArr:

multiDimensionalArr [0] = nieuwe int [] {1, 2}; multiDimensionalArr [1] = nieuwe int [] {3, 4, 5}; multiDimensionalArr [2] = nieuwe int [] {6, 7, 8, 9};

We kunnen ook eenvoudig de elementen declareren zonder ze te initialiseren:

multiDimensionalArr [0] = nieuwe int [2]; multiDimensionalArr [1] = nieuwe int [3]; multiDimensionalArr [2] = nieuwe int [4];

Deze kunnen later worden geïnitialiseerd, bijvoorbeeld door gebruikersinvoer te gebruiken.

We kunnen ook de java.util.Arrays.fill methode om array-elementen te initialiseren:

void initialize2DArray (int [] [] multiDimensionalArray) {voor (int [] array: multiDimensionalArray) {Arrays.fill (array, 7); }} 

Alle elementen in de arrays worden met dezelfde waarde geïnitialiseerd.

3. Geheugenvertegenwoordiging

Hoe zal het geheugen representeren van onze multiDimensionalArr ziet eruit als?

Zoals we weten, is een array in Java niets anders dan een object, waarvan de elementen primitieven of verwijzingen kunnen zijn. Een tweedimensionale array in Java kan dus worden gezien als een array van eendimensionale arrays.

Onze multiDimensionalArr in het geheugen zou er ongeveer zo uitzien:

Duidelijk, multiDimensionalArr[0] bevat een verwijzing naar een eendimensionale reeks van grootte 2, multiDimensionalArr [1] bevat een verwijzing naar een andere eendimensionale reeks van grootte 3 enzovoort.

Op deze manier maakt Java het ons mogelijk om multidimensionale arrays te definiëren en te gebruiken.

4. Itereren over elementen

We kunnen een meerdimensionale array herhalen zoals elke andere array in Java.

Laten we proberen het multiDimensionalArr elementen die gebruikersinvoer gebruiken:

void initializeElements (int [] [] multiDimensionalArr) {Scanner sc = nieuwe scanner (System.in); for (int outer = 0; outer <multiDimensionalArr.length; outer ++) {for (int inner = 0; inner <multiDimensionalArr [outer] .length; inner ++) {multiDimensionalArr [outer] [inner] = sc.nextInt (); }}}

Hier, multiDimensionalArr [buitenste] .length is de lengte van een array bij een index buitenste in multiDimensionalArr.

Het helpt ons ervoor te zorgen dat we alleen naar elementen zoeken binnen een geldig bereik van elke subarray, waardoor een ArrayIndexOutOfBoundException.

5. Afdrukelementen

Wat als we de elementen van onze multidimensionale array willen afdrukken?

Een voor de hand liggende manier zou zijn om de iteratielogica te gebruiken die we al hebben behandeld. Dit omvat het doorlopen van elk item binnen onze multidimensionale array, die zelf een array is, en vervolgens itereren over die onderliggende array - één element tegelijk.

Een andere optie die we hebben is om te gebruiken java.util.Arrays.toString () helper methode:

void printElements (int [] [] multiDimensionalArr) {for (int index = 0; index <multiDimensionalArr.length; index ++) {System.out.println (Arrays.toString (multiDimensionalArr [index])); }}

En we hebben uiteindelijk schone en eenvoudige code. De gegenereerde console-uitvoer zou er als volgt uitzien:

[1, 2] [3, 4, 5] [6, 7, 8, 9]

6. Lengte van elementen

We kunnen de lengte van de arrays in een multidimensionale array vinden door de hoofdarray te herhalen:

int [] findLengthOfElements (int [] [] multiDimensionalArray) {int [] arrayOfLengths = nieuwe int [multiDimensionalArray.length]; voor (int i = 0; i <multiDimensionalArray.length; i ++) {arrayOfLengths [i] = multiDimensionalArray [i] .length; } return arrayOfLengths; }

We kunnen ook de lengte van arrays vinden met behulp van Java-streams:

Geheel getal [] findLengthOfArrays (int [] [] multiDimensionalArray) {return Arrays.stream (multiDimensionalArray) .map (array -> array.length) .toArray (geheel getal [] :: nieuw); }

7. Kopieer een 2D-array

We kunnen een 2D-array kopiëren met behulp van de Arrays.copyOf methode:

int [] [] copy2DArray (int [] [] arrayOfArrays) {int [] [] copied2DArray = nieuwe int [arrayOfArrays.length] []; voor (int i = 0; i <arrayOfArrays.length; i ++) {int [] array = arrayOfArrays [i]; copied2DArray [i] = Arrays.copyOf (array, array.length); } return copied2DArray; }

We kunnen dit ook bereiken door Java-streams te gebruiken:

Geheel getal [] [] copy2DArray (Geheel getal [] [] arrayOfArrays) {return Arrays.stream (arrayOfArrays) .map (array -> Arrays.copyOf (array, array.length)) .toArray (geheel getal [] [] :: nieuw ); }

8. Conclusie

In dit artikel hebben we gekeken naar wat multidimensionale arrays zijn, hoe ze eruitzien in het geheugen en de manieren waarop we ze kunnen definiëren en gebruiken.

Zoals altijd is de broncode van de gepresenteerde voorbeelden te vinden op GitHub.