openplanning

Hướng dẫn sử dụng Java NavigableMap

Xem thêm các chuyên mục:

1- NavigableMap

NavigableMap là một interface con của SortedMap, vì vậy nó hoạt động giống như một SortedMap, ngoài ra nó được bổ xung các phương thức cho phép điều hướng, tìm kiếm các khoá và các ánh xạ.
Chẳng hạn: NavigableMap cho phép điều hướng theo thứ tự tăng dần hoặc giảm dần của khoá, cung cấp các phương thức như lowerKey, floorKey, ceilingKey, higherKey, lowerEntry, floorEntry, ceilingEntry, higherEntry.. để tìm kiếm khoá và ánh xạ.
public interface NavigableMap<K,V> extends SortedMap<K,V>
Map<K,V> SortedMap<K,V>
NavigableMap<K,V>
Không cho phép trùng lặp khoá.
Có thể cho phép khoá null và các giá trị null.
Thứ tự của các khoá không được đảm bảo. Các khoá được xắp xếp theo thứ tự tăng dần dựa trên thứ tự tự nhiên của chúng hoặc theo một Comparator được cung cấp.
Tất cả các khoá của NavigableMap/SortedMap phải là kiểu Comparable (có thể so sánh) hoặc bạn phải cung cấp một Comparator (bộ so sánh) cho NavigableMap/SortedMap để nó so sánh các khoá với nhau. Ngược lại, ClassCastException sẽ bị ném ra.

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

Ví dụ: Một đối tượng NavigableMap<Integer,String>  chứa các ánh xạ giữa năm tổ chức World Cup và quốc gia đăng cai. Chúng ta sử dụng một vài phương thức của nó để điều hướng, tìm kiếm các khoá và ánh xạ theo yêu cầu.
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
Xem thêm các ví dụ khác về cách làm thế nào để sử dụng Comparator cho NavigableMap/SortedMap:

4- descendingMap()

NavigableMap<K,V> descendingMap();
Trả về chế độ xem theo thứ tự đảo ngược của các ánh xạ có trong NavigableMap này. NavigableMap trả về sẽ được xắp xếp giảm dần theo khoá.
NavigableMap trả về có liên hệ với NavigableMap hiện tại, các thay đổi trên NavigableMap này có ảnh hưởng tới NavigableMap kia và ngược lại.
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();
Trả về chế độ xem NavigableSet của các khóa có trong NavigableMap này.
NavigableSet trả về có liên hệ với NavigableMap hiện tại, các thay đổi trên NavigableSet này có ảnh hưởng tới NavigableMap hiện tại và ngược lại.
  1. Thêm hoặc loại bỏ một ánh xạ từ NavigableMap sẽ thêm hoặc loại bỏ một phần tử từ NavigableSet.
  2. Các phương thức loại bỏ các phần tử khỏi NavigableSet như Set.iterator().remove, Set.remove, Set.removeAll, Set.retainAll, Set.clear.. sẽ loại bỏ các ánh xạ tương ứng khỏi NavigableMap.
  3. Đối tượng NavigableSet này không hỗ trợ hoạt động 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();
Trả về chế độ xem theo thứ tự đảo ngược của NavigableSet chứa các khóa có trong NavigableMap này. Tương đương với việc gọi descendingMap().navigableKeySet().
NavigableSet trả về có liên hệ với NavigableMap hiện tại, các thay đổi trên NavigableSet này có ảnh hưởng tới NavigableMap hiện tại và ngược lại.
  1. Thêm hoặc loại bỏ một ánh xạ từ NavigableMap sẽ thêm hoặc loại bỏ một phần tử từ NavigableSet.
  2. Các phương thức loại bỏ các phần tử khỏi NavigableSet như Set.iterator().remove, Set.remove, Set.removeAll, Set.retainAll, Set.clear.. sẽ loại bỏ các ánh xạ tương ứng khỏi NavigableMap.
  3. Đối tượng NavigableSet này không hỗ trợ hoạt động 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);
