devstory

Le Tutoriel de Java NavigableSet

View more Tutorials:

1- NavigableSet

NavigableSet est une sous-interface de SortedSet, qui fonctionne donc comme un SortedSet. Par ailleurs, il dispose de méthodes supplémentaires qui permettent de naviguer et de rechercher des éléments.
Par exemple: NavigableSet autorise l'accès et la navigation dans l'ordre croissant ou décroissant et fournit des méthodes telles que lower, floor, ceiling, higher,... pour trouver des éléments.
public interface NavigableSet<E> extends SortedSet<E>
Les caractéristiques sont héritées de SortedSet:
Set<E>SortedSet<E> / NavigableSet<E>

Les éléments dupliqués ne sont pas autorisés.
Si vous ajoutez intentionnellement un élément dupliqué à Set, cette action sera ignorée.

Similaire à Set.

Autoriser au maximum un élément null.

Autoriser au maximum un élément null.

L'ordre des éléments n'est pas garanti.

L'ordre des éléments est garanti.

Tous les éléments de SortedSet doivent être de type Comparable ou vous devez fournir un Comparator pour SortedSet pour qu'il puisse comparer les éléments.
  • TODO Link!
  • TODO Link!

2- NavigableSet Methods

Les méthodes de 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- L'élément null

La spécification de l'interface SortedSet et NavigableSet ne mentionne pas du tout les éléments null, ce qui signifie qu'ils peuvent autoriser au maximum un élément null (héritant de la spécification de l'interface Set). Par conséquent, si SortedSet et NavigabletSet autorisent ou non l'élément null, cela dépend de la classe qui implémente ces interfaces.
Dans Java Collection Framework, la classe TreeSet implémente l'interface NavigableSet, qui autorise l'élément null si vous lui attribuez un Comparator pour gérer la comparaison d'élément null avec ses autres éléments. Par aillleurs, ConcurrentSkipListSet implémente également l'interface NavigableSet mais n'autorise aucun élément null dans aucune situation.
Vous pouvez trouver des exemples à propos de NavigableSet et l'élément null dans l'article ci-dessous:

4- Examples

Par exemple: Un objet NavigableSet<Integer> contient les années où World Cup est célébrée. Utiliser certaines de ses méthodes pour naviguer et trouver l'élément requis.
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
Par exemple: La classe Player simule un joueur avec les informations suivantes: fullName, goldMedal, silverMedal, bronzeMedal (Nom et prénom, nombre de médailles d'or, d'argent et de bronze). La classe Player implémente l'interface Comparable<Player>, dont cela est comparable.
Le principe de comparaison de deux objets Player est celui-ci: Player avec plus de médailles d'or sera considéré comme plus haut classé, puis comparer le nombre de médailles d'argent, le nombre de médailles de bronze, le nom complet est le critère de comparaison final.
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);
    }
}
Par exemple: Un NavigableSet contient les objets 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
Voir plus d'exemples dans l'article sur SortedSet:

5- descendingSet()

public NavigableSet<E> descendingSet();
Par exemple:
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();
Renvoyer l'objet Iterator pour réitérer les éléments de NavigableSet dans l'ordre décroissant. Cela équivaut à la convocation de descendingSet().iterator().
Par exemple:
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);
Renvoyer une vue partielle de ce NavigableSet dont les éléments vont de fromElement à toElement. Cela inclut fromElement si fromInclusive est true. Cela inclut toElement si toInclusive est true.
NavigableSet renvoyé est relatif à l'actuel NavigableSet, les changements sur ce NavigableSet affectent à l'autre NavigableSet et inversement.
Par exemple:
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);
Renvoyer la vue partielle de ce NavigableSet, dont les éléments sont inférieurs (ou égaux, si inclusive est true) toElement.
NavigableSet renvoyé est relatif à l'actuel NavigableSet, les changements sur ce NavigableSet affectent à l'autre NavigableSet et inversement.

9- tailSet(E fromElement, boolean inclusive)

public NavigableSet<E> tailSet(E fromElement, boolean inclusive);
Renvoyer une vue partielle de ce NavigableSet, dont les éléments sont supérieurs (ou égaux, si inclusive est true) fromElement.
NavigableSet renvoyé est relatif à l'actuel NavigableSet, les changements sur ce NavigableSet affectent à l'autre NavigableSet et inversement.
Par exemple:
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);
Renvoyer les éléments les plus grands dans ce NavigableSet inférieur à l'élément donné, ou null s'il n'existe pas de tel élément.

11- higher(E e)

public E higher(E e);
Renvoyer l'élément le plus petit dans ce NavigableSet supérieur à l'élément donné, ou null s'il n'existe pas de tel élément.

12- floor(E e)

public E floor(E e);
Renvoyer l'élément le plus grand dans ce NavigableSet inférieur ou égal à l'élément donné, ou null s'il n'existe pas de tel élément.

13- ceiling(E e)

public E ceiling(E e);
Renvoyer l'élément le plus petit dans ce NavigableSet supérieur ou égal à l'élément donné, ou null s'il n'existe pas de tel élément.

14- pollFirst()

public E pollFirst();
Récupérer et supprimer le premier (le plus petit) élément, ou renvoyer à null si ce NavigableSet est vide.

15- pollLast()

public E pollLast();
Récupérer et supprimer le dernier (le plus grand) élément, ou renvoyer à null si ce NavigableSet est vide.

View more Tutorials:

Peut-être que vous êtes intéressé

Voici des leçons en ligne à part du site web o7planning que nous recommandons. La liste comprend des leçons en ligne et celles en promo.