WeakHashMap的keySet条目永远不会为空吗？ [英] Are keySet entries of a WeakHashMap never null?
问题描述
如果我遍历WeakHashMap的键集，是否需要检查空值？
If I iterate over the key set of a WeakHashMap, do I need to check for null values?
WeakHashMap<MyObject, WeakReference<MyObject>> hm
= new WeakHashMap<MyObject, WeakReference<MyObject>>();
for ( MyObject item : hm.keySet() ) {
if ( item != null ) { // <- Is this test necessary?
// Do something...
}
}
换句话说，当我迭代它们时，是否可以收集WeakHashMap的元素？
In other words, can elements of the WeakHashMap be collected while I am iterating over them?
编辑
为了这个问题，可以假设在哈希映射中没有添加 null 条目。
For the sake of this question, one can assume that no null entries is added in the hash map.
推荐答案
再次来自 WeakHashMap javadoc ：
具有弱键的基于哈希表的Map实现。当WeakHashMap的密钥不再正常使用时，它将自动被删除。更确切地说，给定密钥的映射的存在不会阻止密钥被垃圾收集器丢弃，即，可以最终化，最终化，然后回收。当一个键被丢弃时，它的条目将被有效地从地图中删除，因此该类的行为与其他Map实现略有不同。
A hashtable-based Map implementation with weak keys. An entry in a WeakHashMap will automatically be removed when its key is no longer in ordinary use. More precisely, the presence of a mapping for a given key will not prevent the key from being discarded by the garbage collector, that is, made finalizable, finalized, and then reclaimed. When a key has been discarded its entry is effectively removed from the map, so this class behaves somewhat differently from other Map implementations.
我读作：是的...当没有剩余的外部引用时WeakHaskMap，那么Key可能是GC'd，使相关的值无法访问，所以它（假设没有直接外部引用）可以用于GC。
Which I read as: Yep... When there are no remaining external references to a Key in WeakHaskMap, then that Key maybe GC'd, making the associated Value unreachable, so it to (presuming there are no external references directly to it) is elligible for GC.
我要测试这个理论。这只是我对doco的解释......我对WeakHashMap没有任何经验......但我立刻发现它有可能成为内存安全的对象缓存。
I'm going to test this theory. It's only my interpretation of the doco... I don't have any experience with WeakHashMap... but I immediately see it's potential as "memory-safe" object-cache.
干杯。 Keith。
编辑：探索WeakHashMap ...专门测试我的理论，即外部 - 对特定键的引用会导致该键被保留...这是纯粹的bunkum; - ）
Exploring WeakHashMap... specifically testing my theory that an external-references to the particular key would cause that key to be retained... which is pure bunkum ;-)
我的测试工具：
package forums;
import java.util.Set;
import java.util.Map;
import java.util.WeakHashMap;
import krc.utilz.Random;
public class WeakCache<K,V> extends WeakHashMap<K,V>
{
private static final int NUM_ITEMS = 2000;
private static final Random RANDOM = new Random();
private static void runTest() {
Map<String, String> cache = new WeakCache<String, String>();
String key; // Let's retain a reference to the last key object
for (int i=0; i<NUM_ITEMS; ++i ) {
/*String*/ key = RANDOM.nextString();
cache.put(key, RANDOM.nextString());
}
System.out.println("There are " + cache.size() + " items of " + NUM_ITEMS + " in the cache before GC.");
// try holding a reference to the keys
Set<String> keys = cache.keySet();
System.out.println("There are " + keys.size() + " keys");
// a hint that now would be a good time to run the GC. Note that this
// does NOT guarantee that the Garbage Collector has actually run, or
// that it's done anything if it did run!
System.gc();
System.out.println("There are " + cache.size() + " items of " + NUM_ITEMS + " remaining after GC");
System.out.println("There are " + keys.size() + " keys");
}
public static void main(String[] args) {
try {
for (int i=0; i<20; ++i ) {
runTest();
System.out.println();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
（令人困惑的是，我一个测试运行的结果：
The (rathering perplexing, I think) results of one test-run:
There are 1912 items of 2000 in the cache before GC.
There are 1378 keys
There are 1378 items of 2000 remaining after GC
There are 909 keys
There are 2000 items of 2000 in the cache before GC.
There are 2000 keys
There are 1961 items of 2000 remaining after GC
There are 1588 keys
There are 2000 items of 2000 in the cache before GC.
There are 2000 keys
There are 1936 items of 2000 remaining after GC
There are 1471 keys
There are 2000 items of 2000 in the cache before GC.
There are 2000 keys
There are 2000 items of 2000 remaining after GC
There are 1669 keys
There are 2000 items of 2000 in the cache before GC.
There are 2000 keys
There are 2000 items of 2000 remaining after GC
There are 1264 keys
There are 2000 items of 2000 in the cache before GC.
There are 2000 keys
There are 2000 items of 2000 remaining after GC
There are 1770 keys
There are 2000 items of 2000 in the cache before GC.
There are 2000 keys
There are 2000 items of 2000 remaining after GC
There are 1679 keys
There are 2000 items of 2000 in the cache before GC.
There are 2000 keys
There are 2000 items of 2000 remaining after GC
There are 1774 keys
There are 2000 items of 2000 in the cache before GC.
There are 2000 keys
There are 2000 items of 2000 remaining after GC
There are 1668 keys
There are 2000 items of 2000 in the cache before GC.
There are 2000 keys
There are 2000 items of 2000 remaining after GC
There are 0 keys
There are 2000 items of 2000 in the cache before GC.
There are 2000 keys
There are 2000 items of 2000 remaining after GC
There are 1834 keys
There are 2000 items of 2000 in the cache before GC.
There are 2000 keys
There are 2000 items of 2000 remaining after GC
There are 0 keys
There are 2000 items of 2000 in the cache before GC.
There are 2000 keys
There are 2000 items of 2000 remaining after GC
There are 0 keys
There are 2000 items of 2000 in the cache before GC.
There are 2000 keys
There are 2000 items of 2000 remaining after GC
There are 0 keys
There are 2000 items of 2000 in the cache before GC.
There are 2000 keys
There are 2000 items of 2000 remaining after GC
There are 0 keys
There are 2000 items of 2000 in the cache before GC.
There are 2000 keys
There are 2000 items of 2000 remaining after GC
There are 0 keys
There are 2000 items of 2000 in the cache before GC.
There are 2000 keys
There are 2000 items of 2000 remaining after GC
There are 0 keys
There are 2000 items of 2000 in the cache before GC.
There are 2000 keys
There are 429 items of 2000 remaining after GC
There are 0 keys
There are 2000 items of 2000 in the cache before GC.
There are 2000 keys
There are 0 items of 2000 remaining after GC
There are 0 keys
There are 2000 items of 2000 in the cache before GC.
There are 2000 keys
There are 0 items of 2000 remaining after GC
There are 0 keys
在我的代码执行过程中，按键仍然会消失......在GC提示后可能需要微睡眠......让GC有时间去做它的事情。无论如何，这种波动性是有趣的行为。
It would appear that keys are still disappearing WHILE my code is executing... possibly a micro-sleep is required after the GC-hint... to give the GC time to do it's stuff. Anyway, this "volatility" is interesting behaviour.
编辑2：是的，添加了line 在 System.gc（）; $ c>使结果更具可预测性。
EDIT 2: Yup, adding the line try{Thread.sleep(10);}catch(Exception e){} directly after the System.gc(); makes the results "more predictable".
There are 1571 items of 2000 in the cache before GC.
There are 1359 keys
There are 0 items of 2000 remaining after GC
There are 0 keys
There are 2000 items of 2000 in the cache before GC.
There are 2000 keys
There are 0 items of 2000 remaining after GC
There are 0 keys
There are 2000 items of 2000 in the cache before GC.
There are 2000 keys
There are 0 items of 2000 remaining after GC
There are 0 keys
There are 2000 items of 2000 in the cache before GC.
There are 2000 keys
There are 0 items of 2000 remaining after GC
There are 0 keys
.... and so on for 20 runs ...
嗯...当GC在任意时间启动时，缓存完全消失在一个真正的应用程序......没什么用......嗯......我想知道什么是WeakHashMap？ ; - ）
Hmmm... A cache that just completely disappears when the GC kicks in... at arbitrary times in a real app... not much use... Hmmm... What is WeakHashMap for I wonder? ;-)
最后编辑，我保证
这是我的 krc / utilz / Random （在上面的测试中使用）
Here's my krc/utilz/Random (used in the above test)
package krc.utilz;
import java.io.Serializable;
import java.nio.charset.Charset;
/**
* Generates random values. Extends java.util.Random to do all that plus:<ul>
* <li>generate random values in a given range, and
* <li>generate Strings of random characters and random length.
* </ul>
* <p>
* Motivation: I wanted to generate random Strings of random length for test
* data in some jUnit tests, and was suprised to find no such ability in the
* standard libraries... so I googled it, and came up with Glen McCluskey's
* randomstring function at http://www.glenmccl.com/tip_010.htm. Then I thought
* aha, that's pretty cool, but if we just extended it a bit, and packaged it
* properly then it'd be useful, and reusable. Cool!
* See: http://www.glenmccl.com/tip_010.htm
* See: http://forum.java.sun.com/thread.jspa?threadID=5117756&messageID=9406164
*/
public class Random extends java.util.Random implements Serializable
{
private static final long serialVersionUID = 34324;
public static final int DEFAULT_MIN_STRING_LENGTH = 5;
public static final int DEFAULT_MAX_STRING_LENGTH = 25;
public Random() {
super();
}
public Random(long seed) {
super(seed);
}
public double nextDouble(double lo, double hi) {
double n = hi - lo;
double i = super.nextDouble() % n;
if (i < 0) i*=-1.0;
return lo + i;
}
/**
* @returns a random int between lo and hi, inclusive.
*/
public int nextInt(int lo, int hi)
throws IllegalArgumentException
{
if(lo >= hi) throw new IllegalArgumentException("lo must be < hi");
int n = hi - lo + 1;
int i = super.nextInt() % n;
if (i < 0) i = -i;
return lo + i;
}
/**
* @returns a random int between lo and hi (inclusive), but exluding values
* between xlo and xhi (inclusive).
*/
public int nextInt(int lo, int hi, int xlo, int xhi)
throws IllegalArgumentException
{
if(xlo < lo) throw new IllegalArgumentException("xlo must be >= lo");
if(xhi > hi) throw new IllegalArgumentException("xhi must be =< hi");
if(xlo > xhi) throw new IllegalArgumentException("xlo must be >= xhi");
int i;
do {
i = nextInt(lo, hi);
} while(i>=xlo && i<=xhi);
return(i);
}
/**
* @returns a string (of between 5 and 25 characters, inclusive)
* consisting of random alpha-characters [a-z]|[A-Z].
*/
public String nextString()
throws IllegalArgumentException
{
return(nextString(DEFAULT_MIN_STRING_LENGTH, DEFAULT_MAX_STRING_LENGTH));
}
/**
* @returns a String (of between minLen and maxLen chars, inclusive)
* which consists of random alpha-characters. The returned string matches
* the regex "[A-Za-z]{$minLen,$maxLan}".
* @nb: excludes the chars "[\]^_`" between 'Z' and 'a', ie chars (91..96).
* @see: http://www.neurophys.wisc.edu/comp/docs/ascii.html
*/
public String nextString(int minLen, int maxLen)
throws IllegalArgumentException
{
if(minLen < 0) throw new IllegalArgumentException("minLen must be >= 0");
if(minLen > maxLen) throw new IllegalArgumentException("minLen must be <= maxLen");
return(nextString(minLen, maxLen, 'A', 'z', '[', '`'));
}
/**
* @does: generates a String (of between minLen and maxLen chars, inclusive)
* which consists of characters between lo and hi, inclusive.
*/
public String nextString(int minLen, int maxLen, char lo, char hi)
throws IllegalArgumentException
{
if(lo < 0) throw new IllegalArgumentException("lo must be >= 0");
String retval = null;
try {
int n = minLen==maxLen ? maxLen : nextInt(minLen, maxLen);
byte b[] = new byte[n];
for (int i=0; i<n; i++)
b[i] = (byte)nextInt((int)lo, (int)hi);
retval = new String(b, Charset.defaultCharset().name());
} catch (Exception e) {
e.printStackTrace();
}
return retval;
}
/**
* @does: generates a String (of between minLen and maxLen chars, inclusive)
* which consists of characters between lo and hi, inclusive, but excluding
* character between
*/
public String nextString(int minLen, int maxLen, char lo, char hi, char xlo, char xhi)
throws IllegalArgumentException
{
if(lo < 0) throw new IllegalArgumentException("lo must be >= 0");
String retval = null;
try {
int n = minLen==maxLen ? maxLen : nextInt(minLen, maxLen);
byte b[] = new byte[n];
for (int i=0; i<n; i++) {
b[i] = (byte)nextInt((int)lo, (int)hi, (int)xlo, (int)xhi);
}
retval = new String(b, Charset.defaultCharset().name());
} catch (Exception e) {
e.printStackTrace();
}
return retval;
}
}
这篇关于WeakHashMap的keySet条目永远不会为空吗？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
