codestory

Die Anleitung zu Java NavigableSet

1- NavigableSet

NavigableSet ist eine Unterinterface von SortedSet, deshalb funktioniert daher wie ein SortedSet. Außerdem verfügt es über die zusätzlichen Methoden, mit denen die Elemente navigiert und gefunden werden können.
Z.B: NavigableSet ermöglicht den Zugriff und die Navigation in die aufsteigende und absteigende Reihenfolge und bietet die Methoden wie lower, floor, ceiling, higher,.. um die Elemente zu finden.
public interface NavigableSet<E> extends SortedSet<E>
Die Eigenschaften werden von SortedSet geerbt:
Set<E>SortedSet<E> / NavigableSet<E>
Doppelte Elemente sind nicht zulässig.
Wenn Sie Set absichtlich ein doppeltes Element hinzufügen, wird diese Aktion ignoriert.
Ähnlich wie Set.
Erlaub höchsten ein Element null.Erlaub höchstens 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 sein, oder Sie müssen einen Comparator für  SortedSet bereitstellen, damit die Elemente verglichen werden.

2- NavigableSet Methods

Die Methode von NavigableSet:
E lower(E e);

E floor(E e);

E ceiling(E e);

E higher(E e);

E pollFirst();

E pollLast();

NavigableSet<E> descendingSet();

Iterator<E> descendingIterator();

NavigableSet<E> subSet(E fromElement, boolean fromInclusive,
                       E toElement,   boolean toInclusive);

NavigableSet<E> headSet(E toElement, boolean inclusive);

NavigableSet<E> tailSet(E fromElement, boolean inclusive);

// --- Methods inherited from SortedSet ------------------------------

Comparator<? super E> comparator();

E first();

E last();

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

SortedSet<E> headSet(E toElement);

SortedSet<E> tailSet(E fromElement);  

default Spliterator<E> spliterator();  

// --- Other ethods inherited from Set, Collection. ------------------
Iterator<E> iterator();
...

3- Das Element null

In der Spezifikation der Interface SortedSet und NavigableSet werden überhaupt das Element null nicht erwähnt, was bedeutet, dass sie höchstens ein Element null zulassen können (erben aus der Spezifikation der Interface Set). Ob  SortedSet und NavigabletSet deshalb ein Element null zulassen oder nicht, hängt von der Klasse ab, die diese Interface implementiert.
In Java Collection Framework implementiert die Klasse TreeSet die Interface NavigableSet, das Element null zulässt, wenn Sie ihm einen Comparator geben, um den Vergleich zwischen das Element null mit den anderen Elementen durchzuführen. In der Zwischenzeit implementiert ConcurrentSkipListSet auch die Interface NavigableSet aber lässt in keiner Situation ein Element null zu.
Sie können die Beispiele über NavigableSet und das Element null im folgenden Artikel:

4- Examples

Z.B: Ein Objekt NavigableSet<Integer> , das die Jahre enthält, in denen World Cup stattgefundet wurde. Verwenden Sie einige seiner Methoden, um zu navigieren und das gewünschte Element zu finden. 
NavigableSetEx1.java
package org.o7planning.navigableset.ex;

import java.util.Arrays;
import java.util.List;
import java.util.NavigableSet;
import java.util.TreeSet;

