• Einführung
• Kontroll-Strukturen
• Arrays
• Klasse
• Konstruktoren
• Vererbung
• Interfaces
• Exceptions
• Strings-Stringbuilder
• Wrapper-Klassen
• Enums
• Collections
• Filehandling
• Datum und Zeit
• Lambda-Ausdrücke
• Swing

Collection in Java

Collections (Sammlungen) sind eine Gruppe von Interfaces und Klassen, die es ermöglichen, mehrere Objekte in einer einzigen Einheit zu speichern, zu verwalten und zu verarbeiten. Collections bieten eine flexible Möglichkeit, Daten in unterschiedlichen Strukturen zu organisieren und zu manipulieren, ohne dass Sie sich um die Details der Datenstruktur kümmern müssen. Es gibt verschiedene Arten von Collections in Java, die in der Java Collections Framework API definiert sind. Hier sind einige der wichtigsten Collection-Typen:

• List: Eine geordnete Sammlung von Elementen, die Duplikate zulassen. Die Elemente in einer Liste können durch ihre Indizes angesprochen werden. Beispiele für konkrete Implementierungen von List sind `ArrayList` und `LinkedList`.
• Set: Eine Sammlung von eindeutigen Elementen, die keine Duplikate zulassen. Beispiele für Set-Implementierungen sind `HashSet`, `LinkedHashSet` und `TreeSet`.
• Map: Eine Sammlung von Schlüssel-Wert-Paaren, wobei jeder Schlüssel eindeutig ist und auf einen Wert abgebildet wird. Beispiele für Map-Implementierungen sind `HashMap`, `LinkedHashMap` und `TreeMap`.
• Queue: Eine Sammlung, die nach dem First-In-First-Out (FIFO)-Prinzip organisiert ist. Beispiele für Queue-Implementierungen sind `LinkedList` und `PriorityQueue`.

Das Java Collections Framework bietet auch Hilfsklassen und Algorithmen, die auf Collections angewendet werden können, um häufige Operationen wie Sortieren, Suchen und Filtern zu erleichtern. Hier ist ein einfaches Beispiel für die Verwendung einer `List`-Collection in Java:

List

import java.util.ArrayList;

public class ArrayListExample {

public static void main(String[] args) {
   ArrayList fruits = new ArrayList();

    // Hinzufügen von Elementen zur ArrayList
    fruits.add("Banane");
    fruits.add("Kirsche");
    fruits.add("Apfel");

    // Zugriff auf ein Element
    System.out.println("Erstes Element: " + fruits.get(0));

    // Entfernen eines Elements
    //fruits.remove("Banane");

    // Ausgabe der Größe der ArrayList
    System.out.println("Die Größe der ArrayList ist: " + fruits.size());

    // Iteration über alle Elemente der ArrayList
    System.out.println("Alle Elemente in der ArrayList:");
    for (String fruit : fruits) {
        System.out.println(fruit);
    }

    // Überprüfen, ob die ArrayList ein bestimmtes Element enthält
    if (fruits.contains("Kirsche")) {
        System.out.println("Kirsche ist in der ArrayList vorhanden.");
    }
    
    Collections.sort(fruits);
    System.out.println(fruits.toString()); // Sortiert
    

    // Leeren der ArrayList
    fruits.clear();
    System.out.println("Die ArrayList ist leer: " + fruits.isEmpty());

In diesem Beispiel haben wir eine `List`-Collection erstellt und einige Integer-Werte hinzugefügt. Dann haben wir die Liste durchlaufen und die Elemente auf der Konsole ausgegeben. Collections in Java sind äußerst vielseitig und leistungsstark, und sie erleichtern die Verwaltung und Verarbeitung von Daten erheblich. Sie sind ein wichtiger Bestandteil der Java Standardbibliothek und werden in vielen Anwendungen verwendet.

Set

Set ist eine Collection (Sammlung), die Teil des Java Collections Frameworks ist. Es repräsentiert eine Menge von Elementen, bei denen keine Duplikate erlaubt sind. Das bedeutet, dass jede Instanz eines Set nur einzigartige Elemente enthalten kann. Hier sind die wichtigsten Punkte zur Set-Collection in Java:

import java.util.HashSet;
import java.util.Set;

public class SetExample {
    public static void main(String[] args) {
        // Erstellen eines HashSets
        Set set = new HashSet<>();

        // Hinzufügen von Elementen
        set.add("Apfel");
        set.add("Banane");
        set.add("Kirsche");
        set.add("Apfel"); // Duplikat, wird ignoriert

        // Überprüfen auf Vorhandensein eines Elements
        if (set.contains("Banane")) {
            System.out.println("Banane ist im Set vorhanden.");
        }

        // Entfernen eines Elements
        set.remove("Kirsche");

        // Ausgabe der Größe des Sets
        System.out.println("Die Größe des Sets ist: " + set.size());

        // Ausgabe aller Elemente im Set
        for (String fruit : set) {
            System.out.println(fruit);
        }

        // Leeren des Sets
        set.clear();
        System.out.println("Das Set ist leer: " + set.isEmpty());
    }

HashMap

HashMap ist eine Implementierung der Map-Schnittstelle, die Teil des Java Collections Frameworks ist. Sie wird verwendet, um Daten in Schlüssel-Wert-Paaren zu speichern. Hier sind die wichtigsten Aspekte der HashMap-Collection:

import java.util.HashMap;
import java.util.Map;

public class HashMapExample {
    public static void main(String[] args) {
        // Erstellen einer HashMap
        Map map = new HashMap<>();

        // Hinzufügen von Schlüssel-Wert-Paaren
        map.put("Apfel", 3);
        map.put("Banane", 2);
        map.put("Kirsche", 5);

        // Zugriff auf einen Wert
        System.out.println("Anzahl der Äpfel: " + map.get("Apfel"));

        // Überprüfen, ob ein Schlüssel vorhanden ist
        if (map.containsKey("Banane")) {
            System.out.println("Banane ist in der Map vorhanden.");
        }

        // Entfernen eines Schlüssel-Wert-Paares
        map.remove("Kirsche");

        // Ausgabe der Größe der Map
        System.out.println("Die Größe der Map ist: " + map.size());

        // Ausgabe aller Schlüssel-Wert-Paare
        for (Map.Entry entry : map.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }

        // Leeren der Map
        map.clear();
        System.out.println("Die Map ist leer: " + map.isEmpty());
    }
}