【小家java】Java中集合List、Set、Map删除元素的方法大总结（避免ConcurrentModificationException异常）（下）

//3、迭代器iterator遍历
Integer baseNum = 5; //以这个为基础 删除掉>=这个值的元素
System.out.println("剩余长度：" + list.size() + "---" + list);
Iterator<Integer> it = list.iterator();
while (it.hasNext()) {
    Integer x = it.next();
    if (x >= baseNum) {
        it.remove();
        //list.remove(x); //java.util.ConcurrentModificationException
    }
}
System.out.println("剩余长度：" + list.size() + "---" + list);
输出结果为：
剩余长度：9---[2, 1, 3, 5, 8, 6, 2, 5, 9]
剩余长度：4---[2, 1, 3, 2]

Integer baseNum = 5;
 System.out.println("剩余长度：" + list.size() + "---" + list);
 for (int i = list.size() - 1; i >= 0; i--) {
     //for (int i = 0; i < list.size(); i++) {
     if (list.get(i) >= baseNum)
         list.remove(i);
 }
 System.out.println("剩余长度：" + list.size() + "---" + list);

public static void main(String[] args) {
        Map<Integer, Integer> map = new HashMap<>();
        map.put(1, 1);
        map.put(2, 2);
        map.put(5, 5);
        map.put(3, 3);
        map.put(10, 10);
        Iterator<Integer> iterator = map.keySet().iterator();
        while (iterator.hasNext()) {
            Integer key = iterator.next();
            if (key >= 5) {
                map.remove(key);
            }
        }
        System.out.println(map);
    }
报错：Exception in thread "main" java.util.ConcurrentModificationException

代码同上，只需要调用iterator.remove();即可，不要用map.remove(key);

public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        System.out.println(map.put("1", 2)); //null 如果是添加成功，返回null
        System.out.println(map.put("1", 3)); //2  如果已经存在此key了 会用新值覆盖旧值  然后把oldValue返回出来
        System.out.println(map); //{1=3}
    }

public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        System.out.println(map.putIfAbsent("1", 2)); //null 如果是添加成功，返回null
        System.out.println(map.putIfAbsent("1", 3)); //2  如果已经存在此key了，不会覆盖此value值。  返回的还是oldValue 
        System.out.println(map); //{1=2}
    }

public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        System.out.println(map.computeIfAbsent("1", key -> Integer.valueOf(key) + 2)); //3 计算出来的newValue放进去，并且返回newValue
        System.out.println(map.computeIfAbsent("1", key -> Integer.valueOf(key) + 3)); //3 key已经存在了，不作为
        System.out.println(map.computeIfAbsent("2", key -> null)); //3 key虽然不存在，但计算出为null，所以不作为，并且返回null
        System.out.println(map); //{1=3}
    }

public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        System.out.println(map.computeIfPresent("1", (k, v) -> Integer.valueOf(k) + v)); //null key不存在，不作为  且返回null
        System.out.println(map.computeIfPresent("1", (k, v) -> Integer.valueOf(k) + v)); //null  key还是不存在，不作为 且返回null
        map.put("1", 1);
        System.out.println(map.computeIfPresent("1", (k, v) -> Integer.valueOf(k) + v)); //2  key存在，开始计算。把计算的结果覆盖掉，然后返回计算的结果
        System.out.println(map); //{1=2}
        System.out.println(map.computeIfPresent("1", (k, v) -> null)); //null key存在，开始计算 但是计算结果为null。所以返回null，此处注意remove()掉了对应的key
        System.out.println(map); //{}
    }

    public static void main(String[] args) {
        Map<String, List<String>> map = new HashMap<>();
        List<String> list;
        // 以前一般这样写，各种判断==========================================================
        list = map.get("list-1");
        if (list == null) {
            list = new LinkedList<>();
            map.put("list-1", list);
        }
        list.add("one");
        //==========================================================
        // 使用 computeIfAbsent 可以这样写 这样若已存在，返回值oldValue，若不存在就执行计算，也是返回一个可用的List 
        // 这样对null非常友好，特别好用~~~~~~~~~~
        list = map.computeIfAbsent("list-1", k -> new ArrayList<>());
        list.add("one");
    }