我有一个 HashMap，我想在每次获得迭代器时以不同的随机顺序迭代它们的键值对。从概念上讲，我想在调用迭代器之前“打乱”地图（或者如果你愿意，“打乱”迭代器）。
我有两个选择：
1) 使用 LinkedHashMap 的方法并在内部保留条目列表，将其就地打乱并在调用迭代器时返回该视图。
2) 获取map.entrySet()，构造一个ArrayList并在其上使用shuffle()。
虽然这两种方法看起来与我非常相似，但我期待非常大的 HashMap，所以我真的很关心细节和内部结构，因为我真的不能浪费内存或计算。
【问题讨论】：
标签： java data-structures random iterator hashmap
其实你根本不需要洗牌：
只需在键数组中绘制一个随机索引并通过覆盖最后一个键来删除键：
public class RandomMapIterator<K,V> implements Iterator<V> {
private final Map<K,V> map;
private final K[] keys;
private int keysCount;
@SuppressWarnings("unchecked")
public RandomMapIterator(Map<K,V> map) {
this.map = map;
this.keys = (K[]) map.keySet().toArray();
this.keysCount = keys.length;
}
@Override
public boolean hasNext() {
return keysCount!=0;
}
@Override
public V next() {
int index = nextIndex();
K key = keys[index];
keys[index] = keys[--keysCount];
return map.get(key);
}
protected int nextIndex() {
return (int)(Math.random() * keysCount);
}
@Override
public void remove() {
throw new UnsupportedOperationException();
}
}
【讨论】：
remove()，但我的主要观点仍然是：随机抽奖可以达到与洗牌相同的目的，而成本只是其中的一小部分。 ArrayList 不是结构的最佳选择，因为无论如何我们都不需要维护密钥顺序。我用一个简单的数组修改了我的解决方案。决定归结为您是更愿意预先考虑 O(N) 成本还是每个 next() 的 O(1) 成本。
重新洗牌一个大集合总是会很昂贵。每个条目至少需要一个参考。例如对于 100 万个条目，您将需要大约 4 MB。
注意；洗牌操作是O(N)
我会用
Map<K,V> map =
List<Map.Entry<K,V>> list = new ArrayList<Map.Entry<K,V>>(map.entrySet());
// each time you want a different order.
Collections.shuffle(list);
for(Map.Entry<K, V> entry: list) { /* ... */ }
【讨论】：
Collections.shuffle 也是如此。
O(N * log N)，而Java使用的shuffle确实是O(N)
Map.Entrys 的引用。如果您重复重新洗牌相同的列表，会有轻微的优化。
ArrayList 时消除显式类型参数 Map.Entry<K,V>。所以你可以输入：= new ArrayList<>(map.entrySet());
尝试使用并发哈希映射，并在迭代周期之前随机获取密钥
Map<String, String> map = Maps.newConcurrentMap();
map.put("1", "1");
map.put("2", "2");
Iterator<String> iterator = map.keySet().iterator();
while (iterator.hasNext()) {
map.remove("2");// add random key values
map.put("2", "2");
String next = iterator.next();
System.out.println("next" + next);
}
随机删除/放置值可以“洗牌”您的地图
【讨论】：