public class NavigableSetEx1 {

    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1970, 1966, 1962, 1958, 1954, 1950, 1938, 1934, 1930);

        // A sorted set in ascending order.
        NavigableSet<Integer> worldCupYears = new TreeSet<Integer>(list);

        System.out.println("World Cup Years: " + worldCupYears);

        // Get a reverse view of the navigable set
        NavigableSet<Integer> reverseYears = worldCupYears.descendingSet();

        System.out.println("Reverse of World Cup Years: " + reverseYears);

        // World Cup Years >= 1935
        NavigableSet<Integer> tailSet1 = worldCupYears.tailSet(1935, true);
        System.out.println("World Cup Years >= 1935: " + tailSet1);

        // World Cup Years <= 1958
        NavigableSet<Integer> headSet1 = worldCupYears.headSet(1938, true);
        System.out.println("World Cup Years <= 1938: " + headSet1);

        // The first year of the World Cup after 1938.
        int year1 = worldCupYears.higher(1938);
        System.out.println("The first year of the World Cup after 1938: " + year1);

        // The last year of the World Cup before 1950.
        int year2 = worldCupYears.lower(1950);
        System.out.println("The last year of the World Cup before 1950: " + year2);
    }
}
Output:
World Cup Years: [1930, 1934, 1938, 1950, 1954, 1958, 1962, 1966, 1970]
Reverse of World Cup Years: [1970, 1966, 1962, 1958, 1954, 1950, 1938, 1934, 1930]
World Cup Years >= 1935: [1938, 1950, 1954, 1958, 1962, 1966, 1970]
World Cup Years <= 1938: [1930, 1934, 1938]
The first year of the World Cup after 1938: 1950
The last year of the World Cup before 1950: 1938
Zum Beispiel: Die Klasse Player simuliert einen Spieler mit den Informationen fullName, goldMedal, silverMedal, bronzeMedal (vollständiger Name, Anzahl der Goldmedaillen, Anzahl der Silbermedaillen, Anzahl der Bronzemedaillen). Die Klasse Player implementiert die Interface Comparable<Player>, deshalb ist sie vergleichbar.
Das Prinzip des Vergleich zweier Objekte Player basiert auf dem Prinzip: Player mit mehr Goldmedaillen haben einen höheren Rang. Vergleichen Sie dann die Anzahl der Silbermedaillen, die Anzahl der Bronzemedaillien und den Name als letztes Vergleichskriterium.
Player.java
package org.o7planning.beans;

public class Player implements Comparable<Player> {

    private String fullName;
    private int goldMedal;
    private int silverMedal;
    private int bronzeMedal;

    public Player(String fullName, int goldMedal, int silverMedal, int bronzeMedal) {
        this.fullName = fullName;
        this.goldMedal = goldMedal;
        this.silverMedal = silverMedal;
        this.bronzeMedal = bronzeMedal;
    }

    public String getFullName() {
        return fullName;
    }

    public int getGoldMedal() {
        return goldMedal;
    }

    public int getSilverMedal() {
        return silverMedal;
    }

    public int getBronzeMedal() {
        return bronzeMedal;
    }

    @Override
    public int compareTo(Player o) {
        int g = this.goldMedal - o.goldMedal;
        if (g != 0) {
            return g;
        }
        int s = this.silverMedal - o.silverMedal;
        if (s != 0) {
            return s;
        }
        int b = this.bronzeMedal - o.bronzeMedal;
        if (b != 0) {
            return b;
        }
        return this.fullName.compareTo(o.fullName);
    }
}
Zum Beispiel: Ein NavigableSet enthält die Objekte Player:
NavigableSetEx2.java
package org.o7planning.navigableset.ex;

import java.util.NavigableSet;
import java.util.TreeSet;

import org.o7planning.beans.Player;

public class NavigableSetEx2 {

    public static void main(String[] args) {
        Player tomA = new Player("Tom A", 3, 1, 4);
        Player tomB = new Player("Tom B", 2, 5, 1);
        Player jerryA = new Player("Jerry A", 1, 2, 4);
        Player jerryB = new Player("Jerry B", 3, 2, 3);
        Player donaldA = new Player("Donald A", 2, 2, 1);
        

        // A sorted set in ascending order.
        NavigableSet<Player> players = new TreeSet<Player>();

        players.add(tomA);
        players.add(tomB);
        players.add(jerryA);
        players.add(jerryB);
        players.add(donaldA);
        
        System.out.println("--- Players (in ascending order) ---");
        for(Player p: players)  {
            System.out.println(p.getGoldMedal()  + " : " + p.getSilverMedal() //
                 +" : " + p.getBronzeMedal() +" - " + p.getFullName());
        }
        
        System.out.println();
        System.out.println("--- Players in decending order ---");
        NavigableSet<Player> decendingPlayers = players.descendingSet();
        
        for(Player p: decendingPlayers)  {
            System.out.println(p.getGoldMedal()  + " : " + p.getSilverMedal() //
                 +" : " + p.getBronzeMedal() +" - " + p.getFullName());
        }
    }
}
Output:
--- Players (in ascending order) ---
1 : 2 : 4 - Jerry A
2 : 2 : 1 - Donald A
2 : 5 : 1 - Tom B
3 : 1 : 4 - Tom A
3 : 2 : 3 - Jerry B

