实现 ConcurrentHashMap API 的Java程序
ConcurrentHashMap类遵循与 HashTable 相同的功能规范，包括与 HashTable 的每个方法对应的方法的所有版本。 HashTable 支持检索的完全并发性和可调整的更新并发性。 ConcurrentHashMap 的所有操作都是线程安全的，但检索操作不需要锁定，即它不支持以阻止所有访问的方式锁定整个表。此 API 与程序中的 HashTable 完全可互操作。它存在于Java .util.concurrent 包中。
ConcurrentHashMap 扩展了 AbstractMap
类型参数：
- K - 地图维护的密钥类型
- V – 映射到它的值的类型。
所有实现的接口：
Serializable, ConcurrentMap, Map 句法：
public class ConcurrentHashMap
extends AbstractMap
implements ConcurrentMap, Serializable 构造函数：
- ConcurrentHashMap() –创建一个空 Map，初始容量为 16，负载因子为 0.75，并发级别为 16。
- ConcurrentHashMap(int initialCapacity) –使用给定的初始容量和负载因子和 concurrencyLevel 的默认值创建一个空 Map。
- ConcurrentHashMap(int initialCapacity, float loadFactor) –创建一个具有给定初始容量、给定负载因子和默认并发级别的空 Map。
- ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) –创建一个具有给定初始容量、负载因子和 concurrencyLevel 的空 Map。
- ConcurrentHashMap(Map m) –创建一个与 Map 中给出的映射相同的新 Map。
代码：
Java
// Java Program to Implement ConcurrentHashMap API
import java.util.Collection;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
public class ConcurrentMap {
private ConcurrentHashMap hm;
// creates an empty ConcurrentHashMap with initial
// capacity 16 and load factor 0.75
public ConcurrentMap()
{
hm = new ConcurrentHashMap();
}
// creates an empty ConcurrentHashMap with given initial
// capacity and load factor 0.75
public ConcurrentMap(int incap)
{
hm = new ConcurrentHashMap(incap);
}
// creates an empty ConcurrentHashMap with given initial
// capacity and load factor
public ConcurrentMap(int incap, float lf)
{
hm = new ConcurrentHashMap(incap, lf);
}
// creates an empty ConcurrentHashMap with given initial
// capacity, load factor and concurrency level
public ConcurrentMap(int incap, float lf,
int concurrLevel)
{
hm = new ConcurrentHashMap(incap, lf,
concurrLevel);
}
// Creates an hashMap with the same values as the given
// hashMap
public ConcurrentMap(Map m)
{
hm = new ConcurrentHashMap(m);
}
// Removes all the keys and values from the Map
public void clear() { hm.clear(); }
// Return true if the Map contains the given Key
public boolean containsKey(Object k)
{
return hm.containsKey(k);
}
// Return true if the map contains keys that maps to the
// given value
public boolean containsValue(Object v)
{
return hm.containsValue(v);
}
// Returns a set view of the key-value pairs of the map
public Set > entrySet()
{
return hm.entrySet();
}
// Return the value to which the given key is mapped
public V get(Object k) { return hm.get(k); }
// Return true if the map does not contains any
// key-value pairs
public boolean isEmpty() { return hm.isEmpty(); }
// Returns a set view of the key-value pairs of the map
public Set keySet() { return hm.keySet(); }
// Maps the given value to the given key in the map
public V put(K k, V v) { return hm.put(k, v); }
// Copies all the key-value pairs from one map to
// another
public void putAll(Map mp)
{
hm.putAll(mp);
}
// Removes the mapping of the given key from its value
public V remove(Object k) { return hm.remove(k); }
// Returns the size of the map
public int size() { return hm.size(); }
// Returns the collection view of the values of the map
public Collection values() { return hm.values(); }
// Returns an enumeration of the given values of the map
public Enumeration elements()
{
return hm.elements();
}
// If the given key is not associated with the given
// value then associate it.
public V putIfAbsent(K k, V v)
{
return hm.putIfAbsent(k, v);
}
// Replaces the value for a key only if it is currently
// mapped to some value.
public V replace(K key, V value)
{
return hm.replace(key, value);
}
// Replaces the oldValue for a key only if it is
// currently mapped to a given value. *
public boolean replace(K key, V oValue, V nValue)
{
return hm.replace(key, oValue, nValue);
}
public static void main(String[] arg)
{
// Creating an object of the class
ConcurrentMap hm
= new ConcurrentMap();
hm.put(1, "Amit");
hm.put(2, "Ankush");
hm.put(3, "Akshat");
hm.put(4, "Tarun");
// Creating another Map
Map hm2
= new HashMap();
hm.putAll(hm2);
System.out.println(
"The Keys of the ConcurrentHashMap is ");
Set k = hm.keySet();
Iterator i = k.iterator();
while (i.hasNext()) {
System.out.print(i.next() + " ");
}
System.out.println();
System.out.println(
"The values of the ConcurrentHashMap is ");
Collection values = hm.values();
Iterator s = values.iterator();
while (s.hasNext()) {
System.out.print(s.next() + " ");
}
System.out.println();
System.out.println(
"The entry set of the ConcurrentHashMap is ");
Iterator > er;
Set > ent = hm.entrySet();
er = ent.iterator();
while (er.hasNext()) {
System.out.println(er.next() + " ");
}
System.out.println(
"The ConcurrentHashMap contains Key 3 :"
+ hm.containsKey(3));
System.out.println(
"The ConcurrentHashMap contains Tarun:"
+ hm.containsValue("Tarun"));
System.out.println(
"Put the key 10 with value Shikha if not asscociated : "
+ hm.putIfAbsent(10, "Shikha"));
System.out.println(
"Replace key 3 oldvalue of Akshat and newvalue Pari :"
+ hm.replace(3, "Akshat", "Pari"));
System.out.println(
"The Size of the ConcurrentHashMap is "
+ hm.size());
// Clearing the Concurrent map
hm.clear();
if (hm.isEmpty())
System.out.println(
"The ConcurrentHashMap is empty");
else
System.out.println(
"The ConcurrentHashMap is not empty");
}
} 输出
The Keys of the ConcurrentHashMap is
1 2 3 4
The values of the ConcurrentHashMap is
Amit Ankush Akshat Tarun
The entry set of the ConcurrentHashMap is
1=Amit
2=Ankush
3=Akshat
4=Tarun
The ConcurrentHashMap contains Key 3 :true
The ConcurrentHashMap contains Tarun:true
Put the key 10 with value Shikha if not asscociated : null
Replace key 3 oldvalue of Akshat and newvalue Pari :true
The Size of the ConcurrentHashMap is 5
The ConcurrentHashMap is empty