Mehrdimensionale Arrays

• Mehrdimensionale Arrays, allgemeine Syntax
• Zweidimensionale Arrays
• Deklarieren, Erstellen und Initialisieren zweidimensionaler Arrays
• Anzeige eines zweidimensionalen Arrays auf dem Bildschirm
• Schnelle Ausgabe eines zweidimensionalen Arrays
• „Längen“ eines zweidimensionalen Arrays
• Beispiel für die Verwendung eines zweidimensionalen Arrays: Schachbrett
• Beispiel für die Verwendung eines zweidimensionalen Arrays: Matrixmultiplikation
• Nicht rechteckige zweidimensionale Arrays
• Dreidimensionale Arrays
• Mehrdimensionale Arrays in der echten Arbeit eines Java-Programmierers
• Interessante Probleme auf zweidimensionalen und dreidimensionalen Arrays

Was ist ein eindimensionales Java-Array?

Ein Array ist eine geordnete Menge von Elementen desselben Typs, Grundelements oder derselben Referenz. Allgemeine Informationen zu Arrays (meist eindimensional) finden Sie im Artikel „ Arrays in Java “ und im JavaRush- Kurs . In diesem Artikel werden wir über Arrays sprechen, deren Elemente andere Arrays sind. Solche Arrays werden als mehrdimensional bezeichnet. Ein Array, dessen Elemente andere Arrays sind, also ein Array von Arrays, wird als zweidimensional bezeichnet. Nicht alle Sprachen verfügen über mehrdimensionale Arrays, die auf diese Weise strukturiert sind, aber in Java ist dies der Fall.

Mehrdimensionale Java-Arrays, allgemeine Syntax

Im Allgemeinen sehen mehrdimensionale Arrays in Java so aus:

Data_type[dimension1][dimension2][]..[dimensionN] array_name = new data_type[size1][size2]….[sizeN];

Wo Data_typeist der Typ der Elemente im Array? Kann primitiv oder referenzierend (Klasse) sein. Die Anzahl der Klammerpaare im dimensionInneren ist die Dimension des Arrays (in unserem Fall - N). array_name– Array-Name size1...sizN– Anzahl der Elemente in jeder Dimension des Arrays. Mehrdimensionale Arrays deklarieren:

int[][] twoDimArray; //zweidimensionales Array
String[][][] threeDimArray; //dreidimensionales Array
double[][][][][] fiveDimArray; // fünfdimensionales Array

Vielleicht sieht das alles sehr abstrakt aus, also kommen wir nun zu den konkreten Erscheinungsformen mehrdimensionaler Arrays – zweidimensional und dreidimensional. Tatsache ist, dass Java-Entwickler manchmal zweidimensionale Arrays verwenden, viel seltener – dreidimensionale, und noch größere Arrays sind äußerst selten. Es besteht eine hohe Wahrscheinlichkeit, dass Sie ihnen nicht begegnen.

Was ist ein zweidimensionales Java-Array?

Ein zweidimensionales Array in Java ist ein Array von Arrays, das heißt, jede Zelle enthält einen Verweis auf ein Array. Es ist jedoch viel einfacher, es in Form einer Tabelle darzustellen, die eine bestimmte Anzahl von Zeilen (erste Dimension) und eine bestimmte Anzahl von Spalten (zweite Dimension) aufweist. Ein zweidimensionales Array, in dem alle Zeilen die gleiche Anzahl von Elementen haben, wird als rechteckig bezeichnet.

Deklarieren, Erstellen und Initialisieren zweidimensionaler Arrays

Das Verfahren zum Deklarieren und Erstellen eines zweidimensionalen Arrays ist fast das gleiche wie im Fall eines eindimensionalen:

int[][] twoDimArray = new int[3][4];

Dieses Array besteht aus 3 Zeilen und 4 Spalten. Die Größe eines rechteckigen zweidimensionalen Arrays (es darf nicht rechteckig sein, mehr dazu weiter unten), also die Gesamtzahl der Elemente, kann durch Multiplikation der Anzahl der Zeilen mit der Anzahl der Spalten bestimmt werden. Es ist nun mit Standardwerten initialisiert (gefüllt). Das heißt, Nullen. Füllen wir es mit den Werten, die wir brauchen.

