devstory

Le Tutoriel de Java NavigableMap

Suivez-nous sur notre fanpage pour recevoir des notifications chaque fois qu'il y a de nouveaux articles. Facebook

1- NavigableMap

NavigableMap est une sous-interface de l'interface SortedMap, elle fonctionne donc comme une SortedMap. De plus, elle est complétée par des méthodes permettant de naviguer, de rechercher des clés et des mappages.
Par exemple, NavigableMap autorise la navigation dans l'ordre croissant ou décroissant de clefs, fournit les méthodes telles que lowerKey, floorKey, ceilingKey, higherKey, lowerEntry, floorEntry, ceilingEntry, higherEntry.. pour chercher les clefs et les mappages.

public interface NavigableMap<K,V> extends SortedMap<K,V>
Map<K,V>SortedMap<K,V>
NavigableMap<K,V>
Les clefs dupliquées ne sont pas autorisées
Autoriser la clef null et les valeurs null.
L'ordre des clefs n'est pas autorisé.
Les clefs sont classées dans l'ordre croissant en fonction de leur ordre naturel ou d'un Comparator fourni.
Toutes les clefs de NavigableMap/SortedMap doivent être de type Comparable ou vous devez fournir un Comparator à NavigableMap/SortedMap pour qu'elle compare les clefs. A l'inverse, ClassCastException sera levée.

2- NavigableMap Methods


Map.Entry<K,V> firstEntry();
Map.Entry<K,V> lastEntry();
Map.Entry<K,V> pollFirstEntry();
Map.Entry<K,V> pollLastEntry();

Map.Entry<K,V> lowerEntry(K key);
Map.Entry<K,V> floorEntry(K key);
Map.Entry<K,V> ceilingEntry(K key);
Map.Entry<K,V> higherEntry(K key);

K lowerKey(K key);
K floorKey(K key);
K ceilingKey(K key);
K higherKey(K key);  

NavigableMap<K,V> descendingMap();
NavigableSet<K> navigableKeySet();
NavigableSet<K> descendingKeySet();

NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive,
                        K toKey,   boolean toInclusive);

NavigableMap<K,V> headMap(K toKey, boolean inclusive);
NavigableMap<K,V> tailMap(K fromKey, boolean inclusive);

// Inherited from SortedSet:
SortedMap<K,V> subMap(K fromKey, K toKey);
SortedMap<K,V> headMap(K toKey);
SortedMap<K,V> tailMap(K fromKey);
...

3- Examples

Par exemple: Un objet NavigableMap<Integer,String>  contient les mappages entre l'année où World Cup est organisée et le pays d'accueil. On utilise certaines de ses méthodes pour naviguer et trouver les clefs et les mappages.
NavigableMapEx1.java

package org.o7planning.navigablemap.ex;

import java.util.Map;
import java.util.NavigableMap;
import java.util.TreeMap;

public class NavigableMapEx1 {

    public static void main(String[] args) {
        // Map: World Cup Year --> Country Name
        NavigableMap<Integer, String> worldCupMap = new TreeMap<>();

        worldCupMap.put(1934, "Italy");
        worldCupMap.put(1930, "Uruguay");
        worldCupMap.put(1970, "Mexico");
        worldCupMap.put(1966, "England");
        worldCupMap.put(1962, "Chile");
        worldCupMap.put(1958, "Sweden");
        worldCupMap.put(1954, "Switzerland");
        worldCupMap.put(1950, "Brazil");
        worldCupMap.put(1938, "France");

        System.out.println("--- World Cup Map ---:");
        printMap(worldCupMap);

        // Get a reverse view of the navigable map.
        NavigableMap<Integer, String> reverseMap = worldCupMap.descendingMap();

        System.out.println("\n--- World Cup Map (Reverse View) ---:");
        printMap(reverseMap);

        // World Cup Map (Year >= 1935)
        NavigableMap<Integer, String> tailMap1 = worldCupMap.tailMap(1935, true);

        System.out.println("\n--- World Cup Map (Year >= 1935) ---:");
        printMap(tailMap1);

        // World Cup Map (Year <= 1958)
        NavigableMap<Integer, String> headMap1 = worldCupMap.headMap(1938, true);

        System.out.println("\n--- World Cup Map (Year <= 1938) ---:");
        printMap(headMap1);

        // The first year of the World Cup after 1938.
        int year1 = worldCupMap.higherKey(1938);
        System.out.printf("%nThe first year of the World Cup after 1938: %d%n", year1);

        // The last year of the World Cup before 1950.
        int year2 = worldCupMap.lowerKey(1950);
        System.out.printf("%nThe last year of the World Cup before 1950: %d%n", year2);

        // The first World Cup after 1938.
        Map.Entry<Integer, String> e1 = worldCupMap.higherEntry(1938);
        System.out.printf("%nThe first World Cup after 1938: %d --> %s%n", e1.getKey(), e1.getValue());

        // The last World Cup before 1950.
        Map.Entry<Integer, String> e2 = worldCupMap.lowerEntry(1950);
        System.out.printf("%nThe last World Cup before 1950: %d --> %s%n", e2.getKey(), e2.getValue());
    }

