Arrays in Java

Ein Array ist die einfachste Datenstruktur in Java: eine geordnete Sammlung von Elementen gleichen Typs mit fester Groesse. Wenn du aus Python kommst, sind Arrays aehnlich wie Listen — aber mit einer wichtigen Einschraenkung: Die Groesse steht beim Erstellen fest und kann nicht geaendert werden.

Array erstellen

Methode 1: Groesse angeben

// Array mit 5 Plaetzen erstellen (default: 0)
int[] zahlen = new int[5];
zahlen[0] = 10;
zahlen[1] = 20;
zahlen[2] = 30;
zahlen[3] = 40;
zahlen[4] = 50;

Methode 2: Direkt mit Werten initialisieren

int[] zahlen = {10, 20, 30, 40, 50};
String[] namen = {"Max", "Anna", "Leo"};
double[] noten = {1.7, 2.3, 1.0, 3.0};
boolean[] flags = {true, false, true};

Methode 3: Mit new und Werten

var zahlen = new int[]{10, 20, 30, 40, 50};
var namen = new String[]{"Max", "Anna", "Leo"};

Zugriff auf Elemente

var fruechte = new String[]{"Apfel", "Banane", "Kirsche", "Dattel"};

System.out.println(fruechte[0]);     // Apfel (erstes Element)
System.out.println(fruechte[2]);     // Kirsche (drittes Element)
System.out.println(fruechte.length); // 4 (Anzahl Elemente)

// Letztes Element
System.out.println(fruechte[fruechte.length - 1]); // Dattel

ArrayIndexOutOfBoundsException

var zahlen = new int[]{1, 2, 3};

// FEHLER zur Laufzeit!
// zahlen[3];   // ArrayIndexOutOfBoundsException (Index 0-2 gueltig)
// zahlen[-1];  // ArrayIndexOutOfBoundsException (kein negativer Index)

Arrays durchlaufen

Klassische for-Schleife

var namen = new String[]{"Max", "Anna", "Leo", "Julia"};

for (int i = 0; i < namen.length; i++) {
    System.out.printf("%d: %s%n", i, namen[i]);
}

For-each-Schleife (empfohlen)

for (var name : namen) {
    System.out.println("Hallo " + name + "!");
}

Vergleich mit Python

# Python: Listen
namen = ["Max", "Anna", "Leo"]
for name in namen:
    print(f"Hallo {name}!")

namen.append("Julia")  # Groesse aenderbar!

// Java: Arrays (feste Groesse!)
var namen = new String[]{"Max", "Anna", "Leo"};
for (var name : namen) {
    System.out.println("Hallo " + name + "!");
}

// namen.append("Julia"); // GEHT NICHT! Feste Groesse.

Arrays manipulieren

Elemente aendern

var noten = new double[]{3.0, 2.7, 1.3, 4.0};
noten[0] = 2.0;  // Erstes Element aendern
noten[3] = 1.7;  // Letztes Element aendern

Arrays sortieren

import java.util.Arrays;

var zahlen = new int[]{5, 2, 8, 1, 9, 3};
Arrays.sort(zahlen);
System.out.println(Arrays.toString(zahlen)); // [1, 2, 3, 5, 8, 9]

var namen = new String[]{"Charlie", "Anna", "Bob"};
Arrays.sort(namen);
System.out.println(Arrays.toString(namen)); // [Anna, Bob, Charlie]

Arrays durchsuchen

var zahlen = new int[]{1, 3, 5, 7, 9, 11};
Arrays.sort(zahlen); // Muss sortiert sein fuer binarySearch!

int index = Arrays.binarySearch(zahlen, 7);
System.out.println("7 gefunden an Index: " + index); // 3

Arrays kopieren

var original = new int[]{1, 2, 3, 4, 5};

// Kopie mit gleicher Groesse
var kopie = Arrays.copyOf(original, original.length);

// Kopie mit anderer Groesse
var kuerzer = Arrays.copyOf(original, 3);        // [1, 2, 3]
var laenger = Arrays.copyOf(original, 8);         // [1, 2, 3, 4, 5, 0, 0, 0]

// Bereich kopieren
var bereich = Arrays.copyOfRange(original, 1, 4); // [2, 3, 4]

Arrays fuellen

var zahlen = new int[10];
Arrays.fill(zahlen, 42);
System.out.println(Arrays.toString(zahlen)); // [42, 42, 42, 42, 42, 42, 42, 42, 42, 42]

Arrays vergleichen und ausgeben

var a = new int[]{1, 2, 3};
var b = new int[]{1, 2, 3};

