Skip to main content

So kannst du zweidimensionale Java Arrays anlegen und nutzen

Eines der bedeutendsten Instrumente in der Mathematik ist das Koordinatensystem.

Die gedankliche Grundlage dieses Werkzeuges lieferte der französische Naturwissenschaftler und Philosoph Rene Descartes.

Man muss sich einmal verdeutlichen, was dies für die damalige Zeit bedeutete.
Bisher wurden mathematische Probleme lediglich durch Berechnungen gelöst.

Denke an geometrische Figuren, wie Dreiecke und Vierecke.
Der Umfang wurde lediglich berechnet.
Klar konnte man es auch auf Papier zeichnen.

Dennoch…
Ab diesem Zeitpunkt war es möglich eine geometrische Figur zu zeichnen.
Und das in einem einheitlichen System, welches jedem Beobachter ermöglichte, die Sachverhalte auf einen Blick zu erfassen.

Das Koordinatensystem verbindet somit die Algebra mit der Geometrie.

Es sorgt dafür, dass die Mathematik ein Instrument zur Visualisierung erhielt.
Somit können komplexe Probleme auf einer anschaulichen Ebene übertragen und gelöst werden.

Und auch in unserem Alltagsleben findest du Koordinatensysteme.

  • Denke an Schachbretter
  • Oder Landkarten mit Längen- und Breitengraden
  • Oder an GPS Systeme, welche diese Koordinaten speichern, verwerten und ausgeben.
  • Aber auch in Tabellen mit Spalten und Zeilen ist die Grundidee ein Koordinatensystem.

Warum erzähle ich dir das?
Ja, es geht um Java Programmierung in diesem Artikel.
Und es geht speziell um Java Arrays.
Und zwar um zweidimensionale oder mehrdimensionale Arrays.

Was kannst du von diesem Beitrag erwarten?

  • Zuerst möchte ich dir zeigen, was du dir unter einem zwei- oder mehrdimensionalen Array vorstellen kannst.
    Es geht um das Konzept, wie deine Daten in so einem Array aufbewahrt werden.
  • Dann zeige ich dir, wie du so ein mehrdimensionales Array anlegen kannst.
    Und worauf dabei zu achten ist.
  • Und dann werde ich dir zeigen, wie du es füllst und aus einem gefüllten Array Daten lesen kannst.

Wie kannst du dir zweidimensionale Java Arrays vorstellen.

Ein normales Array hat x-beliebig viele Fächer.
Und in diesen Fächern kann es Daten eines bestimmten Datentypen speichern.

Wenn ich einmal ein Integer-Array anlege:
int [] arrayEins = new int [] {2,3,4};
Dann hat dieses Array 3 Fächer.

Java Arrays eindimensional

Du hast aber die Möglichkeit in jedem Fach des Arrays, wiederum ein Array anzulegen.
Und dieses kann wieder x-beliebig viele Fächer haben.
Java Arrays zweidimensional drei Fächer

In diesem Moment ist dieses Array zweidimensional.
Jedes Fach beinhaltet wieder ein Array.
Insgesamt besitzt dieses zweidimensionale Array 9 Fächer.

Solche zweidimensionale Java Arrays kannst du dir als Tabelle vorstellen.

Jede Tabelle besitzt Zeilen und Spalten.

Ein normales bzw. eindimensionales Array besitzt nur eine Spalte.
Und hier kann es so viele Werte eines bestimmten Datentypen speichern, wie die Länge es zulässt.
In unserem Beispiel hat das eindimensionale Array die Länge drei und die Werte 2, 3 und vier.

Als Tabelle würde dies so aussehen.

Java Array als Tabelle

Du siehst:
Die Tabelle oder das Array besitzt eine Spalte und drei Zeilen.
Man kann es auch so sagen: „Das Array besitzt drei Zeilen und jede Zeile besitzt nur eine Spalte.“

Und wenn du jetzt in den Fächern ein weiteres Java Array anlegst.
Dann hätte jede Zeile mehrere Spalten.