    private static void printMap(Map<Integer, String> map) {
        for (Map.Entry<Integer, String> entry : map.entrySet()) {
            System.out.println(entry.getKey() + " --> " + entry.getValue());
        }
    }
}
Output:

--- World Cup Map ---:
1930 --> Uruguay
1934 --> Italy
1938 --> France
1950 --> Brazil
1954 --> Switzerland
1958 --> Sweden
1962 --> Chile
1966 --> England
1970 --> Mexico

--- World Cup Map (Reverse View) ---:
1970 --> Mexico
1966 --> England
1962 --> Chile
1958 --> Sweden
1954 --> Switzerland
1950 --> Brazil
1938 --> France
1934 --> Italy
1930 --> Uruguay

--- World Cup Map (Year >= 1935) ---:
1938 --> France
1950 --> Brazil
1954 --> Switzerland
1958 --> Sweden
1962 --> Chile
1966 --> England
1970 --> Mexico

--- World Cup Map (Year <= 1938) ---:
1930 --> Uruguay
1934 --> Italy
1938 --> France

The first year of the World Cup after 1938: 1950

The last year of the World Cup before 1950: 1938

The first World Cup after 1938: 1950 --> Brazil

The last World Cup before 1950: 1938 --> France
Voir plus d'exemples sur l'utilisation de Comparator pour NavigableMap/SortedMap:

4- descendingMap()


NavigableMap<K,V> descendingMap();
Renvoyer une vue dans l'ordre inverse des mappages contenus dans cette NavigableMap. La NavigableMap renvoyée sera trié par ordre décroissant par clef.
La NavigableMap renvoyée est liée à la NavigableMap actuelle. Les changements sur une NavigableMap affectent l'autre NavigableMap et vice versa.
NavigableMap_descendingMap_ex1.java

package org.o7planning.navigablemap.ex;

import java.util.Map;
import java.util.NavigableMap;
import java.util.TreeMap;

public class NavigableMap_descendingMap_ex1 {

    public static void main(String[] args) {
        // Map: World Cup Year --> Country Name
        NavigableMap<Integer, String> worldCupMap = new TreeMap<>();

        worldCupMap.put(1934, "Italy");
        worldCupMap.put(1930, "Uruguay");
        worldCupMap.put(1970, "Mexico");
        worldCupMap.put(1966, "England");
        worldCupMap.put(1962, "Chile");
        worldCupMap.put(1958, "Sweden");
        worldCupMap.put(1954, "Switzerland");
        worldCupMap.put(1950, "Brazil");
        worldCupMap.put(1938, "France");

        System.out.println("--- World Cup Map ---:");
        printMap(worldCupMap);

        // Get a reverse view of the navigable map.
        NavigableMap<Integer, String> reverseMap = worldCupMap.descendingMap();

        System.out.println("\n--- World Cup Map (Reverse View) ---:");
        printMap(reverseMap);
    }

    private static void printMap(Map<Integer, String> map) {
        // Java 8 Syntax:
        map.entrySet().stream().forEach(entry -> {
            System.out.println(entry.getKey() + " --> " + entry.getValue());
        });
    }
}
Output:

--- World Cup Map ---:
1930 --> Uruguay
1934 --> Italy
1938 --> France
1950 --> Brazil
1954 --> Switzerland
1958 --> Sweden
1962 --> Chile
1966 --> England
1970 --> Mexico

--- World Cup Map (Reverse View) ---:
1970 --> Mexico
1966 --> England
1962 --> Chile
1958 --> Sweden
1954 --> Switzerland
1950 --> Brazil
1938 --> France
1934 --> Italy
1930 --> Uruguay

5- navigableKeySet()


