Java TreeSet meistern: Operationen, Methoden und praktische Beispiele

Java TreeSet

In diesem Tutorial lernen Sie die Java TreeSet Klasse und ihre verschiedenen Operationen und Methoden anhand von Beispielen kennen.

Die TreeSet Klasse des Java Collections Frameworks stellt die Funktionalität einer Baum-Datenstruktur bereit.

Sie erweitert das NavigableSet Interface.

TreeSet erstellen

Um ein TreeSet zu erstellen, müssen wir zuerst das Paket java.util.TreeSet importieren.

Nach dem Import können wir ein TreeSet in Java wie folgt erstellen:

TreeSet<Integer> numbers = new TreeSet<>();

Hier haben wir ein TreeSet ohne Argumente erstellt. In diesem Fall werden die Elemente im TreeSet natürlich sortiert (aufsteigende Reihenfolge).

Wir können die Sortierung der Elemente jedoch anpassen, indem wir das Comparator Interface verwenden. Darauf werden wir später in diesem Tutorial eingehen.

Methoden von TreeSet

Die TreeSet Klasse bietet verschiedene Methoden, die es uns ermöglichen, verschiedene Operationen auf dem Set durchzuführen.

Elemente in TreeSet einfügen

• add() – fügt das angegebene Element zum Set hinzu
• addAll() – fügt alle Elemente der angegebenen Collection zum Set hinzu

Zum Beispiel:

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> evenNumbers = new TreeSet<>();
        // add() Methode verwenden
        evenNumbers.add(2);
        evenNumbers.add(4);
        evenNumbers.add(6);
        System.out.println("TreeSet: " + evenNumbers);

        TreeSet<Integer> numbers = new TreeSet<>();
        numbers.add(1);
        // addAll() Methode verwenden
        numbers.addAll(evenNumbers);
        System.out.println("Neues TreeSet: " + numbers);
    }
}

Ausgabe

TreeSet: [2, 4, 6]
Neues TreeSet: [1, 2, 4, 6]

Auf TreeSet Elemente zugreifen

Um auf die Elemente eines TreeSets zuzugreifen, können wir die iterator() Methode verwenden. Dazu müssen wir das Paket java.util.Iterator importieren. Zum Beispiel:

import java.util.TreeSet;
import java.util.Iterator;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> numbers = new TreeSet<>();
        numbers.add(2);
        numbers.add(5);
        numbers.add(6);
        System.out.println("TreeSet: " + numbers);

        // iterator() Methode aufrufen
        Iterator<Integer> iterate = numbers.iterator();
        System.out.print("TreeSet mit Iterator: ");

        // Elemente durchlaufen
        while(iterate.hasNext()) {
            System.out.print(iterate.next());
            System.out.print(", ");
        }
    }
}

Ausgabe

TreeSet: [2, 5, 6]
TreeSet mit Iterator: 2, 5, 6, 

Elemente entfernen

• remove() – entfernt das angegebene Element aus dem Set
• removeAll() – entfernt alle Elemente aus dem Set

Zum Beispiel:

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> numbers = new TreeSet<>();
        numbers.add(2);
        numbers.add(5);
        numbers.add(6);
        System.out.println("TreeSet: " + numbers);

        // remove() Methode verwenden
        boolean value1 = numbers.remove(5);
        System.out.println("Ist 5 entfernt? " + value1);

        // removeAll() Methode verwenden
        boolean value2 = numbers.removeAll(numbers);
        System.out.println("Sind alle Elemente entfernt? " + value2);
    }
}

Ausgabe

TreeSet: [2, 5, 6]
Ist 5 entfernt? true
Sind alle Elemente entfernt? true

Methoden für Navigation

Da die TreeSet Klasse NavigableSet implementiert, bietet sie verschiedene Methoden, um über die Elemente des TreeSets zu navigieren.

1. first() und last() Methoden

• first() – gibt das erste Element des Sets zurück
• last() – gibt das letzte Element des Sets zurück

