codestory

Die Anleitung zu Java SortedSet

Folge uns auf unserer fanpage, um jedes Mal benachrichtigt zu werden, wenn es neue Artikel gibt. Facebook

1- SortedSet

SortedSet ist eine Unter-Interface von Set, daher hat es die vollständigen Eigenschaften von Set. Der Unterschied liegt darin, dass die Elemente von SortedSet in aufsteigender Reihenfolge nach ihrer natürlichen Reihenfolge oder nach einem bereitgestellten Comparator sortiert werden.
SortedSet sortiert die Elemente in aufsteigender Reihenfolge.

public interface SortedSet<E> extends Set<E>
Unten ist das der Vergleich zwischen Set und SortedSet:
Set<E>SortedSet<E> / NavigableSet<E>
Ein doppelte Elemente sind nicht zulässig. Wenn Sie Set absichtlich ein doppeltes Element hinzufügen, wird diese Aktion ignoriert.Ein doppelte Elemente sind nicht zulässig. Wenn Sie SortdSet absichtlich ein doppeltes Element hinzufügen, wird diese Aktion ignoriert.
Erlaube höchsten ein Element null.Erlaube höchsten ein Element null.
Die Reihenfolge der Elemente ist nicht garantiert.Die Reihenfolge der Elemente ist garantiert.
Alle Elemente von SortedSet müssen vom Typ Comparable (vergleichbar) sein, oder Sie müssen einen Comparator für SortedSet bereitstellen, damit die Elemente verglichen werden. Andernfalls wird ClassCastException ausgelöst.
Wenn Sie also ein Element zu SortedSet hinzufügen, können Sie dessen Position nicht angeben. Die Position des eingefügten Elements wird durch seine natürlichen Reihenfolge oder den bereitgestellten Comparator bestimmt.
SortedSet Methods

Comparator<? super E> comparator()

SortedSet<E> subSet(E fromElement, E toElement)

SortedSet<E> headSet(E toElement)

SortedSet<E> tailSet(E fromElement)

E first()  

E last()  

default Spliterator<E> spliterator() 

2- Examples

Die folgende Klasse Employee simuliert einen Mitarbeiter mit der Information von fullName und salary. Die Klasse Employee implementiert die Interface Comparable<Employee>. Dies bedeutet, dass die Objekte Employee vergleichbar sind.
Zwei Objekte Employee können gemäß dieser Regel miteinander verglichen werden: Vergleichen nach salary, wenn sie dasselbe salary haben, wird fullName verwendet zu vergleichen.
Employee.java

package org.o7planning.bean;

public class Employee implements Comparable<Employee> {

    private String fullName;
    private float salary;

    public Employee(String name, float salary) {
        this.fullName = name;
        this.salary = salary;
    }

    public String getFullName() {
        return fullName;
    }

    public float getSalary() {
        return salary;
    }
    
    // Implements method of Comparable<Employee>
    @Override
    public int compareTo(Employee o) {
        float delta = this.salary - o.salary;
        if (delta > 0) {
            return 1;
        } else if (delta < 0) {
            return -1;
        }
        return this.fullName.compareTo(o.fullName);
    }
}
Comparable<Employee>
Beispiel: Wenn Sie TreeSet zum Speichern von Objekten Employee verwenden, werden diese in aufsteigender Reihenfolge sortiert.
SortedSetEx1.java

package org.o7planning.sortedset.ex;

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

import org.o7planning.bean.Employee;

public class SortedSetEx1 {

    public static void main(String[] args) {
        Employee e1 = new Employee("Tom A", 5000);
        Employee e2 = new Employee("Jerry A", 1000);
        Employee e3 = new Employee("Tom B", 1000);
        Employee e4 = new Employee("Jerry B", 5000);
        Employee e5 = new Employee("Donald A", 1000);
        
        SortedSet<Employee> employees = new TreeSet<Employee>();
        
        employees.add(e1);
        employees.add(e2);
        employees.add(e3);
        employees.add(e4);
        employees.add(e5);

        for(Employee e: employees)  {
            System.out.println(e.getSalary() + " / " + e.getFullName());
        }
    }
}
Output:

1000.0 / Donald A
1000.0 / Jerry A
1000.0 / Tom B
5000.0 / Jerry B
5000.0 / Tom A
Comparable<String>
Die Objekte String sind auch nach Alphabet vergleichbar.
SortedSetEx2.java

package org.o7planning.sortedset.ex;

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

public class SortedSetEx2 {

    public static void main(String[] args) {   
        SortedSet<String> flowers = new TreeSet<String>();
        
        flowers.add("Rose");
        flowers.add("Lily");
        flowers.add("Tulip");
        flowers.add("Orchid");
        flowers.add("Carnation");
        flowers.add("Hyacinth");
        flowers.add("Peruvian");

        for(String flower: flowers)  {
            System.out.println(flower);
        }
    }  
}
Output:

