Java TreeSet

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

Der TreeSet Klasse des Java Collections Framework bietet die Funktionalität einer Baumdatenstruktur.

Es erweitert die NavigableSet-Schnittstelle.

TreeSet erstellen

Um einen Baumsatz zu erstellen, müssen wir den java.util.TreeSet importieren Paket zuerst.

Sobald wir das Paket importiert haben, können wir wie folgt einen TreeSet erstellen in Java.


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

Hier haben wir eine TreeSet erstellt ohne Argumente. In diesem Fall die Elemente in TreeSet werden natürlich (aufsteigend) sortiert.

Wir können jedoch die Sortierung der Elemente anpassen, indem wir den Comparator verwenden Schnittstelle. Wir werden später in diesem Tutorial mehr darüber erfahren.

Methoden von TreeSet

Die TreeSet Die Klasse stellt verschiedene Methoden bereit, mit denen wir verschiedene Operationen am Set ausführen können.

Elemente in TreeSet einfügen

add() - fügt das angegebene Element in die Menge ein
addAll() - fügt alle Elemente der angegebenen Sammlung in die Menge ein

Zum Beispiel

import java.util.TreeSet;

class Main {
    public static void main(String[] args) {

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

        // Using the add() method
        evenNumbers.add(2);
        evenNumbers.add(4);
        evenNumbers.add(6);
        System.out.println("TreeSet: " + evenNumbers);

        TreeSet<Integer> numbers = new TreeSet<>();
        numbers.add(1);

        // Using the addAll() method
        numbers.addAll(evenNumbers);
        System.out.println("New TreeSet: " + numbers);
    }
}

Ausgabe

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

Auf TreeSet-Elemente zugreifen

Um auf die Elemente eines Baumsatzes zuzugreifen, können wir den iterator() verwenden Methode. Um diese Methode zu verwenden, müssen wir java.util.Iterator importieren Paket. 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);

        // Calling iterator() method
        Iterator<Integer> iterate = numbers.iterator();
        System.out.print("TreeSet using Iterator: ");
        // Accessing elements
        while(iterate.hasNext()) {
            System.out.print(iterate.next());
            System.out.print(", ");
        }
    }
}

Ausgabe

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

Elemente entfernen

remove() - entfernt das angegebene Element aus der Menge
removeAll() - entfernt alle Elemente aus der Menge

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);

        // Using the remove() method
        boolean value1 = numbers.remove(5);
        System.out.println("Is 5 removed? " + value1);

        // Using the removeAll() method
        boolean value2 = numbers.removeAll(numbers);
        System.out.println("Are all elements removed? " + value2);
    }
}

Ausgabe

TreeSet: [2, 5, 6]
Is 5 removed? true
Are all elements removed? true

Seit dem TreeSet Klasse implementiert NavigableSet , bietet es verschiedene Methoden, um über die Elemente des Baumsatzes zu navigieren.

1. first()- und last()-Methoden

first() - gibt das erste Element der Menge zurück
last() - gibt das letzte Element der Menge 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);

        // Using the first() method
        int first = numbers.first();
        System.out.println("First Number: " + first);

        // Using the last() method
        int last = numbers.last();
        System.out.println("Last Number: " + last);
    }
}

Ausgabe

TreeSet: [2, 5, 6]
First Number: 2
Last Number: 6

2. Ceiling()-, Floor()-, Higher()- und Lower()-Methoden

höheres(Element) - Gibt das niedrigste Element unter den Elementen zurück, die größer als der angegebene element sind .
unteres(Element) - Gibt das größte Element unter den Elementen zurück, die kleiner als der angegebene element sind .
Decke(Element) - Gibt das niedrigste Element unter den Elementen zurück, die größer als das angegebene element sind . Wenn das Element übergeben in einem Baumsatz existiert, gibt es den element zurück als Argument übergeben.
Boden(element) - Gibt das größte Element unter den Elementen zurück, die kleiner als der angegebene element sind . Wenn das Element übergeben in einem Baumsatz existiert, gibt es den element zurück als Argument übergeben.

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);

        // Using higher()
        System.out.println("Using higher: " + numbers.higher(4));

        // Using lower()
        System.out.println("Using lower: " + numbers.lower(4));

        // Using ceiling()
        System.out.println("Using ceiling: " + numbers.ceiling(4));

        // Using floor()
        System.out.println("Using floor: " + numbers.floor(3));

    }
}

Ausgabe

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

3. pollfirst()- und pollLast()-Methoden

pollFirst() - gibt das erste Element aus der Menge zurück und entfernt es
pollLast() - gibt das letzte Element aus der Menge 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);

        // Using pollFirst()
        System.out.println("Removed First Element: " + numbers.pollFirst());

        // Using pollLast()
        System.out.println("Removed Last Element: " + numbers.pollLast());

        System.out.println("New TreeSet: " + numbers);
    }
}

Ausgabe

TreeSet: [2, 4, 5, 6]
Removed First Element: 2
Removed Last Element: 6
New TreeSet: [4, 5]

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

headSet(element, booleanValue)

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

Der boolesche Wert Parameter ist optional. Sein Standardwert ist false .

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

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);

        // Using headSet() with default boolean value
        System.out.println("Using headSet without boolean value: " + numbers.headSet(5));

        // Using headSet() with specified boolean value
        System.out.println("Using headSet with boolean value: " + numbers.headSet(5, true));
    }
}

Ausgabe

TreeSet: [2, 4, 5, 6]
Using headSet without boolean value: [2, 4]
Using headSet with boolean value: [2, 4, 5]

