Java中的WeakHashMap类-yiteyi-C++库

WeakHashMap是Map接口的一个实现。WeakHashMap几乎与HashMap相同，除了在WeakHashMap的情况下，如果对象被指定为不包含任何引用的键，那么它可以进行垃圾收集，即使它与WeakHashMap关联。i、垃圾收集器控制着WeakHashMap。

null

WeakHashMap是基于哈希表的映射接口实现，带有弱键。WeakHashMap中的条目在其密钥不再正常使用时将自动删除。更准确地说，给定密钥的映射不会阻止垃圾收集器丢弃该密钥，也就是说，使其可终结、终结，然后回收。当一个键被丢弃时，它的条目将被有效地从映射中删除，因此这个类的行为与其他映射实现有所不同。

WeakHashMap类的几个重要特性是：

WeakHashMap支持空值和空键。
它不是同步的。
此类主要用于关键对象，其equals方法使用==运算符测试对象标识。

WeakHashMap中的构造函数

1.WeakHashMap（）： 此构造函数用于创建一个默认初始容量为-（16）且负载系数为（0.75）的空WeakHashMap。

2.WeakHashMap（初始容量）： 此构造函数用于创建具有给定初始容量和默认负载系数（0.75）的空WeakHashMap。

3.WeakHashMap（初始容量、浮动负载系数）： 此构造函数用于创建具有给定初始容量和给定负载系数的空WeakHashMap。

4.WeakHashMap（地图m）： 此构造函数用于创建具有与指定映射相同映射的新WeakHashMap。

WeakHashMap中的方法

方法	执行的动作
清除（）	删除此映射中的所有映射。此调用返回后，映射将为空。
containsValue（对象值）	如果此映射将一个或多个键映射到指定值，则返回true。
containsKey（对象键）	如果此映射包含指定键的映射，则返回true。
入口集（）	返回此映射中包含的映射的集合视图。集合由映射支持，因此对映射的更改会反映在集合中，反之亦然。如果在对集合进行迭代时修改映射（除了通过迭代器自己的删除操作，或者通过迭代器返回的映射项上的setValue操作），则迭代的结果是未定义的。该集合支持元素移除，即通过迭代器从映射中移除相应的映射。移除，设置。移除、移除所有、保留和清除操作。它不支持添加或添加所有操作。
获取（对象键）	返回指定键映射到的值，如果此映射不包含该键的映射，则返回null。
isEmpty（）	如果此映射不包含键值映射，则返回true。此结果是一个快照，可能不会反映未处理的条目，这些条目将在下次尝试访问之前删除，因为它们不再被引用。
键集（）	返回此映射中包含的键的集合视图。集合由映射支持，因此对映射的更改会反映在集合中，反之亦然。如果在对集合进行迭代时修改映射（除了通过迭代器自己的移除操作），则迭代的结果是未定义的。该集合支持元素移除，即通过迭代器从映射中移除相应的映射。移除，设置。移除、移除所有、保留和清除操作。它不支持添加或添加所有操作。
输入（K键，V值）	将指定的值与此映射中的指定键相关联。如果映射之前包含该键的映射，则替换旧值。
putAll（地图m）	将指定映射中的所有映射复制到此映射。这些映射将替换此映射对指定映射中当前任何键的所有映射。
移除（对象键）	从弱哈希映射中删除密钥的映射（如果存在）。更正式地说，如果该映射包含从键k到值v的映射，使得（键==null？k==null:key.equals（k）），那么该映射将被删除。
大小（）	返回此映射中的键值映射数。此结果是一个快照，可能不会反映未处理的条目，这些条目将在下次尝试访问之前删除，因为它们不再被引用。
价值观（）	返回此映射中包含的值的集合视图。集合由映射支持，因此对映射的更改会反映在集合中，反之亦然。如果在集合上进行迭代时修改了映射（除了通过迭代器自己的移除操作），则迭代的结果是未定义的。集合支持元素移除，即通过迭代器从映射中移除相应的映射。移除，收集。移除、移除所有、保留和清除操作。它不支持添加或添加所有操作。

例1：

