Arrays in Java

Lerne über Arrays in Java - eindimensionale und mehrdimensionale. Wie du sie anlegst, Werte veränderst und ausgibst.Tags: | | | | | | |
Noch nicht sicher genug im Webdesign? Lass dir in unseren Programmier-Kursen in Kirchdorf oder unserer Wichtel-Webdesign-Agentur in Pettenbach weiterhelfen!

Worum geht´s?

In diesem Java Tutorial lernen wir über den Umgang mit Arrays. Aber was sind überhaupt Arrays?

1. Was sind Arrays in Java?

Ein Array ist eine Art Variable, in der mehrere Variablen „hineingepackt“ wurden.

Anstatt also z.B. zu schreiben:

public class HelloWorld {
    public static void main(String[] args) {
        int a1 = 7;
        int a2 = 3;
        int a3 = 4;
        int a4 = 1;
        int a5 = 4;
    }
}

kannst du auch die 5 Variablen in eine einzige zusammenfassen:

public class HelloWorld {
    public static void main(String[] args) {
        int[] a = {7, 3, 4, 1, 4};
    }
}

Als geistiges Bild kannst du dir eine Art „Regal“ vorstellen, auf dem mehrere unserer „Kisten“ (=Variablen) stehen.

Anstatt dass wir jetzt aber jeder einzelnen Kiste eine Variable geben, geben wir dem Regal einen Namen.

Die einzelnen Kisten erhalten nur noch eine Nummer, beginnend bei 0:

Java Arrays

Das Array-Element a[0] wäre dann z.B. die erste Kiste auf unserem Regal namens a, das Element a[1] die zweite Kiste, usw.

2. Eine Array-Variable anlegen

Eine Möglichkeit, einen Array anzulegen, haben wir oben schon gesehen:

public class HelloWorld {
    public static void main(String[] args) {
        int[] a = {7, 3, 4, 1, 4};
    }
}

Du schreibst den Datentyp, dann ein [], dann den Namen des „Regals“, dann ein =-Zeichen und dann alle Werte des zukünftigen Arrays innerhalb von {}-Klammern, durch Beistriche getrennt.

Auf diese Weise werden alle Werte des Arrays gleich zum Start gesetzt.

Es gibt aber auch noch eine alternative Methode:

public class HelloWorld {
    public static void main(String[] args) {
        int[] a = {7, 3, 4, 1, 4}; // Methode 1
        int[] a2 = new int[5]; // Methode 2
    }
}

Bei der 2. Methode wird nur bestimmt, wie viele „Kisten“ unser Regal haben wird, aber noch nicht, welche Werte diese „Kisten“ annehmen werden.

Wenn wir nichts Anderes mehr festlegen, haben diese „Kisten“ dann entweder Standard-Werte (z.B. 0, falls es ein int-Datentyp ist) oder auch einen undefinierten Wert (null).

3. Werte in einer Array-Variable verändern

Du kannst eine jede „Kiste“ in einem Array-„Regal“ behandeln, als wäre es eine „normale“ Variable. Du musst sie nur mit dem Array-Namen und dem entsprechenden Index (Zahl in den []-Klammern) richtig auswählen:

public class HelloWorld {
    public static void main(String[] args) {
        int[] a = {7, 3, 4, 1, 4};
        a[2] = 2;
        System.out.println(a[3]);
    }
}

Das obige Programm legt einen Array a mit 5 Werten an, ändert dann den 3. Wert (weil Arrays ja bei 0 zu zählen beginnen) und gibt dann den 4. Wert (1) aus.

Ein Array lässt sich auch wunderbar mit Hilfe von Schleifen befüllen/verändern:

import java.util.Random;

public class HelloWorld {
    public static void main(String[] args) {
        Random r = new Random();
        int[] a = new int[10];
        for (int x = 0; x < a.length; x++) {
            a[x] = r.nextInt(100);
        }
    }
}

Das obige Programm legt einen Array mit 10 Elementen an und befüllt ihn dann mit Zufallszahlen von 0-99.

4. Mehrdimensionale Arrays

Es ist auch möglich, mehrdimensionale Arrays zu verwenden.

Als geistiges Bild stellst du dir am besten vor, du hast dann einen Kasten mit mehreren Regalen drin, die wiederum mehrere Kisten haben:

Java mehrdimensionale Arrays

Willst du noch eine Dimension hinzufügen, könntest du dir einen Raum vorstellen, in dem mehrere Kästen stehen. Dann ein Haus, in dem mehrere Räume stehen. Eine Stadt, in der mehrere Häuser sind.

Ich denke, es ist klar, wo die Sache hingeht. Man kann beinahe unendlich viele Dimensionen hinzufügen – aber alles über maximal 6-8 Dimensionen wird völlig unübersichtlich (alles über 4 ist schon anstrengend)

Mehrdimensionale Arrays funktionieren sehr ähnlich wie eindimensionale Arrays, nur hast du ein zusätzliches []-Klammernpaar:

public class HelloWorld {
    public static void main(String[] args) {
        Random r = new Random();
        char[][] map = {
                {'*','*','*','*','*',},
                {'*','*','*','O','O',},
                {'*','*','*','O','*',},
                {'*','*','X','*','*',},
                {'*','*','*','X','*',},
        };
        for (int y = 0; y < map.length; y++) {
            for (int x = 0; x < map[0].length; x++) {
                System.out.print("[" + map[y][x] + "]");
            }
            System.out.println();
        }
    }
}

Das obige Programm erstellt eine 2D-map für ein 4-gewinnt-Spiel, und gibt es mit Hilfe zweier Schleifen in 2D aus.

Die innere Schleife (mit dem x) ist dabei die x-Achse, die äußere Schleife die y-Achse.

Während map den ganzne Kasten darstellt, ist map[1] die zweite Zeile im map-Array, also das zweite Regal innerhalb des Kastens. map[1][0] wäre dann die erste Kiste im zweiten Regal von oben.

Verwirrend?

Ist es am Anfang vermutlich. Aber mit ein wenig Übung wirst du dich schon noch daran gewöhnen 🙂

 

Diskussion zum Tutorial

Du bist aus Oberösterreich? Dann nütze doch auch unsere flexiblen Programmier-Kurse in Kirchdorf - oder gib deine Website gerne in die guten Hände unserer erfahrenen Wichtel-Webdesign-Agentur.