當前位置: 首頁>>代碼示例 >>用法及示例精選 >>正文

Java ConcurrentNavigableMap用法及代碼示例


ConcurrentNavigableMap接口是一個成員Java集合框架。它延伸自NavigableMap Interface接口和ConcurrentMap接口。 ConcurrentNavigableMap 提供對Map元素的線程安全訪問，並提供方便的導航方法。它屬於java.util.concurrent包。

聲明：

public interface ConcurrentNavigableMap<K,V> extends ConcurrentMap<K,V>, NavigableMap<K,V>

這裏，K 是鍵對象類型，V 是值對象類型。

ConcurrentNavigableMap的層次結構

ConcurrentNavigableMap Interface in Java

它實現了ConcurrentMap,Map,NavigableMap Interface,SortedMap Interface接口。ConcurrentSkipListMap實現 ConcurrentNavigableMap。

例子：

Java 


// Java Program to demonstrate the
// ConcurrentNavigableMap Interface
import java.util.concurrent.ConcurrentNavigableMap;
import java.util.concurrent.ConcurrentSkipListMap;
public class GFG {
    public static void main(String[] args)
    {
        // Instantiate an object
        // Since ConcurrentNavigableMap
        // is an interface so We use
        // ConcurrentSkipListMap
        ConcurrentNavigableMap<Integer, String> cnmap
            = new ConcurrentSkipListMap<Integer, String>();
        // Add elements using put() method
        cnmap.put(1, "First");
        cnmap.put(2, "Second");
        cnmap.put(3, "Third");
        cnmap.put(4, "Fourth");
        // Print the contents on the console
        System.out.println(
            "Mappings of ConcurrentNavigableMap : "
            + cnmap);
        System.out.println("HeadMap(3): "
                           + cnmap.headMap(3));
        System.out.println("TailMap(3): "
                           + cnmap.tailMap(3));
        System.out.println("SubMap(1, 3): "
                           + cnmap.subMap(1, 3));
    }
}


輸出：

Mappings of ConcurrentNavigableMap : {1=First, 2=Second, 3=Third, 4=Fourth}
HeadMap(3): {1=First, 2=Second}
TailMap(3): {3=Third, 4=Fourth}
SubMap(1, 3): {1=First, 2=Second}

實現類

ConcurrentNavigableMap 有一個實現類，它是ConcurrentSkipListMap 類。 ConcurrentSkipListMap 是 ConcurrentNavigableMap 接口的可擴展實現。 ConcurrentSkipListMap 中的鍵按自然順序或使用Comparator Interface在構建對象時。 ConcurrentSkipListMap 的預期時間成本為日誌(n)用於插入、刪除和搜索操作。它是一個線程安全的類，因此，所有基本操作都可以並發完成。

用法:

ConcurrentSkipListMap< ? , ? > objectName = new ConcurrentSkipListMap< ? , ? >();

示例：在下麵給出的代碼中，我們簡單地實例化了一個名為 cslmap 的 ConcurrentSkipListMap 類的對象。 put()方法用於添加元素，remove()用於刪除元素。對於 remove() 方法，語法為objectname.remove(對象鍵)。 keySet() 顯示映射中的所有鍵(上麵給出的方法表中的說明)。

Java 


// Java Program to demonstrate the ConcurrentSkipListMap
import java.util.concurrent.*;
public class ConcurrentSkipListMapExample {
    public static void main(String[] args)
    {
        // Instantiate an object of
        // ConcurrentSkipListMap named cslmap
        ConcurrentSkipListMap<Integer, String> cslmap
            = new ConcurrentSkipListMap<Integer, String>();
        // Add elements using put()
        cslmap.put(1, "Geeks");
        cslmap.put(2, "For");
        cslmap.put(3, "Geeks");
        // Print the contents on the console
        System.out.println(
            "The ConcurrentSkipListMap contains: "
            + cslmap);
        // Print the key set using keySet()
        System.out.println(
            "\nThe ConcurrentSkipListMap key set: "
            + cslmap.keySet());
        // Remove elements using remove()
        cslmap.remove(3);
        // Print the contents on the console
        System.out.println(
            "\nThe ConcurrentSkipListMap contains: "
            + cslmap);
    }
}

輸出：

