Java TreeSet

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

Die TreeSet-Klasse der Java-Sammelrahmen bietet Funktionen für die Baumdatenstruktur.

Es erweitertNavigableSet-Schnittstelle。

Erstellen Sie einen TreeSet

Um einen TreeSet zu erstellen, müssen wir zunächst das Paket java.util.TreeSet importieren.

Nachdem das Paket importiert wurde, zeigen wir, wie man TreeSet in Java erstellt.

TreeSet　numbers　=　new　TreeSet<>();

Hier erstellen wir einen TreeSet ohne Parameter. In diesem Beispiel sind die Elemente im TreeSet natürliche geordnet (aufsteigend).

Aber wir können die Sortierung der Elemente mit dem Comparator-Interface anpassen. Dies werden wir in einem späteren Teil des Tutorials lernen.

Methoden der Klasse TreeSet

Die Klasse TreeSet bietet verschiedene Methoden, die es uns erlauben, verschiedene Operationen auf die Sammlung auszuführen.

fügt das Element in den TreeSet ein

• add() - fügt das angegebene Element in die Sammlung ein

• addAll() - fügt alle Elemente der angegebenen Sammlung in die Sammlung ein

Beispielsweise,

import java.util.TreeSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet　evenNumbers　=　new　TreeSet<>();
　　　　　　　　//　Verwenden Sie die Methode add()
　　　　　　　　evenNumbers.add(2);
　　　　　　　　evenNumbers.add(4);
　　　　　　　　evenNumbers.add(6);
　　　　　　　　System.out.println("TreeSet: "　+　evenNumbers);
　　　　　　　　TreeSet　numbers　=　new　TreeSet<>();
　　　　　　　　numbers.add(1);
　　　　　　　　//　Verwenden Sie die Methode addAll()
　　　　　　　　numbers.addAll(evenNumbers);
　　　　　　　　System.out.println("Neuer TreeSet:　"　+　numbers);
　　　　}
}

Output Result

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

TreeSet Elemente ansprechen

Um die Elemente des TreeSet ansprechen zu können, können wir die Methode iterator() verwenden. Um diese Methode verwenden zu können, 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　numbers　=　new　TreeSet<>();
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(5);
　　　　　　　　numbers.add(6);
　　　　　　　　System.out.println("TreeSet: "　+　numbers);
　　　　　　　　//　Aufruf der Methode iterator()
　　　　　　　　Iterator<Integer> iterate = numbers.iterator();
　　　　　　　　System.out.print("TreeSet verwendet den Iterator: ");
　　　　　　　　//Elemente ansprechen
　　　　　　　　while(iterate.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Output Result

TreeSet:　[2,　5,　6]
TreeSet verwendet den Iterator:　2,　5,　6,

entfernt das Element

• remove() - entfernt das angegebene Element aus der Sammlung

• removeAll() - entfernt alle Elemente aus der Sammlung

Beispielsweise,

import java.util.TreeSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet　numbers　=　new　TreeSet<>();
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(5);
　　　　　　　　numbers.add(6);
　　　　　　　　System.out.println("TreeSet: "　+　numbers);
　　　　　　　　//　Verwenden Sie die Methode remove()
　　　　　　　　boolean value1　value = numbers.remove("5);
　　　　　　　　System.out.println("5Wurden gelöscht? "　+　value1);
　　　　　　　　//　Verwenden Sie die Methode removeAll()
　　　　　　　　boolean value2　value = numbers.removeAll(numbers);
　　　　　　　　System.out.println("Wurden alle Elemente gelöscht? " + System.lineSeparator());　+　value2);
　　　　}
}

Output Result

TreeSet:　[2,　5,　6]
5Wurden gelöscht? true
Wurden alle Elemente gelöscht? true

Navigation Methoden

Da die TreeSet-Klasse das NavigableSet-Interface implementiert, bietet sie verschiedene Methoden zur Navigation durch die Elemente des Baumes.

1. first() und last() Methoden

• first() - zurückgibt das erste Element der Sammlung

• last() - zurückgibt das letzte Element der Sammlung

Beispielsweise,

import java.util.TreeSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet　numbers　=　new　TreeSet<>();
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(5);
　　　　　　　　numbers.add(6);
　　　　　　　　System.out.println("TreeSet: "　+　numbers);
　　　　　　　　//　Verwenden Sie die Methode first()
　　　　　　　　int first = numbers.first();
　　　　　　　　System.out.println("erster Zahl: " + System.lineSeparator());　+　first);
　　　　　　　　//　Verwenden Sie　last()　Methode
　　　　　　　　int last = numbers.last();
　　　　　　　　System.out.println("Letzte Zahl:　"　+　last);
　　　　}
}

