Arrays und Listen

Bisher hast du einzelne Werte in Variablen gespeichert.
In echten Programmen brauchst du oft viele Werte der gleichen Art – zum Beispiel eine Liste von Preisen, Namen oder Messwerten.
Dafür gibt es Arrays (feste Größe) und Listen (dynamische Größe, z. B. ArrayList).

Array: fixierte Länge, sehr effizient, geeignet wenn die Anzahl der Elemente vorher feststeht.
ArrayList: wächst oder schrumpft zur Laufzeit, komfortable Methoden wie add, remove, size.

Arrays: Grundlagen

Deklaration, Erzeugung, Zugriff

// 1) Deklaration + Erzeugung
int[] zahlen = new int[5];     // Array mit 5 Elementen, standardmäßig 0

// 2) Initialisierung per Index
zahlen[0] = 10;
zahlen[1] = 20;

// 3) Direkte Initialisierung
String[] namen = {"Ricky", "Lena", "Ali"};

// 4) Zugriff und Länge
System.out.println(namen[0]);  // "Ricky"
System.out.println(namen.length); // 3

Wichtige Punkte:

Indizes starten bei 0 und gehen bis length – 1.
Der Zugriff außerhalb des Bereichs (z. B. namen[3]) führt zu ArrayIndexOutOfBoundsException.
Die Länge eines Arrays ist fest.

Schleifen über Arrays

int[] werte = {2, 4, 6, 8};

// Klassische for-Schleife
for (int i = 0; i < werte.length; i++) {
    System.out.println("Index " + i + ": " + werte[i]);
}

// For-each-Schleife (enhanced for)
for (int w : werte) {
    System.out.println("Wert: " + w);
}

ArrayList: Dynamische Listen

ArrayList ist eine generische Klasse aus java.util.
Sie kann zur Laufzeit wachsen, Elemente löschen und bietet Komfortmethoden.

Import, Anlegen, Methoden

import java.util.ArrayList;

ArrayList<String> liste = new ArrayList<>();

liste.add("Ricky");
liste.add("Lena");
liste.add("Ali");

System.out.println(liste.get(0));  // "Ricky"
System.out.println(liste.size());  // 3

liste.remove("Lena");              // entfernt erstes Vorkommen von "Lena"
System.out.println(liste.contains("Ali")); // true

Wichtige Punkte:

ArrayList<T> nutzt Generics: T ist der Typ (z. B. String, Integer).
Zugriff über get(index), Länge mit size().
remove kann nach Wert oder Index löschen.

Vergleich: Array vs. ArrayList

Kriterium	Array	ArrayList
Größe	fest	dynamisch
Zugriff	`arr[i]`	`list.get(i)`
Länge	`arr.length`	`list.size()`
Hinzufügen	nicht direkt (nur bei initialer Befüllung)	`add(value)`
Entfernen	nicht direkt (nur neu anlegen/kopieren)	`remove(value)` / `remove(index)`
Performance	sehr effizient	etwas Overhead, aber komfortabel
Typ	primitiver oder Referenztyp	Referenztypen (für primitive: Wrapper, z. B. `Integer`)

Merke: Für viele Alltagsaufgaben in Einsteigerprojekten ist ArrayList die praktischere Wahl.
Arrays sind sinnvoll, wenn die Größe fix ist oder maximale Effizienz nötig ist.

Typische Aufgaben

Summe, Durchschnitt und Minimum (Array)

public class Statistik {
    public static void main(String[] args) {
        int[] werte = {5, 7, 3, 9, 2};

        int summe = 0;
        int min = Integer.MAX_VALUE;

        for (int w : werte) {
            summe += w;
            if (w < min) min = w;
        }

        double durchschnitt = (double) summe / werte.length;

        System.out.println("Summe: " + summe);
        System.out.println("Durchschnitt: " + durchschnitt);
        System.out.println("Minimum: " + min);
    }
}

Liste durchlaufen und filtern (`ArrayList<Integer>`)

import java.util.ArrayList;

public class Filtern {
    public static void main(String[] args) {
        ArrayList<Integer> zahlen = new ArrayList<>();
        zahlen.add(5);
        zahlen.add(12);
        zahlen.add(7);
        zahlen.add(20);

        // alle >= 10 ausgeben
        for (int z : zahlen) {
            if (z >= 10) {
                System.out.println(z);
            }
        }
    }
}

Häufige Fehlerquellen

Fehlerbild	Ursache	Lösung
`ArrayIndexOutOfBoundsException`	Index außerhalb des erlaubten Bereichs	Indizes prüfen: 0..`length-1`
`NullPointerException`	Array nicht erzeugt (`null`)	`new` verwenden, bevor darauf zugegriffen wird
Verwechslung von Länge	`arr.length` vs. `list.size()`	Richtige Eigenschaft/Methode verwenden
Primitive in `ArrayList`	`ArrayList<int>` nicht möglich	Wrapper-Typen nutzen: `ArrayList<Integer>`
Entfernen beim Iterieren	`remove` in `for-each` verändert Struktur	Mit Index-Schleife oder Iterator arbeiten

Interaktive Visualisierung: Liste eingeben, Statistik berechnen, Lauf markieren

Interaktive Visualisierung: Array vs. ArrayList

– Java-Code –

Summe

–

Durchschnitt

–

Minimum

–

– Ausgabe der Java-Konsole –