betacode

Руководство Java NavigableMap

1- NavigableMap

NavigableMap - это подинтерфейс интерфейса SortedMap, поэтому он работает как SortedMap. Кроме того, он дополнен методами, которые позволяют перемещаться, искать ключи и сопоставления.
Например: NavigableMap позволяет перемещаться по ключам в порядке возрастания или убывания, предоставляя такие методы, как н lowerKey, floorKey, ceilingKey, higherKey, lowerEntry, floorEntry, ceilingEntry, higherEntry и т.д для поиска ключей и сопоставлений.
public interface NavigableMap<K,V> extends SortedMap<K,V>
Map<K,V>SortedMap<K,V>
NavigableMap<K,V>
Дубликаты ключей не допускаются.
Может разрешить ключ null и значения null.
Порядок ключей не гарантируется.Ключи сортируются в порядке возрастания на основе их естественного порядка или в соответствии с предоставляемым Comparator.
Все ключи NavigableMap/SortedMap должны быть типа Comparable (сопоставимого), или вы должны предоставить Comparator (компаратор) для NavigableMap/SortedMap, чтобы он сравнивал ключи. В противном случае будет вызвано исключение ClassCastException.

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

Например: Объект NavigableMap<Integer,String>  содержит сопоставления между годом проведения World Cup и принимающей страной. Мы используем некоторые из его методов для навигации, поиска ключей и сопоставлений.
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
См. Дополнительные примеры использования Comparator для NavigableMap/SortedMap:

4- descendingMap()

NavigableMap<K,V> descendingMap();
Возвращает представление отображений, содержащихся в этой NavigableMap, в обратном порядке. Возвращенная NavigableMap будет отсортирована в порядке убывания по ключу.
Возвращенная NavigableMap связана с текущей NavigableMap. Изменения на одной NavigableMap влияют на другую NavigableMap и наоборот.
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();
Возвращает NavigableSet ключей, содержащихся в этой NavigableMap.
Возвращенная NavigableSet связана с текущей NavigableMap. Изменения на одной NavigableSet влияют на другую NavigableMap и наоборот.
  1. Добавление или удаление отображения из NavigableMap приведет к добавлению или удалению элемента из NavigableSet.
  2. Методы удаления элементов из NavigableSet, такие как Set.iterator().remove, Set.remove, Set.removeAll, Set.retainAll, Set.clear  и т.д, удаляют соответствующие сопоставления из NavigableMap.
  3. Этот объект NavigableSet не поддерживает операции 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();
Возвращает навигационное представление of NavigableSet в обратном порядке, содержащееся в этой NavigableMap. Аналогично вызову descendingMap().navigableKeySet().
Возвращенная NavigableSet связана с текущей NavigableMap. Изменения на одной NavigableSet влияют на другую NavigableMap и наоборот.
  1. Добавление или удаление отображения из NavigableMap приведет к добавлению или удалению элемента из NavigableSet.
  2. Методы удаления элементов из NavigableSet, такие как Set.iterator().remove, Set.remove, Set.removeAll, Set.retainAll, Set.clear и т.д, будут удалять соответствующие сопоставления из NavigableMap.
  3. Этот объект NavigableSet не поддерживает операции 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);
Возвращает представление части этой NavigableMap, включающей сопоставления с ключами в диапазоне от fromKey до toKey.. Включает fromKey, если значение fromInclusive равно true, включая toKey, если значение toInclusive равно true.
Возвращенная NavigableMap связана с текущей NavigableMap. Изменения на одной NavigableMap влияют на другую NavigableMap и наоборот.
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);
Возвращает представление части этой NavigableMap, включая сопоставления, ключ которых меньше (или равен, если inclusive - true) toKey.
Возвращенная NavigableMap связана с текущей NavigableMap. Изменения на одной NavigableMap влияют на другую NavigableMap и наоборот.

9- tailMap(K, boolean)

NavigableMap<K,V> tailMap(K fromKey, boolean inclusive);
Возвращает представление части этой NavigableMap, включая сопоставления, ключ которых больше (или равен, если inclusive - true) fromKey.
Возвращенная NavigableMap связана с текущей NavigableMap. Изменения на одной NavigableMap влияют на другую NavigableMap и наоборот.
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();
Возвращает первое отображение (с наименьшим ключом) в этой NavigableMap или значение null, если NavigableMap пуста.

11- lastEntry()

Map.Entry<K,V> lastEntry();
Возвращает последнее отображение (с самым большим ключом) в этой NavigableMap или значение null, если NavigableMap пуста.

12- pollFirstEntry()

Map.Entry<K,V> pollFirstEntry();
Удаляет и возвращает первое отображение в этой NavigableMap или значение null, если NavigableMap пуста.

13- pollLastEntry()

Map.Entry<K,V> pollLastEntry();
Удаляет и возвращает последнее отображение в этой NavigableMap или значение null, если NavigableMap пуста.

14- lowerKey(K key)

K lowerKey(K key);
Возвращает самый большой ключ в этой NavigableMap, но меньше заданного ключа, или null, если такого ключа нет.

15- lowerEntry(K key)

Map.Entry<K,V> lowerEntry(K key);
Возвращает сопоставление с самым большим ключом в этой NavigableMap, но меньшим, чем заданный ключ, или null, если такого сопоставления нет.

16- floorKey(K key)

K floorKey(K key);
Возвращает самый большой ключ в этой NavigableMap, но меньше или равен данному ключу, или null, если такого ключа нет.

17- floorEntry(K key)

Map.Entry<K,V> floorEntry(K key);
Возвращает сопоставление с наименьшим ключом в этой NavigableMap, но большим или равным данному ключу, или null, если такого сопоставления нет.

18- ceilingKey(K key)

K ceilingKey(K key);
Возвращает самый большой ключ в этой NavigableMap, но меньше или равен данному ключу, или null, если такого ключа нет.

19- ceilingEntry(K key)

Map.Entry<K,V> ceilingEntry(K key);
Возвращает сопоставление с наименьшим ключом в этой NavigableMap, но большим или равным данному ключу, или null, если такого сопоставления нет.

20- higherKey(K key)

K higherKey(K key);  
Возвращает наименьший ключ в этой NavigableMap, но больше заданного ключа, или null, если такого ключа нет.

21- higherEntry(K key)

Map.Entry<K,V> higherEntry(K key);
Возвращает отображение с наименьшим ключом в этой NavigableMap, но большим, чем заданный ключ, или null, если такого отображения нет.
Maybe you are interested

Это онлайн курс вне вебсайта o7planning, который мы представляем, он включает бесплатные курсы или курсы со скидкой.