twoDimArray[0][0] = 5;//Schreibe den Wert 5 in die Zelle am Schnittpunkt der Nullzeile und Nullspalte
twoDimArray[0][1] = 7; //schreibe den Wert 7 in die Zelle am Schnittpunkt der Nullzeile und der ersten Spalte
twoDimArray[0][2]  = 3;
twoDimArray[0][3] = 17;
twoDimArray[1][0] = 7;
twoDimArray[1][1] = 0;
twoDimArray[1][2] = 1;
twoDimArray[1][3] = 12;
twoDimArray[2][0] = 8;
twoDimArray[2][1] = 1;
twoDimArray[2][2] = 2;
twoDimArray[2][3] = 3;

Wie bei eindimensionalen Arrays können Sie den Initialisierungsvorgang schneller durchführen:

int [][] twoDimArray = {{5,7,3,17}, {7,0,1,12}, {8,1,2,3}};

In beiden Fällen erhalten wir ein zweidimensionales Array mit drei Zeilen und vier Spalten, gefüllt mit ganzen Zahlen.

Anzeige eines zweidimensionalen Arrays auf dem Bildschirm

Der logischste Weg, diese Operation durchzuführen, besteht darin, zuerst die Nulllinie Element für Element auszugeben, dann die zweite und so weiter. Die gebräuchlichste Methode zur Ausgabe eines zweidimensionalen Arrays in Java ist die Verwendung von zwei verschachtelten Schleifen.

int [][] twoDimArray = {{5,7,3,17}, {7,0,1,12}, {8,1,2,3}};//ein Array deklariert und mit Elementen gefüllt
for (int i = 0; i < 3; i++) {  //Gehe die Zeilen durch
            for (int j = 0; j < 4; j++) {//die Spalten durchgehen
                System.out.print(" " + twoDimArray[i][j] + " "); //Ausgabeelement
            }
            System.out.println();// Zeilenumbruch zur visuellen Erhaltung der Tabellenform
        }

Schnelle Ausgabe eines zweidimensionalen Arrays

Der kürzeste Weg, eine Liste von Elementen eines zweidimensionalen Arrays auf dem Bildschirm anzuzeigen, ist die Verwendung der deepToStringKlassenmethode Arrays. Beispiel:

int[][] myArray = {{18,28,18},{28,45,90},{45,3,14}};
System.out.printLn(Arrays.deepToString(myArray));

Das Ergebnis des Programms ist die folgende Ausgabe: [[18, 28, 18], [28, 45, 90], [45, 3, 14]]

„Längen“ eines zweidimensionalen Arrays

Um die Länge eines eindimensionalen Arrays (d. h. die Anzahl der darin enthaltenen Elemente) zu ermitteln, können Sie die Variable verwenden length. Das heißt, wenn wir ein Array definieren int a[] = {1,2,3}, gibt die Operation a.length3 zurück. Was aber, wenn wir dasselbe Verfahren auf unser zweidimensionales Array anwenden?

int [][] twoDimArray = {{5,7,3,17}, {7,0,1,12}, {8,1,2,3}};
System.out.println(twoDimArray.length);

Ausgabe: 3 Diese Operation gibt also die Anzahl der Zeilen im Array aus. Wie erhalte ich die Anzahl der Spalten? Wenn es sich um rechteckige zweidimensionale Arrays handelt (d. h. solche, bei denen alle Linien gleich lang sind), können wir twoDimArray[0].lengthanstelle des Nullelements (im Wesentlichen der Nulllinie) die Operation oder jedes andere vorhandene Element anwenden. Wir können dies tun, weil in Java ein zweidimensionales Array ein Array von Arrays ist und Element Null twoDimArray[0]ein Array der Länge 4 ist. Sie können dies selbst überprüfen.

Beispiel für die Verwendung eines zweidimensionalen Arrays: Schachbrett