--- Players in decending order ---
3 : 2 : 3 - Jerry B
3 : 1 : 4 - Tom A
2 : 5 : 1 - Tom B
2 : 2 : 1 - Donald A
1 : 2 : 4 - Jerry A
Sehen Sie weitere Beispiele im Artikel über SortedSet:

5- descendingSet()

public NavigableSet<E> descendingSet();
Zum Beispiel:
NavigableSet_descendingSet_ex1.java
package org.o7planning.navigableset.ex;

import java.util.Arrays;
import java.util.List;
import java.util.NavigableSet;
import java.util.TreeSet;

public class NavigableSet_descendingSet_ex1 {

    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1970, 1966, 1962, 1958, 1954, 1950, 1938, 1934, 1930);

        // A sorted set in ascending order.
        NavigableSet<Integer> worldCupYears = new TreeSet<Integer>(list);

        System.out.println("worldCupYears: " + worldCupYears);

        // Get a reverse view of the navigable set
        NavigableSet<Integer> reverseYears = worldCupYears.descendingSet();
        
        System.out.println("reverseYears: " + reverseYears);
        System.out.println();

        System.out.println("Add year 1998");
        reverseYears.add(1998); // World Cup 1998 in France.
        
        System.out.println();
        System.out.println("worldCupYears: " + worldCupYears);
        
        System.out.println("reverseYears: " + reverseYears);
    }
}
Output:
worldCupYears: [1930, 1934, 1938, 1950, 1954, 1958, 1962, 1966, 1970]
reverseYears: [1970, 1966, 1962, 1958, 1954, 1950, 1938, 1934, 1930]

Add year 1998

worldCupYears: [1930, 1934, 1938, 1950, 1954, 1958, 1962, 1966, 1970, 1998]
reverseYears: [1998, 1970, 1966, 1962, 1958, 1954, 1950, 1938, 1934, 1930]

6- descendingIterator()

public Iterator<E> descendingIterator();
Gibt das Objekt Iterator zurück um die Elemente von NavigableSet in absteigender Reihenfolge zu iterieren. Es entspricht dem Aufruf von  descendingSet().iterator().
Zum Beispiel:
NavigableSet_descendingIterator_ex1.java
package org.o7planning.navigableset.ex;

import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.NavigableSet;
import java.util.TreeSet;

public class NavigableSet_descendingIterator_ex1 {

    public static void main(String[] args) {
        List<String> list = Arrays.asList("A1", "A2", "C1", "B1", "B2", "D1");

        // A sorted set in ascending order.
        NavigableSet<String> strings = new TreeSet<String>(list);

        System.out.println("NavigableSet: " + strings);
        System.out.println();

        
        Iterator<String> iter = strings.descendingIterator();
        
        while(iter.hasNext()) {
            System.out.println(iter.next());
        }
    }
}
Output:
NavigableSet: [A1, A2, B1, B2, C1, D1]

D1
C1
B2
B1
A2
A1

7- subSet(..)

public NavigableSet<E> subSet(E fromElement, boolean fromInclusive,E toElement,  boolean toInclusive);
Gibt die Ansicht einer Teil von NavigableSet zurück, dessen Elemente vom fromElement zu toElement reichen. Einschließlich fromElement wenn fromInclusive  true ist, einschließlich toElement wenn toInclusive true ist.
NavigableSet bezieht sich auf das aktuelle NavigableSet. Die Änderungen an NavigableSet wirken sich auf das andere NavigableSet und umgekehrt.
Zum Beispiel:
NavigableSet_subSet_ex1.java
package org.o7planning.navigableset.ex;

import java.util.Arrays;
import java.util.List;
import java.util.NavigableSet;
import java.util.TreeSet;

public class NavigableSet_subSet_ex1 {