// == vergleicht Referenzen (fast immer false!)
System.out.println(a == b);              // false

// Arrays.equals() vergleicht Inhalte
System.out.println(Arrays.equals(a, b)); // true

// toString() fuer lesbare Ausgabe
System.out.println(a);                    // [I@1234 (Referenz)
System.out.println(Arrays.toString(a));   // [1, 2, 3]

Mehrdimensionale Arrays

2D-Array (Matrix)

// 3x4 Matrix
int[][] matrix = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
};

// Zugriff: matrix[zeile][spalte]
System.out.println(matrix[0][0]); // 1
System.out.println(matrix[1][2]); // 7
System.out.println(matrix[2][3]); // 12

// Durchlaufen
for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        System.out.printf("%4d", matrix[i][j]);
    }
    System.out.println();
}

Multiplikationstabelle

int groesse = 10;
int[][] tabelle = new int[groesse][groesse];

for (int i = 0; i < groesse; i++) {
    for (int j = 0; j < groesse; j++) {
        tabelle[i][j] = (i + 1) * (j + 1);
    }
}

// Ausgabe
for (var zeile : tabelle) {
    for (var wert : zeile) {
        System.out.printf("%4d", wert);
    }
    System.out.println();
}

Die Arrays-Utility-Klasse

Methode	Beschreibung
Arrays.toString(arr)	Lesbare String-Darstellung
Arrays.sort(arr)	Sortieren
Arrays.binarySearch(arr, key)	Suchen (sortiert!)
Arrays.equals(a, b)	Inhalte vergleichen
Arrays.copyOf(arr, len)	Kopie erstellen
Arrays.fill(arr, val)	Alle Elemente setzen
Arrays.stream(arr)	Stream erstellen
Arrays.asList(arr)	Zu Liste konvertieren

Arrays und Streams

var zahlen = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

// Summe berechnen
var summe = Arrays.stream(zahlen).sum();
System.out.println("Summe: " + summe); // 55

// Durchschnitt
var durchschnitt = Arrays.stream(zahlen).average().orElse(0);
System.out.printf("Durchschnitt: %.1f%n", durchschnitt); // 5.5

// Gerade Zahlen filtern
var gerade = Arrays.stream(zahlen)
    .filter(z -> z % 2 == 0)
    .toArray();
System.out.println("Gerade: " + Arrays.toString(gerade)); // [2, 4, 6, 8, 10]

Praktische Beispiele

Haeufigkeitsanalyse

var wuerfe = new int[]{3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};
var haeufigkeit = new int[10]; // Index 0-9

for (var wurf : wuerfe) {
    haeufigkeit[wurf]++;
}

for (int i = 0; i < haeufigkeit.length; i++) {
    if (haeufigkeit[i] > 0) {
        System.out.printf("Zahl %d: %d mal%n", i, haeufigkeit[i]);
    }
}

Bubble Sort (Lernzweck)

static void bubbleSort(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        for (int j = 0; j < arr.length - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                // Tauschen
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

var zahlen = new int[]{64, 34, 25, 12, 22, 11, 90};
bubbleSort(zahlen);
System.out.println(Arrays.toString(zahlen)); // [11, 12, 22, 25, 34, 64, 90]

Uebungen

Uebung 1: Array-Statistik

Schreibe Methoden, die fuer ein int-Array das Minimum, Maximum, den Durchschnitt und die Summe berechnen.

Uebung 2: Array umkehren

Schreibe eine Methode, die ein Array in-place umkehrt (ohne neues Array).

Uebung 3: Duplikate finden

Schreibe eine Methode, die alle Duplikate in einem int-Array findet und ausgibt.

Uebung 4: Tic-Tac-Toe

Erstelle ein 3x3 char-Array fuer ein Tic-Tac-Toe-Spielfeld. Schreibe Methoden zum Anzeigen, Setzen und Pruefen eines Gewinners.

Was kommt als Naechstes?

Arrays haben eine feste Groesse — das ist oft unpraktisch. In der naechsten Lektion lernst du Collections (List, Set, Map) kennen, die dynamisch wachsen und schrumpfen koennen.

Zusammenfassung

• Arrays speichern eine feste Anzahl von Elementen gleichen Typs
• Zugriff ueber Index (0-basiert): array[0]
• array.length gibt die Groesse zurueck (ohne Klammern!)
• Arrays-Utility-Klasse bietet sort, search, copy, fill und mehr
• Mehrdimensionale Arrays fuer Matrizen und Tabellen
• Arrays und Streams fuer funktionale Operationen
• Arrays haben eine feste Groesse — fuer dynamische Listen nutze Collections

---