The ConcurrentSkipListMap contains: {1=Geeks, 2=For, 3=Geeks}

The ConcurrentSkipListMap key set: [1, 2, 3]

The ConcurrentSkipListMap contains: {1=Geeks, 2=For}

ConcurrentNavigableMap 的基本操作

1. 添加元素

要將元素添加到 ConcurrentNavigableMap，我們可以使用 Map 接口的任何方法。下麵的代碼展示了如何使用它們。您可以在代碼中觀察到，當構建時未提供 Comparator 時，將遵循自然順序。

Java 


// Java Program for adding elements to a
// ConcurrentNavigableMap
import java.util.concurrent.*;
public class AddingElementsExample {
    public static void main(String[] args)
    {
        // Instantiate an object
        // Since ConcurrentNavigableMap is an interface
        // We use ConcurrentSkipListMap
        ConcurrentNavigableMap<Integer, String> cnmap
            = new ConcurrentSkipListMap<Integer, String>();
        // Add elements using put()
        cnmap.put(8, "Third");
        cnmap.put(6, "Second");
        cnmap.put(3, "First");
        // Print the contents on the console
        System.out.println(
            "Mappings of ConcurrentNavigableMap : "
            + cnmap);
    }
}


輸出：

Mappings of ConcurrentNavigableMap : {3=First, 6=Second, 8=Third}

2. 刪除元素

為了刪除元素，我們還使用 Map 接口的方法，因為 ConcurrentNavigableMap 是 Map 的後代。

Java 


// Java Program for deleting
// elements from ConcurrentNavigableMap
import java.util.concurrent.*;
public class RemovingElementsExample {
    public static void main(String[] args)
    {
        // Instantiate an object
        // Since ConcurrentNavigableMap
        // is an interface
        // We use ConcurrentSkipListMap
        ConcurrentNavigableMap<Integer, String> cnmap
            = new ConcurrentSkipListMap<Integer, String>();
        // Add elements using put()
        cnmap.put(8, "Third");
        cnmap.put(6, "Second");
        cnmap.put(3, "First");
        cnmap.put(11, "Fourth");
        // Print the contents on the console
        System.out.println(
            "Mappings of ConcurrentNavigableMap : "
            + cnmap);
        // Remove elements using remove()
        cnmap.remove(6);
        cnmap.remove(8);
        // Print the contents on the console
        System.out.println(
            "\nConcurrentNavigableMap, after remove operation : "
            + cnmap);
        // Clear the entire map using clear()
        cnmap.clear();
        System.out.println(
            "\nConcurrentNavigableMap, after clear operation : "
            + cnmap);
    }
}


輸出：

Mappings of ConcurrentNavigableMap : {3=First, 6=Second, 8=Third, 11=Fourth}

ConcurrentNavigableMap, after remove operation : {3=First, 11=Fourth}

ConcurrentNavigableMap, after clear operation : {}

3. 訪問元素

我們可以使用get()方法訪問ConcurrentNavigableMap的元素，下麵給出了示例。

Java 


// Java Program for accessing
// elements in a ConcurrentNavigableMap
import java.util.concurrent.*;
public class AccessingElementsExample {
    public static void main(String[] args)
    {
        // Instantiate an object
        // Since ConcurrentNavigableMap is an interface
        // We use ConcurrentSkipListMap
        ConcurrentNavigableMap<Integer, String> cnmap
            = new ConcurrentSkipListMap<Integer, String>();
        // Add elements using put()
        cnmap.put(8, "Third");
        cnmap.put(6, "Second");
        cnmap.put(3, "First");
        cnmap.put(11, "Fourth");
        // Accessing the elements using get()
        // with key as a parameter
        System.out.println(cnmap.get(3));
        System.out.println(cnmap.get(6));
        System.out.println(cnmap.get(8));
        System.out.println(cnmap.get(11));
        // Display the set of keys using keySet()
        System.out.println(
            "\nThe ConcurrentNavigableMap key set: "
            + cnmap.keySet());
    }
}


輸出：

First
Second
Third
Fourth

The ConcurrentNavigableMap key set: [3, 6, 8, 11]

4. 遍曆

我們可以使用 Iterator 接口來遍曆 Collection Framework 的任何結構。由於迭代器使用一種類型的數據，因此我們使用 .Entry< ? , ? > 將兩種不同的類型解析為兼容的格式。然後使用 next() 方法打印 ConcurrentNavigableMap 的元素。