Zweidimensionale Arrays können verwendet werden, um jedes endliche zweidimensionale Feld zu erstellen, beispielsweise in Spielen und insbesondere im Schach. Man kann sich ein Schachbrett leicht als zweidimensionale Anordnung vorstellen. Daran können Sie Grafiken „anhängen“, aber zunächst definieren wir ein Schachbrett mithilfe von Symbolen und geben es auf der Konsole aus. Das untere linke Quadrat des Schachbretts ist schwarz gestrichen, das nächste ist weiß, ebenso das darüber liegende. Die Farbe ändert sich also jedes Mal, wenn Sie zu einer Zelle neben der Seite wechseln. Um die Schachfarbe nicht manuell, sondern mithilfe eines Algorithmus festzulegen, können Sie eine Paritätsprüfung verwenden: Wenn die Summe aus Zeilen- und Spaltenindex gerade oder Null ist, ist die Zelle weiß, andernfalls ist sie schwarz. Für diese Prüfung verwenden wir im Algorithmus den Restoperator %. Da wir nicht mit Grafiken, sondern mit Symbolen arbeiten, bezeichnen wir die weiße Zelle mit dem Buchstaben W(weiß) und die schwarze Zelle mit dem Buchstaben B(schwarz).

//Setze das Schachbrett als zweidimensionales Array
String [][] chessBoard = new String[8][8];
        for (int i = 0; i< chessBoard.length; i++) {
            for (int j = 0; j < chessBoard[0].length; j++) {
                if ((i + j) % 2 == 0) chessBoard[i][j] = "W";
                else chessBoard[i][j] = "B";
            }
        }

Die Ausgabe des Programms ist wie folgt: WBWBWBWBBWBWBWBWWBWBW BWBBWBWBWBWWBWBWBWBBW BWBWBWWBWBWBWBBWBWBWB W Alles ist wie auf einem echten Schachbrett, Sie können es überprüfen. Schreiben wir nun eine Methode zur korrekten Nummerierung von Zellen, nicht in der Array-Sprache, sondern in der „Schach“-Sprache. Die untere linke Zelle auf der Platine heißt A1, während sie in unserem Array chessBoard[7][0]. Ordnen wir jedes Indexpaar eines zweidimensionalen Arrays seinem „Schach“-Äquivalent zu. Dazu verwenden wir zwei Zeilen – „ abcdefgh“ und „ 87654321“ (in umgekehrter Reihenfolge – der Einfachheit halber, sodass das Schachbrett 8 der Nullspalte entspricht).

public static String chessBoardCoord(int a, int b) {
            String letters = "abcdefgh";
            String numbers = "87654321";
            if ((a > 7)|| (b>7)) return null; //Wenn die Zahl außerhalb der Tafel liegt, wird der Standardwert null zurückgegeben
            else return (Character.toString(letters.charAt(a)) + numbers.charAt(b)); /*charAt – eine Methode, mit der wir aus dem String das Element unter der übergebenen Nummer extrahieren, hier – unter den Nummern a und b. Character.toString – eine Methode, die das empfangene Zeichen in einen String umwandelt */
        }

Lassen Sie uns nun mit der Methode in jeder Zelle nicht nur ihre Farbe, sondern auch ihre Nummer anzeigenchessBoardCoord

String [][] chessBoard = new String[8][8];
        for (int i = 0; i < chessBoard.length; i++) {
            for (int j = 0; j < chessBoard[0].length; j++) {
                if ((i + j) % 2 == 0) chessBoard[i][j] = "W" + chessBoardCoord(j,i);
                else chessBoard[i][j] = "B"+ chessBoardCoord(j,i);
            }
        }

            for (int i = 0; i < chessBoard.length; i++) {
                for (int j = 0; j < chessBoard[0].length; j++) {
                    System.out.print(" " + chessBoard[i][j] + " ");
                }
                System.out.println();
            }

Programmausgabe: Wa8 Bb8 Wc8 Bd8 We8 Bf8 Wg8 Bh8 Ba7 Wb7 Bc7 Wd7 Be7 Wf7 Lg7 Wh7 Wa6 Bb6 Wc6 Bd6 We6 Bf6 Wg6 Bh6 Ba5 Wb5 Bc5 Wd5 Be5 Wf5 Lg5 Wh5 Wa4 Bb4 Wc4 Bd4 We4 Lf4 Wg4 Bh4 Ba3 Wb3 Bc3 Wd 3 Be3 Wf3 Lg3 Wh3 Wa2 Bb2 Wc2 Bd2 We2 Bf2 Wg2 Bh2 Ba1 Wb1 Bc1 Wd1 Le1 Wf1 Lg1 Wh1 Wobei We2das weiße Feld mit der Nummer e2 gemeint ist.