Java Arrays zweidimensional Spalten und Zeilen

Eine Tabelle mit drei Zeilen und drei Spalten wäre dann ein Array, welche 9 Integerwerte speichert.
Java-Tabelle-anlegen

Alles klar?
Dann lass uns ein solches zweidimensionales Java Array einmal anlegen.

So kannst du zweidimensionale Java Arrays anlegen.

Ein normales eindimensionales Array hast du bisher so angelegt:
int [] eindimArray = new int [] {2,3,4};
Oder so:


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

Es ist eigentlich ganz einfach.
Wenn du mehr Dimensionen brauchst, setze mehr eckige Klammern.
Und zwar auf beiden Seiten:

  • Bei der Variable (int [] eindimArray)
  • Und beim Array (new int[])

int [] [] zweidimArray = new int [3] [2];
In diesem Falle hast du dann ein zweidimensionales Array mit 3 Fächern.
Und alle drei Fächer haben wiederum ein Array mit zwei Fächern.

Das bedeutet, du hast jetzt 3 mal 2 Fächer.
Also ein zweidimensionales Array, welches 6 Werte speichern könnte.

Jetzt lass es uns auch endlich füllen. 🙂

So kannst du zweidimensionale Java Arrays füllen.

Ich bleibe bei der Tabelle.
Und ich habe eine zweite Spalte/ Array hinzugefügt.

Java-Tabelle-2-Spalten

Im Fach 0 0 befindet sich die Zahl 2.


public class ArrayTest {
	
	public static void main(String[] args) {		
		int [] [] zweidimArray = new int [3] [2];//multidimensionales Array mit 3 Zeilen und 2 Spalten
		zweidimArray[0][0]=2; //Koordinaten 0 0
	}
}

Das nächste Fach im Array könnte das Fach mit den Koordinaten 0 und 1 sein.

Koordinate-0-1

Hier wird der Wert 7 gespeichert.


public class ArrayTest {
	
	public static void main(String[] args) {		
		int [] [] zweidimArray = new int [3] [2];//3 Zeilen und 2 Spalten
		zweidimArray[0][0]=2; //Koordinaten 0 0
		zweidimArray[0][1]=7; //Koordinaten 0 1
	}
}

Dann geht es in die nächste Zeile, also in das nächste „erste Fach“.

Koordinate-1-0

Dieses beinhaltet den Wert 3.


public class ArrayTest {
	
	public static void main(String[] args) {		
		int [] [] zweidimArray = new int [3] [2];//3 Zeilen und 2 Spalten
		zweidimArray[0][0]=2; //Koordinaten 0 0
		zweidimArray[0][1]=7; //Koordinaten 0 1
		zweidimArray[1][0]=3; //Koordinaten 1 0
	}
}

Und das Fach 1-1 speichert den Wert 12.

Koordinate-1-1


public class ArrayTest {
	
	public static void main(String[] args) {		
		int [] [] zweidimArray = new int [3] [2];//3 Zeilen und 2 Spalten
		zweidimArray[0][0]=2; //Koordinaten 0 0
		zweidimArray[0][1]=7; //Koordinaten 0 1
		zweidimArray[1][0]=3; //Koordinaten 1 0
		zweidimArray[1][1]=12; //Koordinaten 1 1
	}
}

Die letzte Zeile speichert die Werte 4 und 8.

Und so würde der Java Code mit allen Fächern dieses Java Arrays aussehen:


public class ArrayTest {
	
	public static void main(String[] args) {		
		int [] [] zweidimArray = new int [3] [2];//3 Zeilen und 2 Spalten
		zweidimArray[0][0]=2; //Koordinaten 0 0
		zweidimArray[0][1]=7; //Koordinaten 0 1
		zweidimArray[1][0]=3; //Koordinaten 1 0
		zweidimArray[1][1]=12; //Koordinaten 1 1
		zweidimArray[2][0]=4; //Koordinaten 2 0
		zweidimArray[2][1]=8; //Koordinaten 2 1
	}
}

