Flerdimensionelle arrays i Java

1. Oversigt

Et multidimensionelt array i Java er et array, der omfatter arrays i forskellige størrelser som dets elementer. Det kaldes også "en række arrays" eller "ragged array" eller "takket array".

I denne hurtige vejledning ser vi mere dybtgående på at definere og arbejde med flerdimensionelle arrays.

2. Oprettelse af flerdimensionel matrix

Lad os starte med at se på måder, hvorpå vi kan oprette et flerdimensionelt array:

2.1. Kortformen

En nem måde at definere et flerdimensionelt array på ville være:

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

Her har vi erklæret og initialiseret flerdimensionelArr i et enkelt trin.

2.2. Erklæring og derefter initialisering

Vi starter med at erklære en flerdimensionel matrix af størrelse tre:

int [] [] multiDimensionalArr = ny int [3] [];

Her, Vi har udeladt at specificere den anden dimension, da den vil variere.

Lad os derefter gå videre ved både at erklære og initialisere de respektive elementer indeni flerdimensionelArr:

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

Vi kan også blot erklære dets elementer uden at initialisere dem:

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

Disse kan derefter senere initialiseres, f.eks. Ved hjælp af brugerindgange.

Vi kan også bruge java.util.Arrays.fyld metode til at initialisere matrixelementer:

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

Alle elementerne i arrays initialiseres med den samme værdi.

3. Hukommelsesrepræsentation

Hvordan vil hukommelsesrepræsentationen af ​​vores flerdimensionelArr ligner?

Som vi ved, er en matrix i Java intet andet end et objekt, hvis elementer enten kan være primitive eller referencer. Så et todimensionelt array i Java kan betragtes som et array med endimensionelle arrays.

Vores flerdimensionelArr i hukommelsen ligner:

Klart, flerdimensionelArr[0] holder en henvisning til et enkeltdimensionelt array af størrelse 2, multiDimensionalArr [1] har en henvisning til et andet endimensionelt array med størrelse 3 og så videre.

På denne måde gør Java det muligt for os at definere og bruge multidimensionelle arrays.

4. Iterering over elementer

Vi kan gentage et flerdimensionelt array ligesom ethvert andet array i Java.

Lad os prøve at gentage og initialisere flerdimensionelArr elementer, der bruger brugerindgange:

ugyldigt initializeElements (int [] [] multiDimensionalArr) {Scanner sc = ny Scanner (System.in); for (int ydre = 0; ydre <multiDimensionalArr.længde; ydre ++) {for (int indre = 0; indre <multiDimensionalArr [ydre]. længde; indre ++) {multiDimensionalArr [ydre] [indre] = sc.nextInt (); }}}

Her, multiDimensionalArr [ydre] .længde er længden af ​​en matrix ved et indeks ydre i flerdimensionelArr.

Det hjælper os med at sikre, at vi kun søger efter elementer inden for et gyldigt interval for hver undergruppeog derved undgå en ArrayIndexOutOfBoundException.

5. Udskrivningselementer

Hvad hvis vi vil udskrive elementerne i vores flerdimensionale array?

En åbenbar måde ville være at bruge den iterationslogik, vi allerede har dækket. Dette involverer iterering gennem hvert emne i vores flerdimensionale array, som i sig selv er et array, og derefter iterering over det underordnede array - et element ad gangen.

En anden mulighed, vi har, er at bruge java.util.Arrays.toString () hjælper metode:

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

Og vi ender med at have ren og enkel kode. Den genererede konsoloutput ser ud som:

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

6. Elements længde

Vi kan finde længden af ​​arrays i et flerdimensionelt array ved at gentage det over hovedarrayet:

int [] findLengthOfElements (int [] [] multiDimensionalArray) {int [] arrayOfLengths = new int [multiDimensionalArray.length]; for (int i = 0; i <multiDimensionalArray.length; i ++) {arrayOfLengths [i] = multiDimensionalArray [i] .length; } returnere arrayOfLengths; }

Vi kan også finde længden af ​​arrays ved hjælp af Java-streams:

Heltal [] findLengthOfArrays (int [] [] multiDimensionalArray) {return Arrays.stream (multiDimensionalArray) .map (array -> array.length) .toArray (Integer [] :: new); }

7. Kopier et 2-D-array

Vi kan kopiere et 2-D-array ved hjælp af Arrays.copyOf metode:

int [] [] copy2DArray (int [] [] arrayOfArrays) {int [] [] copied2DArray = new int [arrayOfArrays.length] []; for (int i = 0; i <arrayOfArrays.length; i ++) {int [] array = arrayOfArrays [i]; copied2DArray [i] = Arrays.copyOf (array, array.length); } returner kopieret2DArray; }

Vi kan også opnå dette ved hjælp af Java-streams:

Heltal [] [] copy2DArray (Heltal [] [] arrayOfArrays) {return Arrays.stream (arrayOfArrays) .map (array -> Arrays.copyOf (array, array.length)) .toArray (Integer [] [] :: new ); }

8. Konklusion

I denne artikel kiggede vi på, hvad multidimensionelle arrays er, hvordan de ser ud i hukommelsen, og hvordan vi kan definere og bruge dem.

Som altid kan kildekoden til de præsenterede eksempler findes på GitHub.