Beispiel für die Verwendung eines zweidimensionalen Arrays: Matrixmultiplikation

Aufmerksamkeit!Dieses Beispiel erfordert Grundkenntnisse über Matrizen. Hier wird sehr wenig über sie gesagt, und diese Informationen sind für diejenigen gedacht, die sich mit Matrixarithmetik beschäftigt haben, diese aber etwas vergessen haben. Dieses Wissen kann jedoch aus offenen Quellen gewonnen werden, insbesondere aus einem Artikel auf Wikipedia . Dies ist ein gutes Beispiel für die Verwendung zweidimensionaler Arrays, aber wir können auch ohne weitermachen. Wenn es Ihnen jetzt also aus mathematischer Sicht unverständlich erscheint und Sie sich nicht wirklich damit befassen möchten, können Sie das Beispiel gerne überspringen. Wenn Sie grundlegende lineare Algebra studiert haben, haben Sie möglicherweise etwas über rechteckige Arrays als rechteckige Matrizen gelernt. Wobei a11, a12... aNN einige Zahlen sind. In der Abbildung ist die Matrix nicht einmal rechteckig, sondern quadratisch (die Anzahl der Zeilen ist gleich der Anzahl der Spalten, dies ist jedoch nicht immer der Fall). Im wirklichen Leben trifft man solche Matrizen selten an, in der Programmierung und Informatik sind sie jedoch weit verbreitet. Sie werden insbesondere in Computergrafiken und Spiele-Engines eingesetzt. Beispielsweise kann die Drehung eines Objekts auf dem Bildschirm um einen beliebigen Winkel mithilfe einer Rotationsmatrix programmiert werden. Im zweidimensionalen Raum sieht die Rotationsmatrix folgendermaßen aus: Wobei Theta der Winkel ist, um den das Objekt gedreht werden muss. Matrizen gleicher Dimensionen können einander addiert werden, und die Addition erfolgt Element für Element (wir addieren Elemente mit den gleichen Indizes). Die Funktionsweise der Matrixmultiplikation ist jedoch weniger bekannt. Somit können Matrizen nur dann multipliziert und eine resultierende Matrix erhalten werden, wenn die Anzahl der Spalten der ersten Matrix mit der Anzahl der Zeilen der zweiten übereinstimmt. Die Ergebnismatrix hat die gleiche Anzahl an Zeilen wie die erste und die gleiche Anzahl an Spalten wie die zweite. Die Multiplikation wird wie folgt durchgeführt. Lassen Sie uns eine Matrix haben a[l][m]und b[m][n]. Als Ergebnis ihrer Multiplikation sollten wir eine Matrix erhalten c[l][n]. Um ein Element c[0][0]einer Produktmatrix zu erhalten, müssen Sie a[0][0]das Nullelement der Nullzeile der ersten Matrix mit dem Nullelement der zweiten Matrix multiplizieren und dann das erste Element der ersten Zeile der ersten Matrix mit dem ersten Element multiplizieren der ersten Spalte der zweiten Matrix usw., wonach alle resultierenden Produkte addiert werden.

a[0][0]*b[0][0] + a[0][1]*b[1][0] + … + a[0][m-1]*b[m-1][0]

Um das zweite Element der ersten Zeile der Ergebnismatrix zu erhalten, führen wir den gleichen Vorgang mit der zweiten Zeile durch

a[1][0]*b[0][0] + a[1][1]*b[0][1] + … + a[0][m-1]*b[m-1][0]

Und so weiter bis zum Ende der Zeile. Dann gehen wir zur nächsten Zeile über und wiederholen den Vorgang, bis uns die Zeilen ausgehen. Das heißt, wir multiplizieren die Zeilen der ersten Matrix mit den Spalten der zweiten Matrix. Unten finden Sie den Code für die Matrixmultiplikation. Sie können es durch eine Überprüfung der Einhaltung der oben genannten Bedingung zur Anzahl der Zeilen und Spalten ergänzen.

