以相反顺序迭代 LinkedHashMap

Question

我有一个 LinkedHashMap：

LinkedHashMap<String, RecordItemElement>

我需要从给定键的位置向后迭代。因此，如果给我第 10 个项目的键，我需要向后迭代哈希图 9、8、7 等。

Answer 1

这个问题需要一个相反顺序的 LinkedHashMap，一些答案建议使用 TreeSet，但这会根据键重新排序映射。

该解决方案允许对原始 LinkedHashMap 进行迭代，而不是像已经提议的那样对新的 ArrayList 进行迭代：

List<String> reverseOrderedKeys = new ArrayList<String>(linkedHashMap.keySet());
Collections.reverse(reverseOrderedKeys);
for (String key : reverseOrderedKeys) {
    RecordItemElement line = linkedHashMap.get(key);
}

Answer 2

HashMap：

HashMap<Integer, String> map = new HashMap<Integer, String>();

反向迭代值：

ListIterator<Sprite> iterator = new ArrayList<String>(map.values()).listIterator(map.size());
while (iterator.hasPrevious()) String value = iterator.previous();

反向迭代键：

ListIterator<Integer> iterator = new ArrayList(map.keySet()).listIterator(map.size());
while (iterator.hasPrevious()) Integer key = iterator.previous();

反向迭代两者：

ListIterator<Map.Entry<Integer, String>> iterator = new ArrayList<Map.Entry<Integer, String>>(map.entrySet()).listIterator(map.size());
while (iterator.hasPrevious()) Map.Entry<Integer, String> entry = iterator.previous();

Answer 3

您不必迭代它。但拔下钥匙并将其存储在列表中会很方便。这是执行 indexOf() 类型操作的唯一方法。

List<String> keyList = new ArrayList<String>(map.keySet());
// Given 10th element's key
String key = "aKey";
int idx = keyList.indexOf(key);
for ( int i = idx ; i >= 0 ; i-- ) 
 System.out.println(map.get(keyList.get(i)));

Answer 4

new LinkedList(linkedHashMap.keySet()).descendingIterator();

Answer 5

从 Java 21 开始，LinkedHashMap 具有 reversed() 方法，返回地图的反转视图。这可以以标准方式迭代。

myLinkedHashMap.reversed().forEach((key, value) -> {
  // Do something with the key and/or value
});

要根据请求专门从给定键开始，可以使用反向映射条目集上的 Stream，使用 dropWhile 跳过所有元素的方法在该键之前遇到：

String matchingKey = "someKey";
myLinkedHashMap.entrySet().stream()
        .dropWhile(e -> !matchingKey.equals(e.getKey()))
        .forEach(e -> {
            String key = e.getKey();
            RecordItemElement value = e.getValue();
            // Do something with key & value
        });

Answer 6

使用“user22745008”解决方案和labdas以及一些泛型，您可以得到一个非常简洁的解决方案作为方法：

  public static <T, Q> LinkedHashMap<T, Q> reverseMap(LinkedHashMap<T, Q> toReverse)
  {
      LinkedHashMap<T, Q> reversedMap = new LinkedHashMap<>();
      List<T> reverseOrderedKeys = new ArrayList<>(toReverse.keySet());
      Collections.reverse(reverseOrderedKeys);
      reverseOrderedKeys.forEach((key)->reversedMap.put(key,toReverse.get(key)));
      return reversedMap;
    }

Answer 7

这是一个老问题，但我认为它缺乏采用更新方法的答案。以下使用 Java 9 功能：

Deque<Map.Entry<String, RecordItemElement>> top = map.entrySet().stream()
        .takeWhile(e -> !givenKey.equals(e.getKey()))
        .collect(Collectors.toCollection(ArrayDeque::new));

上面的代码流式传输映射的条目集，保留条目，直到找到与给定键相等的键。然后，条目被收集到 ArrayDeque 中。

不过，有一个细节缺失。根据您是否需要将与给定键匹配的条目也包含在结果中，您可能需要手动将其添加到双端队列中。如果您不想添加它，那么就完成了。否则，只需执行以下操作：

top.add(Map.entry(givenKey, map.get(givenKey)));

现在，要以相反的顺序迭代 Deque，只需使用其 descendingIterator()：

Iterator<Map.Entry<String, RecordItemElement>> descIt = top.descendingIterator();

值得一提的是，此方法仅在流是顺序。无论如何，我们在这里使用并行流不会获得任何东西。