NavigableSet<K> navigableKeySet();
Renvoyer une vue NavigableSet des clef contenues dans cette NavigableMap.
La NavigableMap renvoyée est liée à la NavigableMap actuelle. Les changements sur une NavigableMap affectent l'autre NavigableMap et vice versa.
  1. L'ajout ou la suppression d'un mappage de NavigableMap ajoutera ou supprimera un élément de NavigableSet.
  2. Les méthodes pour supprimer des éléments de NavigableSet tels que Set.iterator().remove, Set.remove, Set.removeAll, Set.retainAll, Set.clear.. suppriment les mappages correspondants de NavigableMap.
  3. Cet objet NavigableSet ne prend pas en charge les opérations Set.add, Set.addAll.
NavigableMap_navigableKeySet_ex1.java

package org.o7planning.navigablemap.ex;

import java.util.Map;
import java.util.NavigableMap;
import java.util.NavigableSet;
import java.util.TreeMap;

public class NavigableMap_navigableKeySet_ex1 {

    public static void main(String[] args) {
        // Map: World Cup Year --> Country Name
        NavigableMap<Integer, String> worldCupMap = new TreeMap<>();

        worldCupMap.put(1934, "Italy");
        worldCupMap.put(1930, "Uruguay");
        worldCupMap.put(1970, "Mexico");
        worldCupMap.put(1966, "England");
        worldCupMap.put(1962, "Chile");
        worldCupMap.put(1958, "Sweden");
        worldCupMap.put(1954, "Switzerland");
        worldCupMap.put(1950, "Brazil");
        worldCupMap.put(1938, "France");

        System.out.println("--- World Cup Map ---:");
        printMap(worldCupMap);

        NavigableSet<Integer> navigableSetYears = worldCupMap.navigableKeySet();
        System.out.println("\nYears: " + navigableSetYears);
        
        // Remove some years from NavigableSet navigableSetYears
        navigableSetYears.remove(1954);
        navigableSetYears.remove(1950);
        navigableSetYears.remove(1938);
        navigableSetYears.remove(1934);
        navigableSetYears.remove(1930);
        
        System.out.println("\n--- World Cup Map (After removing some years from NavigableSet) ---:");
        printMap(worldCupMap);
    }

    private static void printMap(Map<Integer, String> map) {
        // Java 8 Syntax:
        map.entrySet().stream().forEach(entry -> {
            System.out.println(entry.getKey() + " --> " + entry.getValue());
        });
    }
}
Output:

--- World Cup Map ---:
1930 --> Uruguay
1934 --> Italy
1938 --> France
1950 --> Brazil
1954 --> Switzerland
1958 --> Sweden
1962 --> Chile
1966 --> England
1970 --> Mexico

Years: [1930, 1934, 1938, 1950, 1954, 1958, 1962, 1966, 1970]

--- World Cup Map (After removing some years from NavigableSet) ---:
1958 --> Sweden
1962 --> Chile
1966 --> England
1970 --> Mexico

6- descendingKeySet()


NavigableSet<K> descendingKeySet();
Renvoyer une vue NavigableSet dans l'ordre inverse des clés contenues dans cette NavigableMap. C'est l'équivalent de l'appel de descendantingMap().navigableKeySet().
La NavigableMap renvoyée est liée à la NavigableMap actuelle. Les changements sur une NavigableMap affectent l'autre NavigableMap et vice versa.
  1. L'ajout ou la suppression d'un mappage de NavigableMap ajoutera ou supprimera un élément de NavigableSet.
  2. Les méthodes pour supprimer des éléments de NavigableSet telles que Set.iterator().remove, Set.remove, Set.removeAll, Set.retainAll, Set.clear.. suppriment les mappages correspondants de NavigableMap.
  3. Cet objet NavigableSet ne prend pas en charge les opérations Set.add, Set.addAll.
NavigableMap_descendingKeySet_ex1.java

package org.o7planning.navigablemap.ex;

import java.util.Iterator;
import java.util.Map;
import java.util.NavigableMap;
import java.util.NavigableSet;
import java.util.TreeMap;

public class NavigableMap_descendingKeySet_ex1 {

