codestory

Die Anleitung zu Java TreeSet

1- TreeSet

In diesem Arikel werden wir die Klasse TreeSet untersuchen, die eine Implementierung der Interface NavigableSet ist und sich im die Java Collection Framework befindet.
public class TreeSet<E> extends AbstractSet<E>
                    implements NavigableSet<E>, Cloneable, java.io.Serializable
Grundsätzlich lernen wir in diesem Artikel die Eigenschaften von TreeSet und wie es die Elemente speichert. Sie sollte die Grundlagen von Set lernen bevor Sie mit diesem Artikel fortfahren.
Die Eigenschaften von TreeSet:
Set<E>SortedSet<E>
NavigableSet<E>
TreeSet<E>
Doppelte Elemente sind nicht erlaubt. Wenn Sie absichtlich ein doppeltes Element hinzufügen, wird diese Aktion ignoriert.
Es ist höchsten ein Element null zulässig.Es ist höchsten ein Element null erlaubt und das Element null ist nur erlaubt wenn ein Comparator bereitgestellt wird.
Die Reihenfolge der Elemente wird nicht garantiert.Sortieren Sie die Elemente aufsteigend nach ihrer natürlichen Reihenfolge oder nach einem bereitgestellten Comparator .
erbt die Eigenschaften der Interface SortedSet. Alle Elemente von TreeSet müssen vom Typ Comparable (vergleichbar) sein oder Sie müssen einen Comparator (Vergleicher) für TreeSet bereitstellen, damit er die Element miteinander vergleicht. Andernfalls wird ClassCastException geworfen. Der Comparator wird zum Zeitpunkt der Erstellung vom Objekt TreeSet durch einen seiner Konstruktoren erstellt.
Die Konstruktoren von TreeSet:
TreeSet​(Comparator<? super E> comparator)   

// Using the same ordering as the specified sortedSet.
TreeSet​(SortedSet<E> sortedSet)    

TreeSet()     

TreeSet​(Collection<? extends E> c) 

2- Wie lagert TreeSet die Daten?

TreeSet<E> verwaltet ein internes Objekt TreeMap<E,Object> - internalMap. Alle Operationen auf TreeSet werden auf internalMap ausgeführt. Außerdem speichert TreeMap seine Daten in einer Baumstruktur, weshalb TreeSet den Namen trägt.
Um das Verständnis zu erleichtern, sehen Sie sich den Quellcode der Klasse java.util.TreeSet an. Sie werden sehen, dass sie sich wie ein Delegat des von ihr verwaltetten Objekt TreeMap verhält.
java.util.TreeSet class
public class TreeSet<E> extends AbstractSet<E>
                   implements NavigableSet<E>, Cloneable, java.io.Serializable {

    private static final Object PRESENT = new Object();
    
    private transient TreeMap<E,Object> internalMap;
    
    public boolean add(E e) {
        return this.internalMap.put(e, PRESENT)==null;
    }
    
    public boolean remove(Object o) {
        return this.internalMap.remove(o)==PRESENT;
    }
    
    public void clear() {
        this.internalMap.clear();
    }
    
     public E first() {
        return this.internalMap.firstKey();
    }
     
    public E last() {
        return this.internalMap.lastKey();
    }
    // Other methods..
}
TreeMap speichert seine Daten in einer Baumstruktur, die in meinem Artikel unten erklärt wird. Schau es dir bei Interesse an.

3- Examples

Wie wir alle wissen, implementiert die Klasse Integer die Interface Comparable, sodass die Objekte Integer miteinander verglichen werden können. TreeSet mit der Elementen vom Typ Integer ist nicht erforderlich, um einen Comparator bereitzustellen.
TreeSetEx1.java
package org.o7planning.treeset.ex;

import java.util.TreeSet;

public class TreeSetEx1 {

    public static void main(String[] args) {
        TreeSet<Integer> set = new TreeSet<>();
        //
        set.add(5);
        set.add(3);
        set.add(9);
        set.add(7);
        set.add(1);
        set.add(11);

        System.out.println(set);
    }
}
Output:
[1, 3, 5, 7, 9, 11]
Beispiel: Verwenden Sie einen benutzerdefinierten Comparator um die Reihenfolge der Elemente umzukehren.
TreeSet_reverseOrder_ex1.java
package org.o7planning.treeset.ex;

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

public class TreeSet_reverseOrder_ex1 {

    public static void main(String[] args) {
        Comparator<Integer> reverseOrderComparator = Comparator.reverseOrder();
        
        TreeSet<Integer> set = new TreeSet<>(reverseOrderComparator);
        //
        set.add(5);
        set.add(3);
        set.add(9);
        set.add(7);
        set.add(1);
        set.add(11);

        System.out.println(set);
    }
}
Output:
[11, 9, 7, 5, 3, 1]
Sehen Sie sich weitere Beispiel für die Verwendung eines benutzerdefinierten Comparator in TreeSet an und erfahren Sie, wie Sie die Elemente navigieren und finden.
  • TODO Link?

4- TreeSet mit der Element null

TreeSet lässt die Elemente null nur zu, wenn es mit einem Comparator ausgestattet ist, der den Vergleich von Elementen null mit anderen Elementen unterstützt.
TreeSet_nullElement_ex1.java
package org.o7planning.treeset.ex;

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

public class TreeSet_nullElement_ex1 {

    public static void main(String[] args) {
        // Comparator.nullsFirst
        // Comparator.nullsLast
        Comparator<String> comparator = Comparator.nullsFirst(Comparator.naturalOrder());

        // Create a SortedSet object.
        SortedSet<String> map = new TreeSet<String>(comparator);

        map.add("B");
        map.add("A");
        map.add("F");
        map.add(null);
        map.add("D");
        map.add("E");

        System.out.println(map);
    }
}
Output:
[null, A, B, D, E, F]
Z.B: Schreiben Sie einen benutzerdefinierten Comparator, der das Vergleichen von Elementen null mit anderen Elementen unterstützt:
TreeSet_nullElement_ex2.java
package org.o7planning.treeset.ex;

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

public class TreeSet_nullElement_ex2 {

    public static void main(String[] args) {
        Comparator<String> comparator = new StringNullComparator();

        // Create a SortedSet object.
        SortedSet<String> map = new TreeSet<String>(comparator);

        map.add("B");
        map.add("A");
        map.add("F");
        map.add(null);
        map.add("D");
        map.add("E");

        System.out.println(map);
    }
}

// The comparator supports null comparison.
class StringNullComparator implements Comparator<String> {

    @Override
    public int compare(String o1, String o2) {
        if (o1 == o2) {
            return 0; // o1 = o2
        }
        if (o1 == null) {
            return -1; // o1 < o2
        }
        if (o2 == null) {
            return 1; // o1 > o2
        }
        return o1.compareTo(o2);
    }
}
Output:
[null, A, B, D, E, F]
Vielleicht bist du interessiert

Das sind die Online-Courses außer der Website o7planning, die wir empfehlen. Sie können umsonst sein oder Discount haben.