Zum Beispiel:

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> numbers = new TreeSet<>();
        numbers.add(2);
        numbers.add(5);
        numbers.add(6);
        System.out.println("TreeSet: " + numbers);

        // first() Methode verwenden
        int first = numbers.first();
        System.out.println("Erste Zahl: " + first);

        // last() Methode verwenden
        int last = numbers.last();
        System.out.println("Letzte Zahl: " + last);
    }
}

Ausgabe

TreeSet: [2, 5, 6]
Erste Zahl: 2
Letzte Zahl: 6

2. ceiling(), floor(), higher() und lower() Methoden

• higher(element) – Gibt das kleinste Element zurück, das größer als das angegebene element ist.
• lower(element) – Gibt das größte Element zurück, das kleiner als das angegebene element ist.
• ceiling(element) – Gibt das kleinste Element zurück, das größer oder gleich dem angegebenen element ist. Wenn das übergebene element im TreeSet existiert, gibt es das übergebene element zurück.
• floor(element) – Gibt das größte Element zurück, das kleiner oder gleich dem angegebenen element ist. Wenn das übergebene element im TreeSet existiert, gibt es das übergebene element zurück.

Zum Beispiel:

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> numbers = new TreeSet<>();
        numbers.add(2);
        numbers.add(5);
        numbers.add(4);
        numbers.add(6);
        System.out.println("TreeSet: " + numbers);

        // higher() verwenden
        System.out.println("Mit higher: " + numbers.higher(4));
        // lower() verwenden
        System.out.println("Mit lower: " + numbers.lower(4));
        // ceiling() verwenden
        System.out.println("Mit ceiling: " + numbers.ceiling(4));
        // floor() verwenden
        System.out.println("Mit floor: " + numbers.floor(3));
    }
}

Ausgabe

TreeSet: [2, 4, 5, 6]
Mit higher: 5
Mit lower: 2
Mit ceiling: 4
Mit floor: 2

3. pollFirst() und pollLast() Methoden

• pollFirst() – gibt das erste Element aus dem Set zurück und entfernt es
• pollLast() – gibt das letzte Element aus dem Set zurück und entfernt es

Zum Beispiel:

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> numbers = new TreeSet<>();
        numbers.add(2);
        numbers.add(5);
        numbers.add(4);
        numbers.add(6);
        System.out.println("TreeSet: " + numbers);

        // pollFirst() verwenden
        System.out.println("Entferntes erstes Element: " + numbers.pollFirst());
        // pollLast() verwenden
        System.out.println("Entferntes letztes Element: " + numbers.pollLast());
        System.out.println("Neues TreeSet: " + numbers);
    }
}

Ausgabe

TreeSet: [2, 4, 5, 6]
Entferntes erstes Element: 2
Entferntes letztes Element: 6
Neues TreeSet: [4, 5]

4. headSet(), tailSet() und subSet() Methoden

headSet(element, booleanValue)

Die headSet() Methode gibt alle Elemente eines TreeSets vor dem angegebenen element zurück (das als Argument übergeben wird).

Der Parameter booleanValue ist optional. Sein Standardwert ist false.

Wenn true als booleanValue übergeben wird, gibt die Methode alle Elemente vor dem angegebenen Element einschließlich des angegebenen Elements zurück.

Zum Beispiel:

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> numbers = new TreeSet<>();
        numbers.add(2);
        numbers.add(5);
        numbers.add(4);
        numbers.add(6);
        System.out.println("TreeSet: " + numbers);

        // headSet() mit Standard-Boolean-Wert
        System.out.println("headSet ohne Boolean: " + numbers.headSet(5));
        // headSet() mit angegebenem Boolean-Wert
        System.out.println("headSet mit Boolean: " + numbers.headSet(5, true));
    }
}

Ausgabe

TreeSet: [2, 4, 5, 6]
headSet ohne Boolean: [2, 4]
headSet mit Boolean: [2, 4, 5]

tailSet(element, booleanValue)

Die tailSet() Methode gibt alle Elemente eines TreeSets nach dem angegebenen element (das als Parameter übergeben wird) einschließlich des angegebenen element zurück.

Der Parameter booleanValue ist optional. Sein Standardwert ist true.