    public static void main(String[] args) {
        // Map: World Cup Year --> Country Name
        NavigableMap<Integer, String> worldCupMap = new TreeMap<>();

        worldCupMap.put(1934, "Italy");
        worldCupMap.put(1930, "Uruguay");
        worldCupMap.put(1970, "Mexico");
        worldCupMap.put(1966, "England");
        worldCupMap.put(1962, "Chile");
        worldCupMap.put(1958, "Sweden");
        worldCupMap.put(1954, "Switzerland");
        worldCupMap.put(1950, "Brazil");
        worldCupMap.put(1938, "France");

        System.out.println("--- World Cup Map ---:");
        printMap(worldCupMap);

        NavigableSet<Integer> descendingKeySetYears = worldCupMap.descendingKeySet();
        System.out.println("\nDescending Years: " + descendingKeySetYears);
        
        // Remove some years from NavigableSet descendingKeySetYears
        Iterator<Integer> iterator = descendingKeySetYears.iterator();
        
        while(iterator.hasNext())  {
            Integer year = iterator.next();
            if(year <= 1954) {
                iterator.remove();
            }
        }
        
        System.out.println("\n--- World Cup Map (After removing some years from NavigableSet) ---:");
        printMap(worldCupMap);
    }

    private static void printMap(Map<Integer, String> map) {
        // Java 8 Syntax:
        map.entrySet().stream().forEach(entry -> {
            System.out.println(entry.getKey() + " --> " + entry.getValue());
        });
    }
}
Output:

--- World Cup Map ---:
1930 --> Uruguay
1934 --> Italy
1938 --> France
1950 --> Brazil
1954 --> Switzerland
1958 --> Sweden
1962 --> Chile
1966 --> England
1970 --> Mexico

Descending Years: [1970, 1966, 1962, 1958, 1954, 1950, 1938, 1934, 1930]

--- World Cup Map (After removing some years from NavigableSet) ---:
1958 --> Sweden
1962 --> Chile
1966 --> England
1970 --> Mexico

7- subMap(K, boolean, K, boolean)


NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive,
                                                K toKey,   boolean toInclusive);
Renvoyer une vue d'une partie de ce NavigableMap qui inclut des mappages avec des clés allant de fromKey à toKey. Inclure fromKey si fromInclusive est true, y compris toKey si toInclusive est true.
La NavigableMap renvoyée est liée à la NavigableMap actuelle. Les changements sur une NavigableMap affectent l'autre NavigableMap et vice versa.
NavigableMap_subMap_ex1.java

package org.o7planning.navigablemap.ex;

import java.util.Map;
import java.util.NavigableMap;
import java.util.TreeMap;

public class NavigableMap_subMap_ex1 {

    public static void main(String[] args) {
        NavigableMap<String, String> myMap = new TreeMap<>();

        myMap.put("A", "VA");
        myMap.put("B", "VB");
        myMap.put("C", "VC");
        myMap.put("D", "VD");
        myMap.put("E", "VE");

        System.out.println(" -- myMap --");
        printMap(myMap);

        // A Sub Map ("B" <= key <= "C1")
        NavigableMap<String, String> subMap = myMap.subMap("B", true, "C1", true);

        System.out.println("\n -- subMap --");
        printMap(subMap);

        subMap.put("B1", "VB1");
        subMap.put("B2", "VB2");

        System.out.println("\n -- subMap (after putting some mappings to subMap) --");
        printMap(subMap);

        System.out.println("\n -- myMap (after putting some mappings to subMap) --");
        printMap(myMap);
    }

    private static void printMap(Map<String, String> map) {
        for (String s : map.keySet()) {
            System.out.println(s + " --> " + map.get(s));
        }
    }
}
Output:

 -- myMap --
A --> VA
B --> VB
C --> VC
D --> VD
E --> VE

 -- subMap --
B --> VB
C --> VC

 -- subMap (after putting some mappings to subMap) --
B --> VB
B1 --> VB1
B2 --> VB2
C --> VC

 -- myMap (after putting some mappings to subMap) --
A --> VA
B --> VB
B1 --> VB1
B2 --> VB2
C --> VC
D --> VD
E --> VE

8- headMap(K, boolean)


NavigableMap<K,V> headMap(K toKey, boolean inclusive);
Renvoyer une vue d'une partie de cette NavigableMap, y compris les mappages dont la clef est inférieure (ou égale, si inclusive est true) à toKey.
La NavigableMap renvoyée est liée à la NavigableMap actuelle. Les changements sur une NavigableMap affectent l'autre NavigableMap et vice versa.

9- tailMap(K, boolean)


NavigableMap<K,V> tailMap(K fromKey, boolean inclusive);
Renvoyer une vue d'une partie de cette NavigableMap, y compris les mappages dont la clé est supérieure (ou égale, si inclusive est true) fromKey.
La NavigableMap renvoyée est liée à la NavigableMap actuelle. Les changements sur une NavigableMap affectent l'autre NavigableMap et vice versa.
NavigableMap_tailMap_ex1.java