Java 


// Java Program for traversing a ConcurrentNavigableMap
import java.util.concurrent.*;
import java.util.*;
public class TraversalExample {
    public static void main(String[] args)
    {
        // Instantiate an object
        // Since ConcurrentNavigableMap is an interface
        // We use ConcurrentSkipListMap
        ConcurrentNavigableMap<Integer, String> cnmap
            = new ConcurrentSkipListMap<Integer, String>();
        // Add elements using put()
        cnmap.put(8, "Third");
        cnmap.put(6, "Second");
        cnmap.put(3, "First");
        cnmap.put(11, "Fourth");
        // Create an Iterator over the
        // ConcurrentNavigableMap
        Iterator<ConcurrentNavigableMap
                     .Entry<Integer, String> > itr
            = cnmap.entrySet().iterator();
        // The hasNext() method is used to check if there is
        // a next element The next() method is used to
        // retrieve the next element
        while (itr.hasNext()) {
            ConcurrentNavigableMap
                .Entry<Integer, String> entry
                = itr.next();
            System.out.println("Key = " + entry.getKey()
                               + ", Value = "
                               + entry.getValue());
        }
    }
}


輸出：

Key = 3, Value = First
Key = 6, Value = Second
Key = 8, Value = Third
Key = 11, Value = Fourth

注意：每次我們說“ConcurrentNavigableMap 的元素”時，都必須注意這些元素實際上存儲在 ConcurrentNavigableMap 的實現類的對象中，在本例中為 ConcurrentSkipListMap。

ConcurrentNavigableMap的方法

ConcurrentNavigableMap繼承了Map 接口、SortedMap 接口、ConcurrentMap 接口、NavigableMap 接口的方法。添加元素、刪除元素和遍曆的基本方法由父接口給出。下表給出了ConcurrentNavigableMap的方法。這裏，

  • K- Map中按鍵的類型。
  • V- 映射中映射的值的類型。

Method

Description
descendingKeySet() 返回映射中包含的鍵的逆序 NavigableSet 視圖。
descendingMap() 返回Map中映射的逆序視圖。
headMap(K toKey) 返回映射中鍵小於 toKey 的部分的視圖。
headMap(K toKey, boolean inclusive) 返回映射部分的視圖，其中鍵小於 toKey，並且如果包含為 true 則等於 toKey。
keySet() 返回此映射中包含的鍵的 NavigableSet 視圖。
navigableKeySet() 返回此映射中包含的鍵的 NavigableSet 視圖。
subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) 返回Map部分的視圖，鍵範圍從 fromKey 到 toKey。
subMap(K fromKey, K toKey) 返回映射部分的視圖，鍵範圍從 fromKey(包含)到 toKey(不包含)。
tailMap(K fromKey) 返回Map的視圖，其中鍵大於 fromKey。
tailMap(K fromKey, boolean inclusive) 返回映射的視圖，其中鍵大於 fromKey，並且如果包含為 true 則等於。

接口 java.util.concurrent.ConcurrentMap 中聲明的方法

METHOD

DESCRIPTION

計算(K key, BiFunction<? super K,

？超V，？擴展 V> 重映射函數)

 嘗試計算指定鍵及其當前映射值的映射(如果沒有當前映射，則為 null)。

computeIfAbsent(K key, Function<? super K,

？擴展 V> 映射函數)

如果指定的鍵尚未與值關聯(或映射為 null)，則嘗試計算其值

使用給定的映射函數並將其輸入到此映射中，除非為空。

computeIfPresent(K key, BiFunction<? 超級 K,?

超V，？擴展 V> 重映射函數)

 如果指定鍵的值存在且非空，則嘗試在給定鍵及其當前映射值的情況下計算新映射。
forEach(BiConsumer<?超級 K,?超級 V> 操作) 對此映射中的每個條目執行給定的操作，直到處理完所有條目或該操作引發異常。
getOrDefault(Object key, V defaultValue) 返回指定鍵映射到的值，如果此映射不包含該鍵的映射，則返回 defaultValue。