Wenn false als booleanValue übergeben wird, gibt die Methode alle Elemente nach dem angegebenen element ohne Einbeziehung des angegebenen element zurück.

Zum Beispiel:

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> numbers = new TreeSet<>();
        numbers.add(2);
        numbers.add(5);
        numbers.add(4);
        numbers.add(6);
        System.out.println("TreeSet: " + numbers);

        // tailSet() mit Standard-Boolean-Wert
        System.out.println("tailSet ohne Boolean: " + numbers.tailSet(4));
        // tailSet() mit angegebenem Boolean-Wert
        System.out.println("tailSet mit Boolean: " + numbers.tailSet(4, false));
    }
}

Ausgabe

TreeSet: [2, 4, 5, 6]
tailSet ohne Boolean: [4, 5, 6]
tailSet mit Boolean: [5, 6]

subSet(e1, bv1, e2, bv2)

Die subSet() Methode gibt alle Elemente zwischen e1 und e2 einschließlich e1 zurück.

Die Parameter bv1 und bv2 sind optional. Der Standardwert von bv1 ist true, und der Standardwert von bv2 ist false.

Wenn false als bv1 übergeben wird, gibt die Methode alle Elemente zwischen e1 und e2 ohne Einbeziehung von e1 zurück.

Wenn true als bv2 übergeben wird, gibt die Methode alle Elemente zwischen e1 und e2 einschließlich e1 zurück.

Zum Beispiel:

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> numbers = new TreeSet<>();
        numbers.add(2);
        numbers.add(5);
        numbers.add(4);
        numbers.add(6);
        System.out.println("TreeSet: " + numbers);

        // subSet() mit Standard-Boolean-Wert
        System.out.println("subSet ohne Boolean: " + numbers.subSet(4, 6));
        // subSet() mit angegebenem Boolean-Wert
        System.out.println("subSet mit Boolean: " + numbers.subSet(4, false, 6, true));
    }
}

Ausgabe

TreeSet: [2, 4, 5, 6]
subSet ohne Boolean: [4, 5]
subSet mit Boolean: [5, 6]

Mengenoperationen

Die Methoden der TreeSet Klasse können auch verwendet werden, um verschiedene Mengenoperationen durchzuführen.

Vereinigung von Mengen

Um die Vereinigung zwischen zwei Mengen durchzuführen, verwenden wir die addAll() Methode. Zum Beispiel:

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> evenNumbers = new TreeSet<>();
        evenNumbers.add(2);
        evenNumbers.add(4);
        System.out.println("TreeSet1: " + evenNumbers);

        TreeSet<Integer> numbers = new TreeSet<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        System.out.println("TreeSet2: " + numbers);

        // Vereinigung zweier Mengen
        numbers.addAll(evenNumbers);
        System.out.println("Vereinigung ist: " + numbers);
    }
}

Ausgabe

TreeSet1: [2, 4]
TreeSet2: [1, 2, 3]
Vereinigung ist: [1, 2, 3, 4]

Schnittmenge von Mengen

Um die Schnittmenge zwischen zwei Mengen durchzuführen, verwenden wir die retainAll() Methode. Zum Beispiel:

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> evenNumbers = new TreeSet<>();
        evenNumbers.add(2);
        evenNumbers.add(4);
        System.out.println("TreeSet1: " + evenNumbers);

        TreeSet<Integer> numbers = new TreeSet<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        System.out.println("TreeSet2: " + numbers);

        // Schnittmenge zweier Mengen
        numbers.retainAll(evenNumbers);
        System.out.println("Schnittmenge ist: " + numbers);
    }
}

Ausgabe

TreeSet1: [2, 4]
TreeSet2: [1, 2, 3]
Schnittmenge ist: [2]

Differenz von Mengen

Um die Differenz zwischen zwei Mengen zu berechnen, können wir die removeAll() Methode verwenden. Zum Beispiel:

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> evenNumbers = new TreeSet<>();
        evenNumbers.add(2);
        evenNumbers.add(4);
        System.out.println("TreeSet1: " + evenNumbers);

        TreeSet<Integer> numbers = new TreeSet<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        System.out.println("TreeSet2: " + numbers);

        // Differenz zwischen zwei Mengen
        numbers.removeAll(evenNumbers);
        System.out.println("Differenz ist: " + numbers);
    }
}