package org.o7planning.navigablemap.ex;

import java.util.Map;
import java.util.NavigableMap;
import java.util.TreeMap;

public class NavigableMap_tailMap_ex1 {

    public static void main(String[] args) {
        NavigableMap<String, String> myMap = new TreeMap<>();

        myMap.put("A", "VA");
        myMap.put("B", "VB");
        myMap.put("C", "VC");
        myMap.put("D", "VD");
        myMap.put("E", "VE");

        System.out.println(" -- myMap --");
        printMap(myMap);

        // A Tail Map (key >= "C")
        NavigableMap<String, String> tailMap = myMap.tailMap("C", true);

        System.out.println("\n -- tailMap --");
        printMap(tailMap);

        myMap.put("B1", "VB1");
        myMap.put("D1", "VD1");
        
        System.out.println("\n -- myMap (after putting some mappings to myMap) --");
        printMap(myMap);

        System.out.println("\n -- tailMap (after putting some mappings to myMap) --");
        printMap(tailMap);
    }

    private static void printMap(Map<String, String> map) {
        for (String s : map.keySet()) {
            System.out.println(s + " --> " + map.get(s));
        }
    }
}
Output:

 -- myMap --
A --> VA
B --> VB
C --> VC
D --> VD
E --> VE

 -- tailMap --
C --> VC
D --> VD
E --> VE

 -- myMap (after putting some mappings to myMap) --
A --> VA
B --> VB
B1 --> VB1
C --> VC
D --> VD
D1 --> VD1
E --> VE

 -- tailMap (after putting some mappings to myMap) --
C --> VC
D --> VD
D1 --> VD1
E --> VE

10- firstEntry()


Map.Entry<K,V> firstEntry();
Renvoyer le premier mappage (avec la plus petite clef) dans cette NavigableMap, ou null si la NavigableMap est vide.

11- lastEntry()


Map.Entry<K,V> lastEntry();
Renvoyer le dernier mappage (avec la plus grande clef) dans cette NavigableMap, ou null si la NavigableMap est vide.

12- pollFirstEntry()


Map.Entry<K,V> pollFirstEntry();
Supprimer et renvoyer le premier mappage dans cette NavigableMap, ou null si la NavigableMap est vide.

13- pollLastEntry()


Map.Entry<K,V> pollLastEntry();
Supprimer et renvoyer le dernier mappage dans cette NavigableMap, ou null si la NavigableMap est vide.

14- lowerKey(K key)


K lowerKey(K key);
Renvoyer la plus grande clef dans cette NavigableMap mais inférieure à la clef donnée, ou null s'il n'y a pas de telle clef.

15- lowerEntry(K key)


Map.Entry<K,V> lowerEntry(K key);
Renvoyer le mappage ayant la plus grande clef dans cette NavigableMap mais inférieure à la clef donnée, ou null s'il n'y a pas de tel mappage.

16- floorKey(K key)


K floorKey(K key);
Renvoyer la plus grande clef dans cette NavigableMap mais inférieure ou égale à la clef donnée, ou null s'il n'y a pas de telle clef.

17- floorEntry(K key)


Map.Entry<K,V> floorEntry(K key);
Renvoyer le mappage ayant la plus petite clef dans cette NavigableMap mais supérieure ou égale à la clef donnée, ou null s'il n'y a pas de tel mappage.

18- ceilingKey(K key)


K ceilingKey(K key);
Renvoyer la plus grande clef dans cette NavigableMap mais inférieure ou égale à la clef donnée, ou null s'il n'y a pas de telle clef.

19- ceilingEntry(K key)


Map.Entry<K,V> ceilingEntry(K key);
Renvoyer le mappage ayant la plus petite clef dans cette NavigableMap mais supérieure ou égale à la clef donnée, ou null s'il n'y a pas de tel mappage.

20- higherKey(K key)


K higherKey(K key);  
Renvoyer la plus petite clef dans cette NavigableMap mais supérieure à la clef donnée, ou null s'il n'y a pas de telle clef.

21- higherEntry(K key)


Map.Entry<K,V> higherEntry(K key);
Renvoyer le mappage ayant la plus petite clef dans cette NavigableMap mais supérieure à la clef donnée, ou null s'il n'y a pas de tell mappage.
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.