Java-Arrays: deklarieren, initialisieren, zugreifen und durchlaufen

Ein Array ist eine Liste fester Größe

Ein Array in Java enthält eine feste Anzahl von Werten desselben Typs, geordnet angelegt und über die Position zugänglich. „Fest" ist das Schlüsselwort: Sobald du ein Array erstellst, ändert sich seine Länge nie mehr. Und „desselben Typs": Ein int[] enthält nur int-Werte, ein String[] nur Strings. Diese Strenge ist der Preis dafür, dass Arrays schnell und speichersparend sind.

Du deklarierst einen Array-Typ, indem du [] hinter den Elementtyp setzt, und weist dann entweder ein Literal zu oder reservierst eines mit new:

public class Main {
    public static void main(String[] args) {
        int[] scores = {82, 91, 73, 88};
        String[] names = {"Ada", "Boris", "Chen"};

        System.out.println(scores[0]);
        System.out.println(names[1]);
    }
}

Die Klammern können hinter dem Typ stehen (int[] scores) oder hinter dem Namen (int scores[]). Beides kompiliert, aber int[] scores ist der idiomatische Java-Stil - setze die [] zum Typ, wo sie hingehören.

Ein Array mit new erstellen

Wenn du die Werte noch nicht kennst, aber die Größe, verwende new. Das reserviert die Plätze und füllt sie mit dem Standardwert des Typs:

public class Main {
    public static void main(String[] args) {
        int[] nums = new int[5];
        boolean[] flags = new boolean[3];
        String[] words = new String[2];

        System.out.println(nums[0]);
        System.out.println(flags[0]);
        System.out.println(words[0]);
    }
}

Die Standardwerte sind kein zufälliger Müll - Java initialisiert jedes Element mit null. Numerische Typen beginnen bei 0 (oder 0.0), boolean beginnt bei false, und Referenztypen wie String beginnen bei null. Dieses null solltest du dir merken: Ein frisch reserviertes String[] ist voller nulls, und der Aufruf einer Methode auf einem davon wirft eine NullPointerException.

Die Indizierung beginnt bei null

Du liest und schreibst Elemente über den Index, beginnend bei 0. Der letzte gültige Index ist immer length - 1:

public class Main {
    public static void main(String[] args) {
        String[] colors = {"red", "green", "blue"};

        System.out.println(colors[0]);
        System.out.println(colors[2]);

        colors[1] = "yellow";
        System.out.println(colors[1]);
    }
}

Anders als bei Arrays in manchen Skriptsprachen gibt dir ein Zugriff außerhalb des Bereichs nicht stillschweigend null oder undefined zurück - es wirft eine Ausnahme. Versuche, einen Index zu lesen, der nicht existiert:

public class Main {
    public static void main(String[] args) {
        int[] nums = {10, 20, 30};
        System.out.println(nums[5]);
    }
}

Dieses Programm stürzt ab mit:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 5 out of bounds for length 3

Das ist einer der häufigsten Anfängerfehler. Die Behebung ist fast immer ein Off-by-one-Fehler in einer Schleifenbedingung - <= verwenden, wo < gemeint war.

length ist ein Feld, keine Methode

Jedes Array trägt seine Größe in einem length-Feld. Achtung: keine Klammern.

public class Main {
    public static void main(String[] args) {
        int[] nums = {10, 20, 30, 40};
        System.out.println(nums.length);
    }
}

Hier ist eine Falle, in die jeder mindestens einmal tappt: Arrays verwenden .length (ein Feld), aber String verwendet .length() (eine Methode). nums.length() bei einem Array zu schreiben ist ein Kompilierfehler, und text.length bei einem String ebenso. Dasselbe Wort, unterschiedliche Regeln - das beim Array hat keine Klammern.

Ein Array durchlaufen

Du hast die for-each-Schleife auf der vorigen Seite gelernt, und sie ist der sauberste Weg, jedes Element zu lesen, wenn du den Index nicht brauchst:

public class Main {
    public static void main(String[] args) {
        int[] scores = {82, 91, 73, 88};

        int total = 0;
        for (int score : scores) {
            total += score;
        }

        System.out.println("Total: " + total);
        System.out.println("Average: " + (total / scores.length));
    }
}

