Mehrdimensionale Arrays in Java

1. Übersicht

Ein mehrdimensionales Array in Java ist ein Array, das Arrays unterschiedlicher Größe als Elemente umfasst. Es wird auch als "Array von Arrays" oder "zerlumptes Array" oder "gezacktes Array" bezeichnet.

In diesem kurzen Tutorial werden wir uns eingehender mit der Definition und Arbeit mit mehrdimensionalen Arrays befassen.

2. Erstellen eines mehrdimensionalen Arrays

Lassen Sie uns zunächst untersuchen, wie wir ein mehrdimensionales Array erstellen können:

2.1. Die Kurzform

Eine einfache Möglichkeit, ein mehrdimensionales Array zu definieren, wäre:

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

Hier haben wir multiDimensionalArr in einem einzigen Schritt deklariert und initialisiert .

2.2. Deklaration und dann Initialisierung

Wir beginnen mit der Deklaration eines mehrdimensionalen Arrays der Größe drei:

int[][] multiDimensionalArr = new int[3][];

Hier haben wir die Angabe der zweiten Dimension weggelassen, da diese variieren wird .

Als nächstes gehen wir weiter, indem wir die jeweiligen Elemente in multiDimensionalArr deklarieren und initialisieren :

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

Wir können seine Elemente auch einfach deklarieren, ohne sie zu initialisieren:

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

Diese können später beispielsweise mithilfe von Benutzereingaben initialisiert werden.

Wir können auch die Methode java.util.Arrays.fill verwenden, um Array-Elemente zu initialisieren:

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

Alle Elemente in den Arrays werden mit demselben Wert initialisiert.

3. Speicherdarstellung

Wie sieht die Speicherdarstellung unseres multiDimensionalArr aus?

Wie wir wissen, ist ein Array in Java nichts anderes als ein Objekt, dessen Elemente entweder Grundelemente oder Referenzen sein können. Ein zweidimensionales Array in Java kann also als Array eindimensionaler Arrays betrachtet werden.

Unser multiDimensionalArr im Speicher würde ähnlich aussehen wie:

Es ist klar, dass multiDimensionalArr [0] eine Referenz auf ein eindimensionales Array der Größe 2 enthält, multiDimensionalArr [1] eine Referenz auf ein anderes eindimensionales Array der Größe 3 und so weiter.

Auf diese Weise können wir mit Java mehrdimensionale Arrays definieren und verwenden.

4. Iterieren über Elemente

Wir können ein mehrdimensionales Array wie jedes andere Array in Java iterieren.

Versuchen wir, die multiDimensionalArr- Elemente mithilfe von Benutzereingaben zu iterieren und zu initialisieren :

void initializeElements(int[][] multiDimensionalArr) { Scanner sc = new 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 ist multiDimensionalArr [äußere] Länge die Länge eines Arrays an einem äußeren Index in multiDimensionalArr .

Dies hilft uns sicherzustellen, dass wir nur innerhalb eines gültigen Bereichs jedes Unterarrays nach Elementen suchen , wodurch eine ArrayIndexOutOfBoundException vermieden wird .

5. Drucken von Elementen

Was ist, wenn wir die Elemente unseres mehrdimensionalen Arrays drucken möchten?

Ein naheliegender Weg wäre die Verwendung der Iterationslogik, die wir bereits behandelt haben. Dies beinhaltet das Durchlaufen jedes Elements in unserem mehrdimensionalen Array, das selbst ein Array ist, und das anschließende Durchlaufen dieses untergeordneten Arrays - jeweils ein Element.

Eine weitere Option ist die Verwendung der Hilfsmethode java.util.Arrays.toString () :

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

Und am Ende haben wir sauberen und einfachen Code. Die generierte Konsolenausgabe würde folgendermaßen aussehen:

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

6. Länge der Elemente

Wir können die Länge der Arrays in einem mehrdimensionalen Array ermitteln, indem wir über das Hauptarray iterieren:

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

Wir können die Länge von Arrays auch mithilfe von Java-Streams ermitteln:

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

7. Kopieren Sie ein 2D-Array

Wir können ein 2D -Array mit der Methode Arrays.copyOf kopieren :

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); } return copied2DArray; }

Dies können wir auch mithilfe von Java-Streams erreichen:

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

8. Fazit

In diesem Artikel haben wir uns angesehen, was mehrdimensionale Arrays sind, wie sie im Speicher aussehen und wie wir sie definieren und verwenden können.

Der Quellcode der vorgestellten Beispiele ist wie immer auf GitHub zu finden.