//zwei Matrizen deklarieren
int [][] twoDimArray1 = {{1,0,0,0},{0,1,0,0},{0,0,0,0}};
int[][] twoDimArray2 = {{1,2,3},{1,1,1},{0,0,0},{2,1,0}};

//Matrixmultiplikationsprozess
int[][]twoDimArray3 = new int [twoDimArray1.length][twoDimArray2[0].length];
        for (int i=0; i<twoDimArray3[0].length; i++)
            for (int j=0; j<twoDimArray3.length; j++)
                for (int k=0; k<twoDimArray1[0].length; k++)
                              twoDimArray3[i][j] = twoDimArray3[i][j] + twoDimArray1[i][k] * twoDimArray2[k][j];

//Ausgabe auf dem Display
        for (int i = 0; i < twoDimArray3.length; i++) {
            for (int j = 0; j < twoDimArray3[0].length; j++) {
                System.out.print(" " + twoDimArray3[i][j] + " ");
            }
            System.out.println();
        }

Das Programm gibt das folgende Ergebnis aus: 1 2 3 1 1 1 0 0 0

Nicht rechteckige zweidimensionale Arrays

Da zweidimensionale Arrays in Java Arrays von Arrays sind, kann jedes der inneren Arrays eine unterschiedliche Länge haben. Beim Erstellen eines Arrays können wir nur die Anzahl der Zeilen und nicht die Anzahl der Spalten angeben (also tatsächlich die Länge dieser Zeilen). Schauen wir uns ein Beispiel an.

//Deklarieren und Erstellen eines Arrays, wobei nur die Anzahl der Zeilen angegeben wird
int [][] twoDimArray = new int[5][];

//initialisiere das Array und fülle es mit Arrays unterschiedlicher Länge
        twoDimArray[0] = new int[]{1, 2, 3, 4, 5};
        twoDimArray[1] = new int[]{1,2,3,4};
        twoDimArray[2] = new int[]{1,2,3};
        twoDimArray[3] = new int[]{1,2};
        twoDimArray[4] = new int[]{1};
//zeige das resultierende nicht-rechteckige zweidimensionale Array auf dem Bildschirm an
        for (int i = 0; i < twoDimArray.length; i++) {
            for (int j = 0; j < twoDimArray[i].length; j++) {
                System.out.print(" " + twoDimArray[i][j] + " ");
            }
            System.out.println();
        }

Programmausgabe: 1 2 3 4 5 1 2 3 4 1 2 3 1 2 1 Somit enthält die nullte Zeile unseres Arrays das Array {1,2,3,4,5}und die vierte Zeile das Array {1}.

Dreidimensionale Arrays in Java

Dem gesunden Menschenverstand und der Logik der Java-Sprache folgend kann ein dreidimensionales Array als „Array von Arrays von Arrays“ oder „ein Array, dessen jedes Element ein zweidimensionales Array ist“ bezeichnet werden. Darüber hinaus können diese zweidimensionalen Arrays unterschiedlich sein. Beispiel:

// ein dreidimensionales Array erstellen, das aus zwei zweidimensionalen Arrays besteht
int[][][] threeDimArr = new int[2][][];
//Erstelle das erste 2D-Array eines 5x2 3D-Arrays
        threeDimArr[0] = new int[5][2];
//Erstelle ein zweites 2D-Array eines 1x1 3D-Arrays
        threeDimArr[1] = new int[1][1];

In der Praxis gibt es jedoch häufiger dreidimensionale Arrays, in denen alle drei Größen gleichzeitig definiert sind, ein Analogon zu rechteckigen zweidimensionalen Arrays. Wie bereits erwähnt, werden dreidimensionale oder mehrdimensionale Arrays sehr selten verwendet. Mit einem 3D-Array können Sie jedoch etwas Interessantes programmieren. Zum Beispiel ein Parkhaus. Jede Etage kann als zweidimensionale Anordnung betrachtet werden, und ein Parkplatz kann als spezifisches Element einer dreidimensionalen Anordnung betrachtet werden. Ein Element eines solchen Arrays kann durch einen Typ booleanmit dem Wert false dargestellt werden, wenn der Platz frei ist, und true, wenn der Platz belegt ist.