Carnation
Hyacinth
Lily
Orchid
Peruvian
Rose
Tulip
Comparator<E>
Die folgende Klasse Staff implementiert keine Interface Comparable, sodass die Objekte  Staff nicht miteinander verglichen werden können. Wenn die Objekte Staff in einem SortedSet speichern möchten, müssen Sie einen Comparator anbieten.
Staff.java

package org.o7planning.bean;

public class Staff {
    private String fullName;
    private float salary;
    public Staff(String fullName, float salary) {
        super();
        this.fullName = fullName;
        this.salary = salary;
    }
    public String getFullName() {
        return fullName;
    }
    public float getSalary() {
        return salary;
    }
}
Die Klasse MyStaffComparator erlaubt 2 Objekte Staff nach salary und fullName zu vergleichen.
MyStaffComparator.java

package org.o7planning.sortedset.ex;

import java.util.Comparator;

import org.o7planning.bean.Staff;

public class MyStaffComparator implements Comparator<Staff> {

    @Override
    public int compare(Staff o1, Staff o2) {
        float delta = o1.getSalary() - o2.getSalary();
        if (delta > 0) {
            return 1;
        } else if (delta < 0) {
            return -1;
        }
        return o1.getFullName().compareTo(o2.getFullName());
    }
}
SortedSetEx3.java

package org.o7planning.sortedset.ex;

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

import org.o7planning.bean.Staff;

public class SortedSetEx3 {

    public static void main(String[] args) {
        Staff e1 = new Staff("Tom A", 5000);
        Staff e2 = new Staff("Tom A", 2000);
        Staff e3 = new Staff("Jerry A", 1000);
        Staff e4 = new Staff("Tom B", 1000);
        Staff e5 = new Staff("Jerry B", 5000);
        Staff e6 = new Staff("Donald A", 1000);

        // Custom Comparator.
        MyStaffComparator comparator = new MyStaffComparator();
        // A SortedSet with specified Comparator.
        SortedSet<Staff> employees = new TreeSet<Staff>(comparator);

        employees.add(e1);
        employees.add(e2);
        employees.add(e3);
        employees.add(e4);
        employees.add(e5);
        employees.add(e6);

        for (Staff e : employees) {
            System.out.println(e.getSalary() + "/" + e.getFullName());
        }
    }
}
Output:

1000.0/Donald A
1000.0/Jerry A
1000.0/Tom B
2000.0/Tom A
5000.0/Jerry B
5000.0/Tom A
Comparator ist eine functional interface, Deshalb können Sie das Objekt Comparator nach der Syntax Lambda erstellen. OK, schreiben Sie das obigen Beispiel kürzer:
SortedSetEx3A.java

package org.o7planning.sortedset.ex;

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

import org.o7planning.bean.Staff;

public class SortedSetEx3A {

    public static void main(String[] args) {
        Staff e1 = new Staff("Tom A", 5000);
        Staff e2 = new Staff("Tom A", 2000);
        Staff e3 = new Staff("Jerry A", 1000);
        Staff e4 = new Staff("Tom B", 1000);
        Staff e5 = new Staff("Jerry B", 5000);
        Staff e6 = new Staff("Donald A", 1000);

        // Custom Comparator.
        Comparator<Staff> comparator = (s1, s2) -> {
            float delta = s1.getSalary() - s2.getSalary();
            if (delta > 0) {
                return 1;
            } else if (delta < 0) {
                return -1;
            }
            return s1.getFullName().compareTo(s2.getFullName());
        };
        // A SortedSet with specified Comparator.
        SortedSet<Staff> employees = new TreeSet<Staff>(comparator);

        employees.add(e1);
        employees.add(e2);
        employees.add(e3);
        employees.add(e4);
        employees.add(e5);
        employees.add(e6);

        for (Staff e : employees) {
            System.out.println(e.getSalary() + "/" + e.getFullName());
        }
    }
}

3- Das Element null

In der Spezifikation der Interface SortedSet und NavigableSet wird das Element null überhaupt erwähnt. Das bedeutet, dass sie höchsten ein Element null zulassen können (Erben aus der Spezifikation der Interface Set). Ob SortedSet und NavigabletSet deshalb das Element null zulassen oder nicht, hängt von der Klasse ab, die diese Interface implementiert.
Im Java Collection Framework implementiert die Klasse TreeSet die Interface NavigableSet, und erlaubt das Element null wenn Sie ihm einen Comparator geben, um den Vergleich zwischen das Element null mit den anderen Elementen durchzuführen. Inzwischen implementiert ConcurrentSkipListSet auch die Interface NavigableSet , lässt jedoch keine Situation ein Element null zu.
Sehen Sie ein Beispiel über TreeSet und das Element null.
Circle.java

package org.o7planning.bean;

public class Circle  {
    private double radius;

    public Circle(double radius) {
        super();
        this.radius = radius;
    }

    public double getRadius() {
        return radius;
    }
}
Die Klasse CircleComparator implementiert die Interface Comparator<Circle>, mit der 2 Objekte Circle verglichen werden können, einschließlich das Objekt null:
CircleComparator.java

package org.o7planning.sortedset.ex;