merge(K 鍵, V 值, BiFunction<? super V

,?超V，？擴展 V> 重映射函數)

 如果指定的鍵尚未與值關聯或與 null 關聯，則將其與給定的非 null 值關聯。
putIfAbsent(K key, V value) 如果指定的鍵尚未與值關聯，則將其與給定值關聯。
remove(Object key, Object value) 僅當當前映射到給定值時才刪除鍵的條目。
replace(K key, V value) 僅當當前映射到某個值時才替換鍵的條目。
replace(K key, V oldValue, V newValue) 僅當當前映射到給定值時才替換鍵的條目。

ReplaceAll(BiFunction<? 超級 K,? 超級 V

,?擴展 V> 函數)

 將每個條目的值替換為在該條目上調用給定函數的結果，直到處理完所有條目或函數引發異常。

接口 java.util.Map 中聲明的方法

METHOD

DESCRIPTION
Map clear() 從此映射中刪除所有映射(可選操作)。
containsKey(Object key) 如果此映射包含指定鍵的映射，則返回 true。
Map containsValue() 如果此映射將一個或多個鍵映射到指定值，則返回 true。
Map equals() 比較指定對象與此映射是否相等。
get(Object key) 返回指定鍵映射到的值，如果此映射不包含該鍵的映射，則返回 null。
Map hashCode() 返回此映射的哈希代碼值。
Map isEmpty() 如果此映射不包含鍵值映射，則返回 true。
Map put() 將指定值與此映射中的指定鍵相關聯(可選操作)。
Map putAll() 將指定映射中的所有映射複製到此映射(可選操作)。
Map remove() 從此映射中刪除鍵的映射(如果存在)(可選操作)。
size() 返回此映射中鍵值映射的數量。

接口 java.util.NavigableMap 中聲明的方法

METHOD

DESCRIPTION
NavigableMap ceilingEntry() 返回與大於或等於給定鍵的最小鍵關聯的鍵值映射，如果不存在這樣的鍵，則返回 null。
NavigableMap ceilingKey() 返回大於或等於給定鍵的最小鍵，如果沒有這樣的鍵，則返回 null。
NavigableMap firstEntry() 返回與此映射中最小鍵關聯的鍵值映射，如果映射為空，則返回 null。
NavigableMap floorEntry() 返回與小於或等於給定鍵的最大鍵關聯的鍵值映射，如果不存在這樣的鍵，則返回 null。
NavigableMap floorKey() 返回小於或等於給定鍵的最大鍵，如果沒有這樣的鍵，則返回 null。
NavigableMap higherEntry() 返回與嚴格大於給定鍵的最小鍵關聯的鍵值映射，如果不存在這樣的鍵，則返回 null。
NavigableMap higherKey() 返回嚴格大於給定鍵的最小鍵，如果不存在這樣的鍵，則返回 null。
NavigableMap lastEntry() 返回與此映射中最大鍵關聯的鍵值映射，如果映射為空，則返回 null。
NavigableMap lowerEntry() 返回與嚴格小於給定鍵的最大鍵關聯的鍵值映射，如果不存在這樣的鍵，則返回 null。
NavigableMap lowerKey() 返回嚴格小於給定鍵的最大鍵，如果不存在這樣的鍵，則返回 null。
NavigableMap pollFirstEntry() 刪除並返回與此映射中最小鍵關聯的鍵值映射，如果映射為空，則返回 null。
NavigableMap pollLastEntry() 刪除並返回與此映射中最大鍵關聯的鍵值映射，如果映射為空，則返回 null。

接口 java.util.SortedMap 中聲明的方法

METHOD

DESCRIPTION
SortedMap comparator() 返回用於對該映射中的鍵進行排序的比較器，如果該映射使用其鍵的自然順序，則返回 null。
SortedMap entrySet() 返回此映射中包含的映射的集合視圖。
SortedMap firstKey() 返回當前此映射中的第一個(最低)鍵。
SortedMap lastKey() 返回當前此映射中的最後一個(最高)鍵。
SortedMap values() 返回此映射中包含的值的集合視圖。


相關用法


注：本文由純淨天空篩選整理自ManasiKirloskar大神的英文原創作品 ConcurrentNavigableMap Interface in Java。非經特殊聲明，原始代碼版權歸原作者所有，本譯文未經允許或授權，請勿轉載或複製。