Trả về chế độ xem của một phần của NavigableMap này bao gồm các ánh xạ có khoá nằm trong khoảng từ fromKey đến toKey. Bao gồm cả fromKey nếu fromInclusivetrue, bao gồm cả toKey nếu toInclusivetrue.
NavigableMap trả về có liên hệ với NavigableMap hiện tại, các thay đổi trên NavigableMap này có ảnh hưởng tới NavigableMap kia và ngược lại.
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);
Trả về chế độ xem của một phần của NavigableMap này, bao gồm các ánh xạ có khoá nhỏ hơn (hoặc bằng, nếu inclusivetrue) toKey.
NavigableMap trả về có liên hệ với NavigableMap hiện tại, các thay đổi trên NavigableMap này có ảnh hưởng tới NavigableMap kia và ngược lại.

9- tailMap(K, boolean)

NavigableMap<K,V> tailMap(K fromKey, boolean inclusive);
Trả về chế độ xem của một phần của NavigableMap này, bao gồm các ánh xạ có khoá lớn hơn (hoặc bằng, nếu inclusivetrue) fromKey.
NavigableMap trả về có liên hệ với NavigableMap hiện tại, các thay đổi trên NavigableMap này có ảnh hưởng tới NavigableMap kia và ngược lại.
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();
Trả về ánh xạ đầu tiên (có khoá nhỏ nhất) trong NavigableMap này, hoặc null nếu NavigableMap rỗng.

11- lastEntry()

Map.Entry<K,V> lastEntry();
Trả về ánh xạ cuối cùng (có khoá lớn nhất) trong NavigableMap này, hoặc null nếu NavigableMap rỗng.

12- pollFirstEntry()

Map.Entry<K,V> pollFirstEntry();
Loại bỏ và trả về ánh xạ đầu tiên trong NavigableMap này, hoặc null nếu NavigableMap rỗng.

13- pollLastEntry()

Map.Entry<K,V> pollLastEntry();
Loại bỏ và trả về ánh xạ cuối cùng trong NavigableMap này, hoặc null nếu NavigableMap rỗng.

14- lowerKey(K key)

K lowerKey(K key);
Trả về khoá lớn nhất trong NavigableMap này nhưng nhỏ hơn khoá đã cho, hoặc null nếu không có khoá nào như vậy.

15- lowerEntry(K key)

Map.Entry<K,V> lowerEntry(K key);
Trả về ánh xạ có khoá lớn nhất trong NavigableMap này nhưng nhỏ hơn khoá đã cho, hoặc null nếu không có ánh xạ nào như vậy.

16- floorKey(K key)

K floorKey(K key);
Trả về khoá lớn nhất trong NavigableMap này nhưng nhỏ hơn hoặc bằng khoá đã cho, hoặc null nếu không có khoá nào như vậy.

17- floorEntry(K key)

Map.Entry<K,V> floorEntry(K key);
Trả về ánh xạ có khoá nhỏ nhất trong NavigableMap này nhưng lớn hơn hoặc bằng khoá đã cho, hoặc null nếu không có ánh xạ nào như vậy.

18- ceilingKey(K key)

K ceilingKey(K key);
Trả về khoá lớn nhất trong NavigableMap này nhưng nhỏ hơn hoặc bằng khoá đã cho, hoặc null nếu không có khoá nào như vậy.

19- ceilingEntry(K key)

Map.Entry<K,V> ceilingEntry(K key);
Trả về ánh xạ có khoá nhỏ nhất trong NavigableMap này nhưng lớn hơn hoặc bằng khoá đã cho, hoặc null nếu không có ánh xạ nào như vậy.

20- higherKey(K key)

K higherKey(K key);  
Trả về khoá nhỏ nhất trong NavigableMap này nhưng lớn hơn khoá đã cho, hoặc null nếu không có khoá nào như vậy.

21- higherEntry(K key)

Map.Entry<K,V> higherEntry(K key);
Trả về ánh xạ có khoá nhỏ nhất trong NavigableMap này nhưng lớn hơn khoá đã cho, hoặc null nếu không có ánh xạ nào như vậy.

Xem thêm các chuyên mục:

Có thể bạn quan tâm

Đây là các khóa học trực tuyến bên ngoài website o7planning mà chúng tôi giới thiệu, nó có thể bao gồm các khóa học miễn phí hoặc giảm giá.