import java.util.Comparator;

import org.o7planning.bean.Circle;

public class CircleComparator implements Comparator<Circle> {

    @Override
    public int compare(Circle o1, Circle o2) {
        if (o1 == null && o2 == null) {
            return 0;
        }
        if (o1 == null) {
            return -1; // o1 < o2
        } else if (o2 == null) {
            return 1; // o1 > o2
        }
        double delta = o1.getRadius() - o2.getRadius();
        if (delta < 0) {
            return -1; // o1 < o2
        } else if (delta > 0) {
            return 1; // o1 > o2
        }
        return 0;
    }
}
Z.B: Ein Objekt TreeSet enthaltet das Element null:
SortedSet_null_element_ex1.java

package org.o7planning.sortedset.ex;

import java.util.TreeSet;

import org.o7planning.bean.Circle;

public class SortedSet_null_element_ex1 {

    public static void main(String[] args) {
        Circle c1 = new Circle(3);
        Circle c2 = new Circle(5);
        Circle c3 = new Circle(9);
        Circle c4 = new Circle(7);

        // Create a SortedSet with provided Comparator.
        TreeSet<Circle> set = new TreeSet<Circle>(new CircleComparator());

        set.add(null); // Add null Element
        set.add(c1);
        set.add(c2);
        set.add(c3);
        set.add(c4);

        for (Circle c : set) {
            System.out.println("Circle: " + (c == null?null : c.getRadius()));
        }
    }
}
Output:

Circle: null
Circle: 3.0
Circle: 5.0
Circle: 7.0
Circle: 9.0

4- subSet(E fromElement, E toElement)


public SortedSet<E> subSet(E fromElement, E toElement)
Gibt eine Ansicht des Teils von diesem SortedSet zurück, dessen Elemente von fromElement zu toElement (fromElement =< element < toElement) liegen. (Wenn fromElement und toElement gleich ist, gibt SortedSet leer zurück).
Das zurückgegebene SortedSet bezieht sich auf das aktuelle SortedSet , Die Änderungen an einem SortedSet wirken sich auf das andere  SortedSet aus und umgekehrt.
SortedSet_subSet_ex1.java

package org.o7planning.sortedset.ex;

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

public class SortedSet_subSet_ex1 {

    public static void main(String[] args) {  
        SortedSet<String> mySet = new TreeSet<String>();
        
        mySet.add("A");
        mySet.add("B");
        mySet.add("C");
        mySet.add("D");
        mySet.add("E");

        // A Sub Set
        SortedSet<String> subSet = mySet.subSet("B", "C1");
        
        System.out.println(" -- subSet --");
        for(String s: subSet)  {
            System.out.println(s);
        }
        
        subSet.add("B1");
        subSet.add("B2");
        
        System.out.println(" -- subSet (after adding elements to subSet) --");
        for(String s: subSet)  {
            System.out.println(s);
        }
        
        System.out.println(" -- mySet (after adding elements to subSet) --");
        for(String s: mySet)  {
            System.out.println(s);
        }
    }
}
Output:

 -- subSet --
B
C
 -- subSet (after adding elements to subSet) --
B
B1
B2
C
 -- mySet (after adding elements to subSet) --
A
B
B1
B2
C
D
E

5- headSet(E toElement)


public SortedSet<E> headSet(E toElement)
Gibt eine Ansicht des Teils dieses SortedSet zurück, dessen Elemente kleiner als toElement. (element < toElement) ist.
Das zurückgegeben SortedSet bezieht sich auf das aktuelle SortedSet. Die Änderungen an diesem SortedSet wirken sich auf das andere SortedSet aus und umgekehrt.
Zum Beispiel:
SortedSet_headSet_ex1.java

package org.o7planning.sortedset.ex;

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

public class SortedSet_headSet_ex1 {

    public static void main(String[] args) {
        SortedSet<String> mySet = new TreeSet<String>();

        mySet.add("A");
        mySet.add("B");
        mySet.add("C");
        mySet.add("D");
        mySet.add("D1");
        mySet.add("E");

        // A Head Set (elements < "D1")
        SortedSet<String> headSet = mySet.headSet("D1");

        System.out.println(" -- headSet --");
        for (String s : headSet) {
            System.out.println(s);
        }
    }
}
Output:

 -- headSet --
A
B
C
D

6- tailSet(E fromElement)


public SortedSet<E> tailSet(E fromElement)
Gibt eine Ansicht des Teils dieses SortedSet zurück, dessen Elemente größer als oder gleich wie fromElement. (element >= fromElement) ​​​​​​​sind.
Das zurückgegebene SortedSet bezieht sich auf das aktuelle SortedSet. Die Änderungen an einem SortedSet wirken sich auf das andere SortedSet aus und umgekehrt.

7- spliterator()


public default Spliterator<E> spliterator()
  • TODO Link?

8- first()


public E first()  
Gibt das erste Element (das kleinste) von SortedSet zurück.

9- last()


public E last()  
Gibt das letzte Element (das größte) von SortedSet zurück.
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.