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。非经特殊声明，原始代码版权归原作者所有，本译文未经允许或授权，请勿转载或复制。