LinkedHashMap 遍历删除

可以使用迭代器 Iterator 来遍历 LinkedHashMap 并且删除元素。具体的代码如下：

LinkedHashMap<String, String> map = new LinkedHashMap<>();
map.put("A", "Apple");
map.put("B", "Banana");
map.put("C", "Cat");
map.put("D", "Dog");

Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
    Map.Entry<String, String> entry = iterator.next();
    if (entry.getKey().equals("B")) {
        iterator.remove(); // 删除 key 为 "B" 的元素
    }
}

System.out.println(map); // 输出 {A=Apple, C=Cat, D=Dog}

上述代码中，我们使用 `entrySet()` 方法获取 LinkedHashMap 中所有元素的集合，然后使用迭代器 Iterator 遍历集合，如果符合条件就使用 `iterator.remove()` 方法删除元素。最后输出剩余的元素。

相关问题

反向遍历LinkedHashMap 并删除

要反向遍历并删除LinkedHashMap中的元素，可以使用List来保存LinkedHashMap中的键，然后从最后一个键开始逐个删除对应的键值对。

以下是一个示例代码：

import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        LinkedHashMap<Integer, String> linkedHashMap = new LinkedHashMap<>();
        linkedHashMap.put(1, "One");
        linkedHashMap.put(2, "Two");
        linkedHashMap.put(3, "Three");

        List<Integer> keys = new LinkedList<>(linkedHashMap.keySet());
        for (int i = keys.size() - 1; i >= 0; i--) {
            int key = keys.get(i);
            linkedHashMap.remove(key);
        }

        System.out.println(linkedHashMap);
    }
}

在上述代码中，我们首先创建了一个LinkedHashMap并添加了一些键值对。然后，我们创建了一个List并通过LinkedHashMap的keySet()方法将键添加到List中。接下来，我们从List的最后一个元素开始，使用remove()方法逐个删除LinkedHashMap中的元素。最后，我们打印出修改后的LinkedHashMap。

输出将会是一个空的LinkedHashMap `{}`，表示所有元素都已被删除。

LinkedHashMap效率最高的遍历

LinkedHashMap 的遍历效率与具体的遍历方式有关，以下是两种常用的遍历方式：

1. 使用 for-each 循环遍历，可以保证元素的插入顺序：

   for (Map.Entry<String, Integer> entry : map.entrySet()) {
       String key = entry.getKey();
       Integer value = entry.getValue();
       // do something with key and value
   }

这种方式的时间复杂度是 O(n)，其中 n 是元素的个数。

2. 使用迭代器遍历，同样可以保证元素的插入顺序：

   Iterator<Map.Entry<String, Integer>> iterator = map.entrySet().iterator();
   while (iterator.hasNext()) {
       Map.Entry<String, Integer> entry = iterator.next();
       String key = entry.getKey();
       Integer value = entry.getValue();
       // do something with key and value
   }

这种方式的时间复杂度也是 O(n)，其中 n 是元素的个数。

总的来说，两种方式的遍历效率基本相同，都是 O(n)。但是使用 for-each 循环更加简洁，可读性更好，同时也可以避免迭代器的使用。但是如果需要在遍历的过程中删除元素，则必须使用迭代器，否则会抛出 ConcurrentModificationException 异常。