tailSet(element, booleanValue)

Der tailSet() -Methode gibt alle Elemente eines Baumsatzes nach dem angegebenen element zurück (der als Parameter übergeben wird) einschließlich des angegebenen elements .

Der boolesche Wert Parameter ist optional. Sein Standardwert ist true .

Wenn false wird als booleanValue übergeben , gibt die Methode alle Elemente nach dem angegebenen element zurück ohne das angegebene element einzuschließen .

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);

        // Using tailSet() with default boolean value
        System.out.println("Using tailSet without boolean value: " + numbers.tailSet(4));

        // Using tailSet() with specified boolean value
        System.out.println("Using tailSet with boolean value: " + numbers.tailSet(4, false));
    }
}

Ausgabe

TreeSet: [2, 4, 5, 6]
Using tailSet without boolean value: [4, 5, 6]
Using tailSet with boolean value: [5, 6]

subSet(e1, bv1, e2, bv2)

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

Die bv1 und bv2 sind optionale Parameter. Der Standardwert von bv1 ist true , und den Standardwert von bv2 ist false .

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

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

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);

        // Using subSet() with default boolean value
        System.out.println("Using subSet without boolean value: " + numbers.subSet(4, 6));

        // Using subSet() with specified boolean value
        System.out.println("Using subSet with boolean value: " + numbers.subSet(4, false, 6, true));
    }
}

Ausgabe

TreeSet: [2, 4, 5, 6]
Using subSet without boolean value: [4, 5]
Using subSet with boolean value: [5, 6]

Set-Operationen

Die Methoden des TreeSet Klasse kann auch verwendet werden, um verschiedene Set-Operationen auszuführen.

Vereinigung von Mengen

Um die Vereinigung zwischen zwei Mengen durchzuführen, verwenden wir den 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);

        // Union of two sets
        numbers.addAll(evenNumbers);
        System.out.println("Union is: " + numbers);

    }
}

Ausgabe

TreeSet1: [2, 4]
TreeSet2: [1, 2, 3]
Union is: [1, 2, 3, 4]

Schnittmenge von Mengen

Um die Schnittmenge zwischen zwei Sätzen auszuführen, verwenden wir den 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);

        // Intersection of two sets
        numbers.retainAll(evenNumbers);
        System.out.println("Intersection is: " + numbers);
    }
}

Ausgabe

TreeSet1: [2, 4]
TreeSet2: [1, 2, 3]
Intersection is: [2]

Unterschied von Sätzen

Um die Differenz zwischen den beiden Sätzen zu berechnen, können wir den removeAll() verwenden 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);
        numbers.add(4);
        System.out.println("TreeSet2: " + numbers);

        // Difference between two sets
        numbers.removeAll(evenNumbers);
        System.out.println("Difference is: " + numbers);
    }
}

Ausgabe

TreeSet1: [2, 4]
TreeSet2: [1, 2, 3, 4]
Difference is: [1, 3]

Teilmenge einer Menge

Um zu überprüfen, ob eine Menge eine Teilmenge einer anderen Menge ist oder nicht, verwenden wir den 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);

        // Check if primeNumbers is subset of numbers
        boolean result = numbers.containsAll(primeNumbers);
        System.out.println("Is TreeSet2 subset of TreeSet1? " + result);
    }
}

Ausgabe

TreeSet1: [1, 2, 3, 4]
TreeSet2: [2, 3]
Is TreeSet2 subset of TreeSet1? True

Andere Methoden von TreeSet

Methode	Beschreibung
`clone()`	Erzeugt eine Kopie des TreeSet
`contains()`	Durchsucht das TreeSet nach dem angegebenen Element und gibt ein boolesches Ergebnis zurück
`isEmpty()`	Überprüft, ob der `TreeSet` ist leer
`size()`	Gibt die Größe des `TreeSet` zurück
`clear()`	Entfernt alle Elemente aus `TreeSet`

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

TreeSet vs. HashSet

Sowohl die TreeSet sowie der HashSet implementiert den Set Schnittstelle. Es gibt jedoch einige Unterschiede zwischen ihnen.

Im Gegensatz zu HashSet , Elemente in TreeSet werden in einer bestimmten Reihenfolge gespeichert. Das liegt daran, dass TreeSet implementiert den SortedSet Schnittstelle.
TreeSet bietet einige Methoden zur einfachen Navigation. Beispiel:first() , last() , headSet( ), tailSet() usw. Es liegt daran, dass TreeSet implementiert auch den NavigableSet Schnittstelle.
HashSet ist schneller als TreeSet für grundlegende Operationen wie Hinzufügen, Entfernen, Enthält und Größe.

TreeSet-Vergleicher

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

Dazu müssen wir unsere eigene Komparatorklasse erstellen, basierend darauf, welche Elemente in einem Baumsatz sortiert werden. Zum Beispiel

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

class Main {
    public static void main(String[] args) {

        // Creating a tree set with customized comparator
        TreeSet<String> animals = new TreeSet<>(new CustomComparator());

        animals.add("Dog");
        animals.add("Zebra");
        animals.add("Cat");
        animals.add("Horse");
        System.out.println("TreeSet: " + animals);
    }

    // Creating a comparator class
    public static class CustomComparator implements Comparator<String> {

        @Override
        public int compare(String animal1, String animal2) {
            int value =  animal1.compareTo(animal2);

            // elements are sorted in reverse order
            if (value > 0) {
                return -1;
            }
            else if (value < 0) {
                return 1;
            }
            else {
                return 0;
            }
        }
    }
}

Ausgabe