Kapitel 14: Collection Framework (Einstieg)

🎯 Lernziele

• Was sind Collections? Unterschied zu Arrays
• ArrayList verwenden
• LinkedList Einführung
• Häufige Collection-Methoden (Hinzufügen, Löschen, Suchen, Durchlaufen)

14.1 Was sind Collections? Unterschied zu Arrays

📦 Array vs. ArrayList

Array	ArrayList
Größe fest	Größe dynamisch (wächst automatisch!)
Primitive Datentypen + Objekte	Nur Objekte (keine primitiven Datentypen!)
array[0]	list.get(0)
array.length	list.size()

→ ArrayList = Flexibler als Array!

14.2 ArrayList verwenden

📝 Syntax

import java.util.ArrayList;  // Importieren!

ArrayList<datentyp> listName = new ArrayList<>();

📋 Beispiel: ArrayList Grundlagen

import java.util.ArrayList;

public class ArrayListBeispiel {
    public static void main(String[] args) {
        // ArrayList für Strings erstellen
        ArrayList<String> namen = new ArrayList<>();
        
        // Hinzufügen
        namen.add("Max");
        namen.add("Anna");
        namen.add("Tom");
        
        // Ausgeben
        System.out.println(namen);  // [Max, Anna, Tom]
        System.out.println("Größe: " + namen.size());  // 3
        
        // Element an Index 1 abrufen
        System.out.println("Index 1: " + namen.get(1));  // Anna
        
        // Element löschen
        namen.remove(1);  // Anna löschen
        System.out.println(namen);  // [Max, Tom]
        
        // Liste durchlaufen
        for (String name : namen) {
            System.out.println(name);
        }
    }
}

14.3 LinkedList Einführung

🔗 ArrayList vs. LinkedList

Operation	ArrayList	LinkedList
Zugriff (get)	Schnell (direkt)	Langsam (muss durchlaufen)
Hinzufügen/Löschen (in der Mitte)	Langsam (verschieben)	Schnell (nur Zeiger ändern)

→ ArrayList für häufigen Zugriff, LinkedList für häufiges Einfügen/Löschen!

📋 Beispiel: LinkedList

import java.util.LinkedList;

public class LinkedListBeispiel {
    public static void main(String[] args) {
        LinkedList<Integer> zahlen = new LinkedList<>();
        
        zahlen.add(10);
        zahlen.add(20);
        zahlen.addFirst(5);   // Am Anfang einfügen
        zahlen.addLast(30);   // Am Ende einfügen
        
        System.out.println(zahlen);  // [5, 10, 20, 30]
    }
}

14.4 Häufige Collection-Methoden

📋 Beispiel: Alle wichtigen Methoden

import java.util.ArrayList;

public class CollectionMethoden {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        
        // 1. Hinzufügen
        list.add("A");
        list.add("B");
        list.add("C");
        System.out.println("Nach add: " + list);  // [A, B, C]
        
        // 2. Element abrufen
        System.out.println("Element an Index 1: " + list.get(1));  // B
        
        // 3. Element ändern (set)
        list.set(1, "X");
        System.out.println("Nach set: " + list);  // [A, X, C]
        
        // 4. Element löschen (remove)
        list.remove("X");
        System.out.println("Nach remove: " + list);  // [A, C]
        
        // 5. Größe (size)
        System.out.println("Größe: " + list.size());  // 2
        
        // 6. Enthält? (contains)
        System.out.println("Enthält A? " + list.contains("A"));  // true
        
        // 7. Index finden (indexOf)
        System.out.println("Index von A: " + list.indexOf("A"));  // 0
        
        // 8. Leeren (clear)
        list.clear();
        System.out.println("Nach clear: " + list);  // []
        System.out.println("Ist leer? " + list.isEmpty());  // true
    }
}

🔄 ArrayList durchlaufen (3 Methoden)

import java.util.ArrayList;

public class ArrayListDurchlaufen {
    public static void main(String[] args) {
        ArrayList<String> namen = new ArrayList<>();
        namen.add("Max");
        namen.add("Anna");
        namen.add("Tom");
        
        // Methode 1: Klassische for-Schleife
        System.out.println("Methode 1:");
        for (int i = 0; i < namen.size(); i++) {
            System.out.println(namen.get(i));
        }
        
        // Methode 2: For-each Schleife (empfohlen!)
        System.out.println("\nMethode 2:");
        for (String name : namen) {
            System.out.println(name);
        }
        
        // Methode 3: forEach mit Lambda (Java 8+)
        System.out.println("\nMethode 3:");
        namen.forEach(name -> System.out.println(name));
    }
}

📝 Zusammenfassung

In diesem Kapitel hast du gelernt:

• ✅ Collections = Flexibler als Arrays (dynamische Größe)
• ✅ ArrayList verwenden (add, get, remove, size)
• ✅ LinkedList für häufiges Einfügen/Löschen
• ✅ ArrayList durchlaufen (3 Methoden)

💡 Merksatz für Anfänger

"ArrayList = flexibler Array. Für Anfänger meistens ArrayList verwenden!"

🎯 Nächste Schritte

Im nächsten Kapitel lernst du:

• Ausnahmebehandlung (Exception Handling) (Kapitel 15)
• try...catch...finally
• Häufige Exception-Typen
• throws und throw

Bereit für Fehlerbehandlung? Los geht's! 🚀

---

📚 Weiterführende Links:

• Oracle Java Tutorials - Collections
• Java ArrayList Dokumentation

💬 Fragen?
Hinterlassen Sie einen Kommentar!