JAVA

                         // Java Program to Illustrate WeakHashMap class                       
                         // Via close(), containsValue(), containsKey()                       
                         // and isEmpty() method                       
                                   
                         // Importing required classes                       
                         import                                     java.util.Map;                       
                         import                                     java.util.WeakHashMap;                       
                                   
                         // Main class                       
                         // WeakHashMapdemo                       
                         class                                     GFG {                       
                                   
                                                 // Main driver method                       
                                                 public                                     static                                     void                                     main(String[] arg)                       
                                                 {                       
                                   
                                                 // Creating an empty WeakHashMap                       
                                                 // of Number and string type                       
                                                 Map<Number, String> weak                       
                                                 =                                     new                                     WeakHashMap<Number, String>();                       
                                   
                                                 // Inserting custom elements                       
                                                 // using put() method                       
                                                 weak.put(                                     1                                     ,                                     "geeks"                                     );                       
                                                 weak.put(                                     2                                     ,                                     "for"                                     );                       
                                                 weak.put(                                     3                                     ,                                     "geeks"                                     );                       
                                   
                                                 // Printing and alongside checking weak map                       
                                                 System.out.println(                                     "our weak map: "                                     + weak);                       
                                   
                                                 // Checking if "for" exist                       
                                                 if                                     (weak.containsValue(                                     "for"                                     ))                       
                                                 System.out.println(                                     "for exist"                                     );                       
                                   
                                                 // Checking if 1 exist as a key in Map                       
                                                 if                                     (weak.containsKey(                                     1                                     ))                       
                                                 System.out.println(                                     "1 exist"                                     );                       
                                   
                                                 // Removing all data                       
                                                 // using clear() method                       
                                                 weak.clear();                       
                                   
                                                 // Checking whether the Map is empty or not                       
                                                 // using isEmpty() method                       
                                                 if                                     (weak.isEmpty())                       
                                   
                                                 // Display message for better readability                       
                                                 System.out.println(                                     "empty map: "                                     + weak);                       
                                                 }                       
                         }                       

输出

our weak map: {3=geeks, 2=for, 1=geeks}
for exist
1 exist
empty map: {}

例2：

JAVA

                         // Java Program to Illustrate WeakHashMap class                       
                         // Via entrySet(), keySet() and Values() Method                       
                                   
                         // Importing required classes                       
                         import                                     java.util.Collection;                       
                         import                                     java.util.Map;                       
                         import                                     java.util.Set;                       
                         import                                     java.util.WeakHashMap;                       
                                   
                         // Main class                       
                         // WeakHashMapdemo                       
                         class                                     GFG {                       
                                   
                                                 // Main driver method                       
                                                 public                                     static                                     void                                     main(String[] arg)                       
                                                 {                       
                                   
                                                 // Creating an empty WeakHashMap                       
                                                 // of number and string type                       
                                                 Map<Number, String> weak                       
                                                 =                                     new                                     WeakHashMap<Number, String>();                       
                                   
                                                 // Inserting elements                       
                                                 // using put() method                       
                                                 weak.put(                                     1                                     ,                                     "geeks"                                     );                       
                                                 weak.put(                                     2                                     ,                                     "for"                                     );                       
                                                 weak.put(                                     3                                     ,                                     "geeks"                                     );                       
                                   
                                                 // Creating object of Set interface                       
                                                 Set set1 = weak.entrySet();                       
                                   
                                                 // Checking above Set                       
                                                 System.out.println(set1);                       
                                   
                                                 // Creating set for key                       
                                                 Set keySet = weak.keySet();                       
                                   
                                                 // Checking keySet                       
                                                 System.out.println(                                     "key set: "                                     + keySet);                       
                                   
                                                 Collection value = weak.values();                       
                                   
                                                 // Checking values of map and printing them                       
                                                 System.out.println(                                     "values: "                                     + value);                       
                                                 }                       
                         }                       

输出

[3=geeks, 2=for, 1=geeks]
key set: [3, 2, 1]
values: [geeks, for, geeks]

例3：

JAVA

                         // Java code remove(), putAll()                       
                         // get() and size() method                       
                                   
                         import                                     java.util.Collection;                       
                         import                                     java.util.Map;                       
                         import                                     java.util.Set;                       
                         import                                     java.util.WeakHashMap;                       
                                   
                         class                                     WeakHashMapdemo {                       
                                                 public                                     static                                     void                                     main(String[] arg)                       
                                                 {                       
                                                 Map<Number, String> weak                       
                                                 =                                     new                                     WeakHashMap<Number, String>();                       
                                                 weak.put(                                     1                                     ,                                     "geeks"                                     );                       
                                                 weak.put(                                     2                                     ,                                     "for"                                     );                       
                                                 weak.put(                                     3                                     ,                                     "geeks"                                     );                       
                                   
                                                 Map<Number, String> weak1                       
                                                 =                                     new                                     WeakHashMap<Number, String>();                       
                                                 weak1.putAll(weak);                       
                                   
                                                 // Getting value of key 2                       
                                                 System.out.println(weak1.get(                                     2                                     ));                       
                                   
                                                 // Printing the size of map                       
                                                 // using size() method                       
                                                 System.out.println(                                     "Size of map is: "                       
                                                 + weak1.size());                       
                                   
                                                 // Removing second element                       
                                                 // using standard remove() method                       
                                                 weak1.remove(                                     2                                     );                       
                                   
                                                 // Printing the size after removing key and value                       
                                                 // pair                       
                                                 System.out.println(                                     "Size after removing: "                       
                                                 + weak1.size());                       
                                                 }                       
                         }                       

输出

for
Size of map is: 3
Size after removing: 2

本文由 阿布舍克·维马 .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用写极客。组织或者把你的文章寄去评论-team@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END

Java