Java HashSet: eindeutige Werte, Zugehörigkeit und Mengenoperationen

Eine Menge speichert eindeutige Werte

Ein HashSet (aus java.util) ist eine Sammlung, die jeden Wert höchstens einmal enthält. Es gibt keine Schlüssel und keine zugeordneten Werte wie in einer HashMap - nur einen Sack voll unterschiedlicher Elemente. Seine ganze Aufgabe ist es, eine Frage schnell zu beantworten: „Ist dieses Ding hier drin?"

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

public class Main {
    public static void main(String[] args) {
        Set<String> tags = new HashSet<>();
        tags.add("java");
        tags.add("backend");
        tags.add("java");   // Duplikat - ignoriert

        System.out.println(tags.contains("java"));     // true
        System.out.println(tags.contains("frontend")); // false
        System.out.println(tags.size());               // 2
    }
}

Es gibt einen einzigen Typparameter, <ElementType>. Wie bei ArrayList und HashMap typisierst du die Variable üblicherweise mit der Schnittstelle Set und konstruierst ein HashSet.

add gibt zurück, ob der Wert neu war

add speichert den Wert nicht einfach nur - es gibt ein boolean zurück, das dir sagt, ob sich die Menge tatsächlich verändert hat. Einen bereits vorhandenen Wert hinzuzufügen gibt false zurück und lässt die Menge unverändert.

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

public class Main {
    public static void main(String[] args) {
        Set<Integer> seen = new HashSet<>();

        System.out.println(seen.add(7));  // true  - 7 war neu
        System.out.println(seen.add(7));  // false - schon vorhanden
        System.out.println(seen);
    }
}

Dieser Rückgabewert ist wirklich nützlich: if (!seen.add(x)) { /* x ist eine Wiederholung */ } lässt dich Duplikate im Vorbeigehen in einer einzigen Zeile erkennen.

Duplikate aus einer Liste entfernen

Da eine Menge Wiederholungen ablehnt, ist der schnellste Weg, eine Sammlung zu deduplizieren, sie in eine Menge zu kippen. Der HashSet-Konstruktor akzeptiert jede andere Sammlung:

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>(List.of("Ada", "Boris", "Ada", "Chen", "Boris"));

        Set<String> unique = new HashSet<>(names);
        System.out.println(unique);          // jeder Name einmal
        System.out.println(unique.size());   // 3

        // brauchst du eine List zurück?
        List<String> deduped = new ArrayList<>(unique);
        System.out.println(deduped.size());  // 3
    }
}

Das ist der häufigste Grund, warum Anfänger zu einer Menge greifen. Sei dir nur bewusst, dass du bei diesem Hin und Her die ursprüngliche Reihenfolge verlierst - verwende LinkedHashSet, wenn die Reihenfolge wichtig ist (weiter unten behandelt).

contains, remove und size

Die alltäglichen Operationen spiegeln die der anderen Sammlungen wider:

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

public class Main {
    public static void main(String[] args) {
        Set<String> tags = new HashSet<>();
        tags.add("java");
        tags.add("backend");
        tags.add("api");

        System.out.println(tags.contains("api"));  // true
        System.out.println(tags.size());           // 3

        tags.remove("backend");
        System.out.println(tags.contains("backend")); // false

        tags.clear();
        System.out.println(tags.isEmpty());         // true
    }
}

Der große Vorteil gegenüber einer ArrayList ist contains. Eine Liste muss jedes Element durchlaufen, um es zu beantworten (O(n)); ein HashSet springt fast direkt zur Antwort (etwa O(1)). Wenn du dich dabei ertappst, list.contains(...) innerhalb einer Schleife aufzurufen, ist das meist das Signal, auf eine Menge umzusteigen.

Mengenoperationen: Vereinigung, Schnittmenge, Differenz

Mengen glänzen, wenn du sie kombinierst. Die Methoden lesen sich fast wie normales Deutsch, sobald du weißt, welche welche ist:

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

public class Main {
    public static void main(String[] args) {
        Set<Integer> a = new HashSet<>(Set.of(1, 2, 3, 4));
        Set<Integer> b = new HashSet<>(Set.of(3, 4, 5, 6));

        Set<Integer> union = new HashSet<>(a);
        union.addAll(b);            // alles, was in einer der beiden Mengen ist
        System.out.println(union);  // 1 2 3 4 5 6

        Set<Integer> intersection = new HashSet<>(a);
        intersection.retainAll(b);  // nur, was in beiden ist
        System.out.println(intersection); // 3 4

        Set<Integer> difference = new HashSet<>(a);
        difference.removeAll(b);    // in a, aber nicht in b
        System.out.println(difference);   // 1 2
    }
}

Der entscheidende Stolperstein: addAll, retainAll und removeAll verändern die Menge, auf der sie aufgerufen werden. Deshalb kopiert jedes Beispiel zuerst a in ein frisches HashSet - sonst würdest du dein Original zerstören. Baue für jedes Ergebnis eine neue Menge.

HashSet behält die Reihenfolge nicht bei

Wie HashMap gibt ein HashSet keine Zusicherung über die Iterationsreihenfolge, und die Reihenfolge kann sich zwischen Durchläufen unterscheiden. Wenn du Vorhersagbarkeit brauchst:

• LinkedHashSet bewahrt die Einfügereihenfolge - die Reihenfolge, in der du die Elemente hinzugefügt hast.
• TreeSet hält die Elemente nach ihrer natürlichen Ordnung sortiert (oder nach einem Comparator, den du angibst).

import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;

public class Main {
    public static void main(String[] args) {
        Set<String> insertion = new LinkedHashSet<>();
        insertion.add("gamma");
        insertion.add("alpha");
        insertion.add("beta");
        System.out.println(insertion);  // [gamma, alpha, beta]

        Set<String> sorted = new TreeSet<>(insertion);
        System.out.println(sorted);      // [alpha, beta, gamma]
    }
}

Alle drei implementieren die Schnittstelle Set, sodass der Wechsel zwischen ihnen eine einzeilige Änderung am Konstruktor ist.

Elemente müssen hashbar sein

Ein HashSet wird unter der Haube von einer HashMap getragen, daher gilt dieselbe Regel: Es findet Elemente, indem es sie hasht, was bedeutet, dass hashCode() und equals() eines Elements übereinstimmen müssen. Eingebaute Typen wie String und Integer machen das bereits richtig, weshalb die doppelten "java"-Strings oben korrekt zusammenfallen. Wenn du Instanzen deiner eigenen Klasse speicherst, überschreibe sowohl equals als auch hashCode - sonst werden zwei Objekte, die inhaltlich „gleich" sind, als verschieden behandelt, und contains sowie die Deduplizierung schlagen stillschweigend fehl.

Als Nächstes: Sammlungen durchlaufen

Du hast jetzt die drei Arbeitstier-Sammlungen kennengelernt - ArrayList, HashMap und HashSet. Jede durchläufst du ein wenig anders, und es gibt subtile Fallen (etwa eine Sammlung zu verändern, während du über sie iterierst). Als Nächstes fügen wir alles zusammen und behandeln, wie man Sammlungen sauber mit der for-each-Schleife, Iteratoren und forEach durchläuft.