Output Result

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

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

• Higher(element) - Geben Sie zurück das kleinste Element, das größer als das angegebene Element (element) ist.

• lower(element) - Geben Sie zurück das größte Element, das kleiner als das angegebene Element (element) ist.

• ceiling(element) - Geben Sie zurück das kleinste Element, das größer als das angegebene Element (element) ist. Wenn das übergebene Element (element) im Baum存在于 der Sammlung vorhanden ist, wird das als Parameter übergebene Element (element) zurückgegeben.

• floor(element) - Geben Sie zurück das größte Element, das kleiner als das angegebene Element (element) ist. Wenn das übergebene Element (element) im Baum存在于 der Sammlung vorhanden ist, wird das als Parameter übergebene Element (element) zurückgegeben.

Beispielsweise,

import java.util.TreeSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet　numbers　=　new　TreeSet<>();
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(5);
　　　　　　　　numbers.add(4);
　　　　　　　　numbers.add(6);
　　　　　　　　System.out.println("TreeSet: "　+　numbers);
　　　　　　　　//　Verwenden Sie　higher()
　　　　　　　　System.out.println("Verwenden Sie　higher:　"　+　numbers.higher(4));
　　　　　　　　//　Verwenden Sie　lower()
　　　　　　　　System.out.println("Verwenden Sie　lower:　"　+　numbers.lower(4));
　　　　　　　　//　Verwenden Sie　ceiling()
　　　　　　　　System.out.println("Verwenden Sie　ceiling:　"　+　numbers.ceiling(4));
　　　　　　　　//　Verwenden Sie　floor()
　　　　　　　　System.out.println("Verwenden Sie　floor:　"　+　numbers.floor(3));
　　　　}
}

Output Result

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

3. pollfirst() und pollLast() Methoden

• pollFirst() - Geben Sie zurück und löschen Sie das erste Element aus der Sammlung

• pollLast() - Geben Sie zurück und löschen Sie das letzte Element aus der Sammlung

Beispielsweise,

import java.util.TreeSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet　numbers　=　new　TreeSet<>();
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(5);
　　　　　　　　numbers.add(4);
　　　　　　　　numbers.add(6);
　　　　　　　　System.out.println("TreeSet: "　+　numbers);
　　　　　　　　//　Verwenden Sie　pollFirst()
　　　　　　　　System.out.println("Erstes Element löschen:　"　+　numbers.pollFirst());
　　　　　　　　//　Verwenden Sie　pollLast()
　　　　　　　　System.out.println("Letztes Element löschen:　"　+　numbers.pollLast());
　　　　　　　　System.out.println("Neuer TreeSet:　"　+　numbers);
　　　　}
}

Output Result

TreeSet:　[2,　4,　5,　6]
Erstes Element löschen:　2
Letztes Element löschen:　6
Neuer TreeSet:　[4,　5]

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

headSet(element,booleanValue)

Die Methode headSet() gibt alle Elemente im Vorgänger-Baumset aller Elemente zurück, die vor dem angegebenen Element (als Parameter übergeben) enthalten sind.

Der Parameter booleanValue ist optional. Standardwert ist false.

wenn der Wert von booleanValue true ist, gibt diese Methode alle Elemente vor dem angegebenen Element zurück, einschließlich des angegebenen Elements.

Beispielsweise,

import java.util.TreeSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet　numbers　=　new　TreeSet<>();
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(5);
　　　　　　　　numbers.add(4);
　　　　　　　　numbers.add(6);
　　　　　　　　System.out.println("TreeSet: "　+　numbers);
　　　　　　　　//　Verwendung von headSet() mit dem Standard-Boolean-Wert
　　　　　　　　System.out.println("Verwendung von headSet ohne Boolean-Wert: ")　+　numbers.headSet(5));
　　　　　　　　//　Verwendung von headSet() mit angegebenem Boolean-Wert
　　　　　　　　System.out.println("Verwendung von headSet mit Boolean-Wert: ")　+　numbers.headSet(5,　true));
　　　　}
}

Output Result

TreeSet:　[2,　4,　5,　6]
Verwendung von headSet ohne Boolean-Wert: [2,　4]
Verwendung von headSet mit Boolean-Wert: [2,　4,　5]