Ausgabe

TreeSet1: [2, 4]
TreeSet2: [1, 2, 3, 4]
Differenz ist: [1, 3]

Teilmenge einer Menge

Um zu prüfen, ob eine Menge eine Teilmenge einer anderen Menge ist, verwenden wir die containsAll() Methode. Zum Beispiel:

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {
        TreeSet<Integer> numbers = new TreeSet<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);
        numbers.add(4);
        System.out.println("TreeSet1: " + numbers);

        TreeSet<Integer> primeNumbers = new TreeSet<>();
        primeNumbers.add(2);
        primeNumbers.add(3);
        System.out.println("TreeSet2: " + primeNumbers);

        // Prüfen, ob primeNumbers Teilmenge von numbers ist
        boolean result = numbers.containsAll(primeNumbers);
        System.out.println("Ist TreeSet2 Teilmenge von TreeSet1? " + result);
    }
}

Ausgabe

TreeSet1: [1, 2, 3, 4]
TreeSet2: [2, 3]
Ist TreeSet2 Teilmenge von TreeSet1? true

Weitere Methoden von TreeSet

Methode	Beschreibung
clone()	Erstellt eine Kopie des TreeSets
contains()	Sucht das TreeSet nach dem angegebenen Element und gibt ein boolean Ergebnis zurück
isEmpty()	Prüft, ob das TreeSet leer ist
size()	Gibt die Größe des TreeSet zurück
clear()	Entfernt alle Elemente aus dem TreeSet

Für weitere Details besuchen Sie die offizielle Java TreeSet Dokumentation.

TreeSet vs. HashSet

Sowohl TreeSet als auch HashSet implementieren das Set Interface. Es gibt jedoch einige Unterschiede zwischen ihnen.

• Im Gegensatz zu HashSet werden Elemente in TreeSet in einer bestimmten Reihenfolge gespeichert, da TreeSet auch das SortedSet Interface implementiert.
• TreeSet bietet Methoden für einfache Navigation, z. B. first(), last(), headSet(), tailSet(), da es auch das NavigableSet Interface implementiert.
• HashSet ist schneller als TreeSet für grundlegende Operationen wie add, remove, contains und size.

TreeSet Comparator

In allen obigen Beispielen werden TreeSet-Elemente natürlich sortiert. Wir können jedoch auch die Reihenfolge der Elemente anpassen.

Dafür müssen wir unsere eigene Comparator-Klasse erstellen, nach der die Elemente in einem TreeSet sortiert werden. Zum Beispiel:

import java.util.TreeSet;
import java.util.Comparator;

class Main {
    public static void main(String[] args) {
        // TreeSet mit benutzerdefiniertem Comparator erstellen
        TreeSet<String> animals = new TreeSet<>(new CustomComparator());
        animals.add("Dog");
        animals.add("Zebra");
        animals.add("Cat");
        animals.add("Horse");
        System.out.println("TreeSet: " + animals);
    }

    // Comparator-Klasse erstellen
    public static class CustomComparator implements Comparator<String> {
        @Override
        public int compare(String animal1, String animal2) {
            int value = animal1.compareTo(animal2);
            // Elemente werden in umgekehrter Reihenfolge sortiert
            if (value > 0) {
                return -1;
            } else if (value < 0) {
                return 1;
            } else {
                return 0;
            }
        }
    }
}

Ausgabe

TreeSet: [Zebra, Horse, Dog, Cat]

Im obigen Beispiel haben wir ein TreeSet erstellt, indem wir die CustomComparator Klasse als Argument übergeben haben.

Die CustomComparator Klasse implementiert das Comparator Interface.

Wir überschreiben dann die compare() Methode. Die Methode sortiert die Elemente nun in umgekehrter Reihenfolge.

Um mehr zu erfahren, besuchen Sie Java Comparator (offizielle Java-Dokumentation).