实现 WeakHashMap API 的Java程序
WeakHashMap 类是Java集合框架的一部分，实现了 Map 接口并扩展了 AbstractMap 类。 Map 接口帮助我们将键映射到值，而 AbstractMap 类使实现 Map 接口更容易。
映射中的每个键都必须是唯一的，并且最多可以与一个值联合。请注意，地图本身不能是键。 WeakHashMap 中不保证键值对的顺序。 WeakHashMap 与常规 HashMap 的不同之处在于 WeakHashMap 使用弱键。
强引用：强引用是通常使用的引用类型。垃圾收集器不会回收具有强引用的对象。
例子：
Geek strongRef=new Geek();弱引用：如果对象没有强引用或软引用，则称该对象具有弱引用。
例子：
new Geek();An explicit weak reference can also be generated using the WeakReference class
例子：
WeakReference weakRef=new WeakReference(new Geek());
// Now use the the get() method to obtain the object
// weakRef.get() 弱密钥的存在意味着垃圾收集器将在密钥不再使用时删除它们。另一方面，值由强引用保存。所以值对象不能直接引用它们的键 else；这将防止密钥被回收。 WeakHashMap 支持空键和值。
负载因子： WeakHashMap 容量翻倍后的占用百分比。例如，如果初始容量为 16 且负载因子为 0.75 (75%)，即 12.，则在添加第 13 个元素时，WeakHashMap 的大小将增加一倍。
构造函数： WeakHashMap 类提供了 4 个构造函数：
1.WeakHashMap()：这将生成一个WeakHashMap对象，初始容量为16，负载因子为0.75
句法：
WeakHashMap wHM=new WeakHashMap(); 2.WeakHashMap(int InitialCapacity)：这将生成一个 WeakHashMap 对象，它具有所需的 InitialCapacity 和 0.75 的负载因子
句法：
WeakHashMap wHM=new WeakHashMap(20);
// This will generate a WeakHashMap
// object with an initial capacity of 20 3.WeakHashMap(int InitialCapacity, float LoadFactor)：这将生成一个具有所需InitialCapacity 和负载因子的WeakHashMap 对象。
句法：
WeakHashMap wHM=new WeakHashMap(20,0.9);
// This will generate a WeakHashMap object with an
// initial capacity of 20 and load factor of 90% 4.WeakHashMap(Map map)：这将生成一个WeakHashMap对象，并将在此过程中从指定映射中复制所有键值对。
句法：
WeakHashMap wHM=new WeakHashMap( oldMap);
// This will generate a WeakHashMap object and
// will copy all the mappings of oldMap WeakHashMap 上的操作
WeakHashMap 的操作可以分为破坏性和非破坏性。破坏性方法修改它们操作的地图。
破坏性操作
1. 添加或更新
当一个 key 被插入到 WeakHashMap 中时，内部会发生以下过程：
- 为该特定键生成唯一的哈希码
- 此哈希码用于生成索引值
- 键值对存储在哈希表中的特定索引处
A) public T put(K key, T value)：在 WeakHashMap 中插入给定的键值对。如果键已经存在，那么值会被更新。此方法返回键的先前值。如果键是第一次插入或前一个值为空，则返回空
B) public void putAll(Map m)：将map中的所有映射插入到当前map中。如果有任何键是通用的，则值会更新。如果指定的映射 m 为 null，则抛出 NullPointerException。
2. 删除
A) public void clear()：从地图中删除所有映射
B) public T remove(Object key)：从映射中移除与键 obj 关联的映射，前提是它存在。此方法将返回与要删除的键关联的值。如果不存在这样的键或值本身为空，则将返回空值。
非破坏性操作
非破坏性方法不会改变它们操作的地图。非破坏性方法如下：
1. containsKey：如果映射包含指定的键，则返回true，否则返回false。
public boolean containsKey(Object Key)2. containsValue：如果映射包含具有指定值的键，则返回true，否则返回false。
public boolean containsValue(Object Value)3. get：返回指定键附带的值。如果键不存在或值本身为空，则返回 null。
public T get(Object Key)4.大小：返回调用该方法时映射中存在的键值对的数量。
public int size() 5. isEmpty：如果调用该方法的瞬间映射中没有键值对，则返回true，否则返回false。
public boolean isEmpty()6. entrySet：键值对也称为映射条目。 Map.Entry 接口允许我们处理地图条目。 entrySet 方法将返回所有当前地图条目的集合。
public Set> entrySet() 7. keySet：返回一个包含地图中所有键的集合。地图中所做的更改反映在此集合中。在地图上进行操作并同时遍历集合可能会导致未定义的行为。
public Set keySet() 8. values：返回地图中存在的所有值的集合视图。地图中所做的更改反映在此集合中。在地图上进行操作并同时遍历集合可能会导致未定义的行为。
public Collection values() 实现 WeakHashMap
以下程序包含 WHI 类，它实现了 WeakHashMap API。然后在此处使用此实现将成绩映射到分数。
Java
// Java Program to implement WeakHashMap
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.WeakHashMap;
// The class WHI will implement WeakHashMap
class WHI {
// Make a private WeakHashMap reference
// variable
private WeakHashMap obj;
// Constructors
// Create WeakHashMap with capacity 16
// and 0.75 load-factor
public WHI() { obj = new WeakHashMap(); }
// Create WeakHashMap with desired capacity
// and 0.75 load-factor
public WHI(int initialCapacity)
{
obj = new WeakHashMap(initialCapacity);
}
// Create WeakHashMap with desired capacity
// and desired load-factor
public WHI(int initialCapacity, float loadFactor)
{
obj = new WeakHashMap(initialCapacity,
loadFactor);
}
// Destructive-Methods
// Place the key-value pair in the
// WeakHashMap
public V put(K key, V value)
{
return obj.put(key, value);
}
// Copy all the key-value pairs
// from a map
public void putAll(Map map) { obj.putAll(map); }
// Remove all the key-value pairs
public void clear() { obj.clear(); }
// Remove a particular key
public V remove(Object key) { return obj.remove(key); }
// Non-Destructive methods
// Check if the map contains
// a specific key
public boolean containsKey(Object key)
{
return obj.containsKey(key);
}
// Check if the map contains a key
// with specific value
public boolean containsValue(Object value)
{
return obj.containsValue(value);
}
// get the value for a specific
// key
public V get(Object key) { return obj.get(key); }
// get size of the map
public int size() { return obj.size(); }
// Check if the map is empty
public boolean isEmpty() { return obj.isEmpty(); }
// get a set of Map entries
public Set > entrySet()
{
return obj.entrySet();
}
// get a set of keys
public Set keySet() { return obj.keySet(); }
// get a Collection of values
public Collection values() { return obj.values(); }
}
public class Main {
public static void main(String args[])
{
// Create an object of WHI class
// key will be of type String
// value will be of type Integer
WHI obj1
= new WHI();
System.out.println(
"The grades and cut off are as follows: ");
// insert key-value pairs in the WeakHashMap object
obj1.put("A+", 90);
obj1.put("A", 80);
obj1.put("B", 70);
obj1.put("C", 60);
// Traverse the set containing map entries
// entrySet() is used to obtain the set
for (Map.Entry ivar :
obj1.entrySet()) {
System.out.println(ivar.getKey() + " "
+ ivar.getValue());
}
// get value associated with key "B"
System.out.println("The cut-off for B grade is "
+ obj1.get("B"));
}
} The grades and cut off are as follows:
A+ 90
C 60
B 70
A 80
The cut-off for B grade is 70Note: The grades and cut off might get printed in an unorderly manner. This is because the order is not guaranteed in a WeakHashMap.