tailSet(element,booleanValue)

Die Methode tailSet() gibt alle Elemente im Nachfolger-Baumset aller Elemente zurück, die nach dem angegebenen Element (als Parameter übergeben) enthalten sind.

Der Parameter booleanValue ist optional. Standardwert ist true.

wenn false als a übergeben wird, gibt diese Methode alle nachfolgenden Elemente zurück, element, ohne das angegebene element.

Beispielsweise,

import java.util.TreeSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet　numbers　=　new　TreeSet<>();
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(5);
　　　　　　　　numbers.add(4);
　　　　　　　　numbers.add(6);
　　　　　　　　System.out.println("TreeSet: "　+　numbers);
　　　　　　　　//　Verwendung von tailSet() mit dem Standard-Boolean-Wert
　　　　　　　　System.out.println("tailSet() mit dem Standard-Boolean-Wert: ")　+　numbers.tailSet(4));
　　　　　　　　//　Verwendung von tailSet() mit angegebenem Boolean-Wert
　　　　　　　　System.out.println("tailSet() mit Boolean-Wert: ")　+　numbers.tailSet(4, false));
　　　　}
}

Output Result

TreeSet:　[2,　4,　5,　6]
Verwendung von tailSet() mit dem Standard-Boolean-Wert: [4,　5,　6]
tailSet() mit Boolean-Wert: [5,　6]

subSet(e1,bv1,e2,bv2)

gibt subSet() e zurück1und e2alle Elemente zwischen1。

bv1und bv2ist ein optionaler Parameter. 　bv1Der Standardwert ist true, bv2Der Standardwert ist false.

wenn false als bv1wenn e übergeben wird, gibt diese Methode e zurück1und e2alle Elemente zwischen, ohne e1。

wenn true als bv2wenn e übergeben wird, gibt diese Methode e zurück1und e2alle Elemente zwischen1。

Beispielsweise,

import java.util.TreeSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet　numbers　=　new　TreeSet<>();
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(5);
　　　　　　　　numbers.add(4);
　　　　　　　　numbers.add(6);
　　　　　　　　System.out.println("TreeSet: "　+　numbers);
　　　　　　　　//　Verwendung von subSet() mit dem Standard-Boolschen-Wert
　　　　　　　　System.out.println("subSet() verwendet den Standard-Boolschen-Wert: ")　+　numbers.subSet(4,　6));
　　　　　　　　//　使用　subSet()　使用指定的布尔值
　　　　　　　　System.out.println("subSet()使用指定的布尔值:　"　+　numbers.subSet(4,　false,　6,　true));
　　　　}
}

Output Result

TreeSet:　[2,　4,　5,　6]
subSet()使用默认布尔值:　[4,　5]
subSet()使用指定的布尔值:　[5,　6]

Set操作方法

TreeSet类的方法还可以用于执行各种集合操作。

集合的并集

为了执行两个集合之间的并集，我们使用 addAll()方法。例如，

import　java.util.TreeSet;;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet　evenNumbers　=　new　TreeSet<>();
　　　　　　　　evenNumbers.add(2);
　　　　　　　　evenNumbers.add(4);
　　　　　　　　System.out.println("TreeSet1:　"　+　evenNumbers);
　　　　　　　　TreeSet　numbers　=　new　TreeSet<>();
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(3);
　　　　　　　　System.out.println("TreeSet2:　"　+　numbers);
　　　　　　　　//两个集合的并集
　　　　　　　　numbers.addAll(evenNumbers);
　　　　　　　　System.out.println("Union　is:　"　+　numbers);
　　　　}
}

Output Result

TreeSet1: [2,　4]
TreeSet2: [1,　2,　3]
并集:　[1,　2,　3,　4]

集合的交集

为了执行两个集合之间的交集，我们使用retainAll()方法。例如，

import　java.util.TreeSet;;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet　evenNumbers　=　new　TreeSet<>();
　　　　　　　　evenNumbers.add(2);
　　　　　　　　evenNumbers.add(4);
　　　　　　　　System.out.println("TreeSet1:　"　+　evenNumbers);
　　　　　　　　TreeSet　numbers　=　new　TreeSet<>();
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(3);
　　　　　　　　System.out.println("TreeSet2:　"　+　numbers);
　　　　　　　　//　两个集合的交集
　　　　　　　　numbers.retainAll(evenNumbers);
　　　　　　　　System.out.println("集合的交集:　"　+　numbers);
　　　　}
}