Wenn du den Index brauchst - um Positionsnummern auszugeben, Elemente an Ort und Stelle zu ändern oder rückwärts zu iterieren - greife zur klassischen indizierten for-Schleife mit length als Grenze:

public class Main {
    public static void main(String[] args) {
        String[] names = {"Ada", "Boris", "Chen"};

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

Die Bedingung lautet i < names.length, nicht <=. <= zu verwenden, läuft einen Schritt zu weit und wirft die Out-of-bounds-Ausnahme aus dem vorigen Abschnitt. Eine schnelle Regel: for-each, wenn du nur Werte liest, indizierte for-Schleife, wenn du die Position brauchst oder ins Array zurückschreiben willst.

Mehrdimensionale Arrays

Ein 2D-Array ist eigentlich ein Array von Arrays - stell es dir als Raster aus Zeilen und Spalten vor. Du fügst ein zweites Paar eckiger Klammern hinzu:

public class Main {
    public static void main(String[] args) {
        int[][] grid = {
            {1, 2, 3},
            {4, 5, 6}
        };

        System.out.println(grid[0][2]);
        System.out.println(grid[1][0]);

        for (int[] row : grid) {
            for (int value : row) {
                System.out.print(value + " ");
            }
            System.out.println();
        }
    }
}

grid[zeile][spalte] wählt eine einzelne Zelle aus. Da jede Zeile ihr eigenes Array ist, ist grid.length die Anzahl der Zeilen und grid[0].length die Anzahl der Spalten in der ersten Zeile. Die Zeilen müssen nicht einmal gleich lang sein (das nennt man ein zerklüftetes Array), auch wenn die meisten Raster rechteckig sind.

Die Hilfsklasse Arrays

Arrays selbst haben fast keine Methoden - du kannst eines nicht direkt auf nützliche Weise sortieren oder ausgeben. Java stellt genau dafür eine Hilfsklasse java.util.Arrays voller statischer Helfer bereit:

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] nums = {5, 2, 8, 1, 9};

        Arrays.sort(nums);
        System.out.println(Arrays.toString(nums));

        int[] copy = Arrays.copyOf(nums, 7);
        System.out.println(Arrays.toString(copy));

        int found = Arrays.binarySearch(nums, 8);
        System.out.println("Index of 8: " + found);
    }
}

Ein paar Dinge, auf die du dich hier stützen kannst. Arrays.toString(arr) ist der richtige Weg, ein Array auszugeben - gibst du eines direkt aus, erhältst du einen nutzlosen String wie [I@1b6d3586. Arrays.sort sortiert an Ort und Stelle. Arrays.copyOf ist die Art, wie du „vergrößerst": Es gibt ein neues Array der gewünschten Länge zurück und füllt mit Standardwerten auf (die zwei zusätzlichen Plätze oben sind 0). Und Arrays.binarySearch funktioniert nur auf einem bereits sortierten Array korrekt.

Arrays vs. ArrayList

Verwende ein einfaches Array, wenn die Größe von vornherein feststeht und sich nicht ändert - ein fester Satz von Wochentagen, ein Spielbrett, Pixeldaten. Arrays sind schnell und leichtgewichtig, aber ihre feste Länge ist eine echte Einschränkung: Du kannst einem Array der Länge 6 kein siebtes Element hinzufügen, ohne ein komplett neues zu bauen.

In dem Moment, in dem du Elemente frei hinzufügen und entfernen musst, wird ein Array umständlich. Dafür ist ArrayList da - eine veränderbare, wachsende Liste, die das Kopieren für dich erledigt.

Als Nächstes: ArrayList

Wenn du nicht weißt, wie viele Elemente du haben wirst, oder sich diese Zahl ändert, während dein Programm läuft, steht dir ein Array fester Länge im Weg. ArrayList ist Javas Antwort: eine Liste, die bei Bedarf wächst und schrumpft, mit add- und remove-Methoden statt Index-Jongliererei. Das kommt als Nächstes.