    public static void main(String[] args) {
        
        List<Integer> list = Arrays.asList(1986, 1990, 1994,1998,2010, 2014, 2018); // Without: 2006,2002 (!)

        // A sorted set in ascending order.
        NavigableSet<Integer> worldCupYears = new TreeSet<Integer>(list);

        System.out.println("worldCupYears: " + worldCupYears);
        
        NavigableSet<Integer> subSet = worldCupYears.subSet(1994, true, 2010, true);
        
        System.out.println("subSet: " + subSet);
        System.out.println();
 

        System.out.println("Add years 2002,2006 to subSet");
        subSet.add(2002); // World Cup 2002 in South Korea, Japan.
        subSet.add(2006); // World Cup 2006 in Germany.
        
        System.out.println();
        System.out.println("worldCupYears: " + worldCupYears);
        System.out.println("subSet: " + subSet);
    }
}
Output:
worldCupYears: [1986, 1990, 1994, 1998, 2010, 2014, 2018]
subSet: [1994, 1998, 2010]

Add years 2002,2006 to subSet

worldCupYears: [1986, 1990, 1994, 1998, 2002, 2006, 2010, 2014, 2018]
subSet: [1994, 1998, 2002, 2006, 2010]

8- headSet(E toElement, boolean inclusive)

public NavigableSet<E> headSet(E toElement, boolean inclusive);
Gibt eine Ansicht des Teils vom NavigableSet, einschließlich die Elemente, die als (oder gleich, wenn inclusive  true ist) toElement ​​​​​​​sind.
Das zurückgegeben NavigableSet bezieht sich auf das aktuelle NavigableSet. Die Änderungen an einem NavigableSet wirken sich auf das andere NavigableSet aus und umgekehrt.

9- tailSet(E fromElement, boolean inclusive)

public NavigableSet<E> tailSet(E fromElement, boolean inclusive);
Gibt eine Ansicht des Teils von NavigableSet, einschließlich der Elemente, die größer als (oder gleich, wenn inclusive  true ist) fromElement ist.
Das zurückgegebene NavigableSet bezieht sich auf das aktuelle NavigableSet. Die Änderungen an NavigableSet wirken sich auf das andere NavigableSet und umgekehrt.
Zum Beispiel:
NavigableSet_tailSet_ex1.java
package org.o7planning.navigableset.ex;

import java.util.NavigableSet;
import java.util.TreeSet;

public class NavigableSet_tailSet_ex1 {

    public static void main(String[] args) {
        NavigableSet<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 >= "C")
        NavigableSet<String> tailSet = mySet.tailSet("C", true);

        System.out.println(" -- tailSet --");
        for (String s : tailSet) {
            System.out.println(s);
        }
        // Remove some elements from tailSet
        tailSet.remove("D");
        tailSet.remove("D1");
        
        System.out.println();
        System.out.println(" -- mySet (After remove some elements from tailSet --");
        for (String s : mySet) {
            System.out.println(s);
        }
    }
}
Output:
 -- tailSet --
C
D
D1
E

 -- mySet (After remove some elements from tailSet --
A
B
C
E

10- lower(E e)

public E lower(E e);
Gibt das größte Element in diesem NavigableSet zurück, das kleiner als das angegebene Element ist, oder null wenn es kein solches Element gibt.

11- higher(E e)

public E higher(E e);
Gibt das kleinste Element in diesem NavigableSet zurück, das größer als das angegebene Element ist, oder null wenn es kein solches Element gibt.

12- floor(E e)

public E floor(E e);
Gibt das größte Element in diesem NavigableSet zurück, das kleiner oder gleich dem angegebenen Element ist, oder null wenn es kein solches Element gibt.

13- ceiling(E e)

public E ceiling(E e);
Gibt das kleinste Element in diesem NavigableSet zurück, das größer als oder gleich dem angegebenen Element ist, oder null wenn es kein solches Element gibt.

14- pollFirst()

public E pollFirst();
Ruft das erste (kleinste) Element ab und entfernt es oder gibt null zurück wenn dieses NavigableSet leer ist.

15- pollLast()

public E pollLast();
Ruft das letzte (größte) Element ab und entfernt es oder gibt null zurück wenn NavigableSet leer ist.
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.