Um die Werte dann wieder aus dem Array zu lesen, kannst du die Koordinaten in eine System.out.println()-Anweisung einbinden und dir zurück geben lassen.

Dabei gehst du genauso vor, wie bei der Füllung der einzelnen Fächer.
Du gibst die Koordinaten an und platzierst diese innerhalb der System.out.println()-Anweisung.


public class ArrayTest {
	
	public static void main(String[] args) {		
		int [] [] zweidimArray = new int [3] [2];//3 Zeilen und 2 Spalten
		
		//Array mit Werten füllen
		zweidimArray[0][0]=2; //Koordinaten 0 0
		zweidimArray[0][1]=7; //Koordinaten 0 1
		zweidimArray[1][0]=3; //Koordinaten 1 0
		zweidimArray[1][1]=12; //Koordinaten 1 1
		zweidimArray[2][0]=4; //Koordinaten 2 0
		zweidimArray[2][1]=8; //Koordinaten 2 1
		
		//Werte aus dem Array lesen
		System.out.println(zweidimArray[0][0]);//Rückgabe 2
		System.out.println(zweidimArray[0][1]);//Rückgabe 7
		System.out.println(zweidimArray[1][0]);//Rückgabe 3
		System.out.println(zweidimArray[1][1]);//Rückgabe 12
		System.out.println(zweidimArray[2][0]);//Rückgabe 4
		System.out.println(zweidimArray[2][1]);//Rückgabe 8
	}
}

Aber da geht noch mehr.

Denn du kannst die zweite Dimension mit einer dynamischen Größe belegen.

Und so geht’s.
Beim Anlegen des Arrays kannst du die Größe der zweiten Dimension oder Spalte erst einmal offen lassen.
int [] [] zweidimArray = new int [3] [];
Dann hast du ein zweidimensionales Array mit drei Fächern.
In jedem dieser drei Fächer steckt ein anderes Array, dessen Länge noch unklar ist.
Und dann kannst du beliebige neue Arrays in den einzelnen Fächern anlegen.


	int [] [] zweidimArray = new int [3] [];//3 Zeilen und x- Spalten
		zweidimArray[0]= new int[2]; //Im Fach 0 wurde ein Array für zwei Integer-Werte angelegt
		zweidimArray[1]= new int[2]; //Fach 1 mit Array für zwei Werte
		zweidimArray[2]= new int[2];//Dritte Zeile mit zwei Fächern

Der Rest – also das Füllen und Abrufen der einzelnen Werte – würde im Code so bleiben.


public class ArrayTest {
	
	public static void main(String[] args) {		
		int [] [] zweidimArray = new int [3] [];//3 Zeilen und x- Spalten
		zweidimArray[0]= new int[2]; //Im Fach 0 wurde ein Array für zwei Integer-Werte angelegt
		zweidimArray[1]= new int[2]; //Fach 1 mit Array für zwei Werte
		zweidimArray[2]= new int[2];//Dritte Zeile mit zwei Fächern
		
		//Array mit Werten füllen
		zweidimArray[0][0]=2; //Koordinaten 0 0
		zweidimArray[0][1]=7; //Koordinaten 0 1
		zweidimArray[1][0]=3; //Koordinaten 1 0
		zweidimArray[1][1]=12; //Koordinaten 1 1
		zweidimArray[2][0]=4; //Koordinaten 2 0
		zweidimArray[2][1]=8; //Koordinaten 2 1
		
		//Werte aus dem Array lesen
		System.out.println(zweidimArray[0][0]);
		System.out.println(zweidimArray[0][1]);
		System.out.println(zweidimArray[1][0]);
		System.out.println(zweidimArray[1][1]);
		System.out.println(zweidimArray[2][0]);
		System.out.println(zweidimArray[2][1]);
	}
}