//setze ein boolesches dreidimensionales Array. Dieses Parkhaus verfügt über 3 Etagen, die jeweils Platz für 2x5 = 10 Autos bieten. Standardmäßig sind alle Zellen leer (falsch)
boolean[][][] parkingLot = new boolean[3][2][5];
//zwei Autos kamen an und parkten im Erdgeschoss in den Zellen [1][0] und [1][3]
        parkingLot[0][1][0] = true;
        parkingLot[0][1][3] = true;

//Das Array an die Konsole ausgeben
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 2; j++) {
                for (int k = 0; k < 5; k++) {
                    System.out.print("arr[" + i + "][" + j + "][" + k + "] = " + parkingLot[i][j][k] + "\t");

                }
                System.out.println();
            }
        }

Interessante Probleme auf zweidimensionalen und dreidimensionalen Arrays

Sie wissen genug über mehrdimensionale Arrays in Java und können, wenn Sie sich sicher fühlen, versuchen, einige der folgenden Probleme zu lösen. Sie sind nicht einfach, aber interessant. Tic-Tac-Toe. Richten Sie ein 3x3-Feld ein und erstellen Sie zwei Spieler, die sich abwechseln. Das Feld ist zunächst leer und in jedes der leeren Felder kann der erste Spieler ein Kreuz und der zweite eine Null setzen. Gewinner ist derjenige, der zuerst drei Kreuze oder drei Nullen in einer Reihe, einer Spalte oder diagonal angeordnet sammelt. Langtons Ameise . Es gibt ein bestimmtes Feld, das in Zellen unterteilt ist (ein zweidimensionales Array), schwarz oder weiß bemalt (kann durch eine Zufallsfunktion festgelegt werden). Eine „Ameise“ materialisiert sich zufällig in einem der Felder und kann sich bei jedem Schritt in eine von vier Richtungen zum benachbarten Feld bewegen, horizontal oder vertikal. Regeln für die Ameisenbewegung:

• Auf einem schwarzen Feld muss sich die Ameise um 90° nach links drehen, die Farbe ihres Feldes in Weiß ändern und dann zum nächsten Feld vortreten.
• Auf einem weißen Quadrat dreht sich die Ameise um 90° nach rechts, ändert die Farbe ihrer Zelle in Schwarz und geht dann zum nächsten Quadrat vor.

Schreiben Sie eine Methode, die die Iteration bei der Schrittnummer nanhand der Anfangsposition der Ameise berechnet. Das Feld kann zufällig mit Nullen und Einsen gefüllt werden (oder durch die Buchstaben Wund gekennzeichnet werden B, wie wir es im Schachbrettbeispiel getan haben). Wir benötigen außerdem zwei weitere Parameter – die horizontale und vertikale Position der Ameise sowie ihre Richtung in diesem Schritt (Norden, Süden, Westen, Osten), während die Ameise standardmäßig nach Norden schaut. Sie können versuchen, einen Zauberwürfel mithilfe dreidimensionaler Arrays zu modellieren. Ein normaler Zauberwürfel hat sechs Flächen und jede davon ist eine dreidimensionale Anordnung farbiger Quadrate Color[][][] rubik = new Color[6][3][3]. Allerdings ist die Implementierung eines Zauberwürfels keine triviale Aufgabe.

Nützliche Materialien zu Arrays

Viele Artikel auf JavaRush widmen sich Arrays (hauptsächlich eindimensionalen, da sie in der Praxis viel häufiger verwendet werden). Achten Sie auf sie.

1. Arrays in Java – über Arrays für Anfänger mit Beispielen
2. Etwas über Arrays – Guter ausführlicher Artikel über Arrays
3. Die Arrays-Klasse und ihre Verwendung – der Artikel beschreibt einige Methoden der KlasseArray
4. Arrays ist die erste JavaRush-Vorlesung, die sich Arrays widmet.
5. Geben Sie ein Array der Länge Null zurück, nicht null – Joshua Bloch, Autor von Effective Programming, spricht darüber, wie Sie leere Arrays besser zurückgeben können