Output Result

TreeSet1: [2,　4]
TreeSet2: [1,　2,　3]
集合的交集:　[2]

集合的差集

要计算两组之间的差集，我们可以使用removeAll()方法。例如，

import　java.util.TreeSet;;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet　evenNumbers　=　new　TreeSet<>();
　　　　　　　　evenNumbers.add(2);
　　　　　　　　evenNumbers.add(4);
　　　　　　　　System.out.println("TreeSet1:　"　+　evenNumbers);
　　　　　　　　TreeSet　numbers　=　new　TreeSet<>();
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(3);
　　　　　　　　numbers.add(4);
　　　　　　　　System.out.println("TreeSet2:　"　+　numbers);
　　　　　　　　//集合的差集
　　　　　　　　numbers.removeAll(evenNumbers);
　　　　　　　　System.out.println("差集:　"　+　numbers);
　　　　}
}

Output Result

TreeSet1: [2,　4]
TreeSet2: [1,　2,　3,　4]
差集:　[1,　3]

集合的子集

为了检查一个集合是否是另一个集合的子集，我们使用containsAll()方法。例如，

import java.util.TreeSet;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　TreeSet　numbers　=　new　TreeSet<>();
　　　　　　　　numbers.add(1);
　　　　　　　　numbers.add(2);
　　　　　　　　numbers.add(3);
　　　　　　　　numbers.add(4);
　　　　　　　　System.out.println("TreeSet1:　"　+　numbers);
　　　　　　　　TreeSet　primeNumbers　=　new　TreeSet<>();
　　　　　　　　primeNumbers.add(2);
　　　　　　　　primeNumbers.add(3);
　　　　　　　　System.out.println("TreeSet2:　"　+　primeNumbers);
　　　　　　　　//检查primeNumbers是否为numbers子集
　　　　　　　　boolean　result　=　numbers.containsAll(primeNumbers);
　　　　　　　　System.out.println("TreeSet2Ist TreeSet1Ist das ein Unterensemble? "　+　result);
　　　　}
}

Output Result

TreeSet1: [1,　2,　3,　4]
TreeSet2: [2,　3]
TreeSet2Ist TreeSet1Ist das ein Unterensemble? True

Andere Methoden von TreeSet

TreeSet vs. HashSet

TreeSet und HashSet implementieren beide das Set-Interface. Allerdings gibt es zwischen ihnen einige Unterschiede.

• Im Gegensatz zu HashSet werden die Elemente in TreeSet in einer bestimmten Reihenfolge gespeichert. Dies liegt daran, dass TreeSet auch das SortedSet-Interface implementiert.

• TreeSet bietet einige leicht zu navigierende Methoden. Zum Beispiel first(), last(), headSet(), tailSet() usw. Dies liegt daran, dass TreeSet auch das NavigableSet-Interface implementiert.

• Für grundlegende Operationen wie Hinzufügen, Entfernen, Enthält und Größe ist HashSet schneller als TreeSet.

TreeSet-Vergleichsoperator

In allen obigen Beispielen sind die Elemente des Baumsets in natürlicher Reihenfolge sortiert. Aber wir können auch die Reihenfolge der Elemente selbst definieren.

Daher müssen wir unsere own Comparator-Klasse erstellen, die auf die Sortierung der Elemente im Baumset basiert. Zum Beispiel

import java.util.TreeSet;
import java.util.Comparator;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Erstellen Sie einen TreeSet mit einem benutzerdefinierten Comparator
　　　　　　　　TreeSet<String> tiere = new TreeSet<>(new CustomComparator());
　　　　　　　　tiere.add("Hund");
　　　　　　　　tiere.add("Zebra");
　　　　　　　　tiere.add("Katze");
　　　　　　　　tiere.add("Pferd");
　　　　　　　　System.out.println("TreeSet: "　+　tiere);
　　　　}
　　　　//Erstellen Sie eine Vergleichsclasse
　　　　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;
　　　　　　　　　　　　}
　　　　　　　　}
　　　　}
}

Output Result

TreeSet: [Zebra, Horse, Dog, Cat]

In the above example, we create a TreeSet and pass the CustomComparator class as a parameter.

The CustomComparator class implements the Comparator interface.

Then, we rewrite the compare() method. Now, this method will sort the elements in reverse order.