Also was bringt es?
Du kannst an den einzelnen Stellen Arrays mit verschiedener Länge anlegen.
Zum Beispiel könnte die Tabelle dann so aussehen:

Java-Tabelle-unterschiedliche-Spalten

Die erste Zeile hätte nach wie vor zwei Spalten.
zweidimArray[0]= new int[2];
Die zweite Zeile hätte aber drei Spalten.
zweidimArray[1]= new int[3];
Und die dritte Zeile sogar vier Spalten.
zweidimArray[2]= new int[4];

Der komplette Code zu dieser Tabelle würde dann so aussehen.
Die neuen Fächer und Werte habe ich für dich fett markiert.


public class ArrayTest {
	
	public static void main(String[] args) {		
		int [] [] zweidimArray = new int [3] [];//3 Zeilen und x- Spalten
		zweidimArray[0]= new int[2]; //Im Fach 0 wurde ein Array für zwei Integer-Werte angelegt
		zweidimArray[1]= new int[3]; //Fach 1 mit Array für drei Werte
		zweidimArray[2]= new int[4];//Dritte Zeile mit vier Fächern
		
		//Array mit Werten füllen
		zweidimArray[0][0]=2; //Koordinaten 0 0
		zweidimArray[0][1]=7; //Koordinaten 0 1
		zweidimArray[1][0]=3; //Koordinaten 1 0
		zweidimArray[1][1]=12; //Koordinaten 1 1
		zweidimArray[1][2]=2; //Koordinaten 1 2
		zweidimArray[2][0]=4; //Koordinaten 2 0
		zweidimArray[2][1]=8; //Koordinaten 2 1
		zweidimArray[2][2]=22; //Koordinaten 2 2
		zweidimArray[2][3]=3; //Koordinaten 2 3
		
		//Werte aus dem Array lesen
		System.out.println(zweidimArray[0][0]);
		System.out.println(zweidimArray[0][1]);
		System.out.println(zweidimArray[1][0]);
		System.out.println(zweidimArray[1][1]);
		System.out.println(zweidimArray[1][2]);//Rückgabe 2
		System.out.println(zweidimArray[2][0]);
		System.out.println(zweidimArray[2][1]);
		System.out.println(zweidimArray[2][2]);//Rückgabe 22
		System.out.println(zweidimArray[2][3]);//Rückgabe 3
	}
}

Du kannst die Größe des Arrays auch nachträglich ändern

Dafür musst du nur die Längenwerte überschreiben:


public class ArrayTest {
	
	public static void main(String[] args) {		
		int [] [] zweidimArray = new int [3] [1];//3 Zeilen und 1 Spalte
		zweidimArray[0]= new int[2]; //Länge für Fach 0 wurde überschrieben
		zweidimArray[1]= new int[3]; //Länge für Fach 1 wurde überschrieben
		zweidimArray[2]= new int[4];//Länge für Fach 2 wurde überschrieben
	}
}

Du siehst:
Ursprünglich hatte das Array nur 1 Spalte.
Dann wurden für alle Zeilen bzw. Fächer neue Dimensionen festgelegt.

Dass dies auch funktioniert, siehst du hier.
Probiere diesen Code aus.


public class ArrayTest {
	
	public static void main(String[] args) {		
		int [] [] zweidimArray = new int [3] [1];//3 Zeilen und 1 Spalte
		zweidimArray[0]= new int[2]; //Länge für Fach 0 wurde überschrieben
		zweidimArray[1]= new int[3]; //Länge für Fach 1 wurde überschrieben
		zweidimArray[2]= new int[4];//Länge für Fach 2 wurde überschrieben
		
		//Array mit Werten füllen
		zweidimArray[0][0]=2;
		zweidimArray[0][1]=7;
		zweidimArray[1][0]=3;
		zweidimArray[1][1]=12;
		zweidimArray[1][2]=2;
		zweidimArray[2][0]=4; 
		zweidimArray[2][2]=22;
		zweidimArray[2][3]=3;
		
		//Werte aus dem Array lesen
		System.out.println(zweidimArray[0][0]);
		System.out.println(zweidimArray[0][1]);
		System.out.println(zweidimArray[1][0]);
		System.out.println(zweidimArray[1][1]);
		System.out.println(zweidimArray[1][2]);
		System.out.println(zweidimArray[2][0]);
		System.out.println(zweidimArray[2][1]);
		System.out.println(zweidimArray[2][2]);
		System.out.println(zweidimArray[2][3]);
	}
}

Und natürlich kannst du auch multidimensionale Arrays anlegen.

Und damit meine ich mehr als unsere bisherigen zwei Dimensionen.

Wenn du mehr Dimensionen willst, dann setze mehr Klammern.
Und das wiederum auf beiden Seiten.

  • int [] [] [] dreidimArray = new int [3] [2] [2]; drei Dimensionen mit 12 Fächern
  • int [] [] [] [] vierdimArray = new int [3] [2] [2] [7]; vier Dimensionen mit 84 Fächern

Schauen wir uns das dreidimensionale Array einmal an.
Dieses Array könntest du dir so vorstellen:
Dreidimensionales Array mit 3 Fächern und jeweils 2 Spalten und jeweils 2 Reihen in die Tiefe.

Java Arrays multidimensional

Ab der vierten Dimension ist es für uns nicht mehr visuell darstellbar.
Ab jetzt sind nur noch die Mathematiker mit Matrizen und Vektoren gefragt. 🙂

Den Zugriff auf die einzelnen Fächer organisierst du analog zu einem zweidimensionalen Array.


int [] [] [] dreiDimArray= new int [3][2][2]; 
		dreiDimArray[0][0][0]=2; //Das Fach 0-0-0 speichert den Wert 2

So habe ich noch etwas vergessen?

Ah ja.
Wie auch schon bei den eindimensionalen Arrays ist eine Mischung der Datentypen nicht möglich.

Das heißt:
Du kannst in einem Integer-Array, in allen Dimensionen, nur ganze Zahlen speichern.
In einem String Array ist nur Platz für Textwerte. Und auch das erstreckt sich über alle Dimensionen.
Und so weiter… 🙂

Zusammenfassung:

  • Java Arrays können nicht nur eindimensional sein.
    Du kannst in Java auch mehr- oder multidimensionale Arrays anlegen.
  • In diesen kannst du dann ganz normal Werte speichern und die Werte wieder abrufen.
    Du gibst die Indizes (Koordinaten) zum Array an und kannst dort Werte speichern und abrufen.
  • Wie auch schon bei den normalen Arrays ist hier keine Mischung der Datentypen möglich.

Ähnliche Beiträge

Nutze das Keyword this für deine Java Konstruktoren

Java konstruktoren this

Es ist gemein. Wahrscheinlich hast den Beitrag zu den lokalen Variablen gelesen. Vielleicht hast du auch den Artikeln zum Anlegen und Überladen von Java Konstruktoren gelesen. Und wenn du die beschriebene Inhalte selbst ausprobiert hast…… Dann hast du dir wahrscheinlich sehr viele lokale Variablennamen für die Parameterliste ausdenken müssen.

Java Binärzahl in Dezimalzahl umwandeln – So geht’s.

Java-Binärzahl-umrechnen

Erinnerst du dich? In einer der letzten Beiträge haben wir uns die Zusammenhänge zwischen dem dualen und dem dezimalen Zahlensystem angeschaut. Aber wir haben noch keine Java Binärzahl in eine Dezimalzahl verwandelt. Zumindestens nicht praktisch…. Stattdessen…. Haben wir festgestellt, dass beide Zahlensysteme im Grunde genommen sehr ähnlich sind. Beim Dezimalsystem spielt die Zahl 10, als […]

Java Übung 27 – Auf zur Mathe-Olympiade

Java Übung Mathe Olympiade

In dieser Java Übung möchte ich mit dir ein Programm erstellen, welches ein Mathematik-Test oder eine Mathe-Olympiade simuliert. Du kennst das vielleicht noch aus der Schule. Matheolympiade- Da wurden aus allen vier Grundrechenarten, Aufgaben formuliert. Die Schüler mussten diese Aufgaben lösen. Die Lehrer kontrollierten die Lösungen. Und der Schüler, welcher die wenigsten Fehler hatte – […]

So verwendest du in Java try und catch Blöcke

Java try und catch

Ich bereue lieber die Dinge, die ich getan habe – als die Dinge, welche ich gar nicht erst versucht habe. Ja ich würde mich als den typischen „try-and-error-Menschen“ bezeichnen. Was ich will, probiere ich einfach aus und schaue dann erst was passiert. So etwas wie Pläne kenne ich eigentlich nicht. Und wenn ich mal einen […]

Polymorphie bringt Vorteile für Java Arrays

Java Polymorphie Arrays

Wenn Java Arrays, Schubladen oder Container sein sollen… Dann wäre der Gebrauch einer solchen Schublade ziemlich einseitig und festgefahren. Denn in jedes Array passen zwar mehrere Daten – aber immer nur vom gleichen Datentyp. Immer gleicher Datentyp? Also eine Schublade nur für Socken, Unterwäsche und der ganze andere Kram passt dann eben nicht hinein. Um […]

Der bedeutende Unterschied zwischen Klassenvariablen und Instanzvariablen

Java Klassenvariablen

Bei der Java Programmierung unterscheidet man drei Arten von Variablen. Als erste Gruppe sind die lokalen Variablen zu nennen. Auf diese gehe ich in einem separaten Artikel ein. Mich interessieren die zwei anderen Variablentypen. Zum einen existieren Klassenvariablen. Und dann sind da noch die Instanzvariablen. Wo liegt der Unterschied? Instanzvariablen stehen einem Objekt zur Verfügung. […]

Die vier wichtigen Phasen um Java Objekte zu erstellen

Java Objekte anlegen

Wie werden aus deinen Java Klassen richtig nützliche Java Objekte? Das ganze läuft in vier Phasen ab. Und diese Phasen möchte ich dir in diesem Beitrag vorstellen. Ob das nützlich ist? Schau dir das Bild an. Am Ende dieses Beitrages wirst du wissen, warum Eclipse dir hier eine Fehlermeldung gibt und wie du dieses Problem […]

Ende vom Java Blog?

Falls du hier schon länger dabei bist, wird dir aufgefallen sein – dass kaum noch Beiträge veröffentlicht werden. Das tut mir wirklich leid und dafür möchte ich mich auch entschuldigen. Ich weiß, dass Einige unter Euch den Java-Blog wirklich lieben. Aber es ist verdammt schwierig so ein aufwendiges Thema – stilvoll, unterhaltend und methodisch umzusetzen. […]

So kannst du dein Java Programm mit der main Methode ausführen

Auf zum ersten Java Programm. Vielleicht fragst du dich jetzt gerade: Na, was haben wir denn bisher gemacht? War das etwa kein Java Programm? Wir haben bisher nur eine Klasse „Human“ für ein zuküntfiges Mensch-Objekt erstellt. Diesem Objekt haben wir eine Instanzvariable, namens size (Größe) zugeordnet. Und wir haben eine Instanzmethode, namens grow (wachsen) geschrieben. […]

So nutzt du Methoden aus der Java String Klasse

Java Strings Methoden

In einen der letzten Beiträge haben wir darüber gesprochen, dass Java Strings – Objekte sind. Dass Strings in allen Programmen äußerst häufig vorkommen Und dass sich deshalb Referenzvariablen String-Objekte im String Pool teilen. Das Konzept hinter dem String-Pool ist die Teilung der Ressourcen. Und das bedeutet: Weniger Objekte – mehr Speicher Mehr Speicher – bessere […]