Map中compute、putIfAbsent、computeIfAbsent、merge、computeIfPresent使用

目录

putIfAbsent

computeIfAbsent

computeIfPresent

compute

merge

---

putIfAbsent

解释：【不存在则添加】，如果map中没有该key，则直接添加；如果map中已经存在该key，则value保持不变

 default V putIfAbsent(K key, V value) {
  			//  根据key获取value
        V v = get(key);
        // 如果value == null  则将新的value赋值给key 然后返回新的value
        // 否则返回历史value
        if (v == null) {
            v = put(key, value);
        }

        return v;
    }

 Map<String,Integer> map1 = new HashMap<>();
        map1.put("a",1);
        map1.putIfAbsent("a",2);
        map1.forEach((k,v)->{
            System.out.println(k+"->"+v);
        });

输出结果为1

 Map<String,Integer> map1 = new HashMap<>();
        //map1.put("a",1);
        map1.putIfAbsent("a",2);
        map1.forEach((k,v)->{
            System.out.println(k+"->"+v);
        });
输出结果为2

computeIfAbsent

解释：【不存在则计算】，如果map中没有该key，则会计算出一个符合value类型的值赋给value；如果map中已经存在该key，则value保持不变；由于它是Funcation函数接口，因此只能处理一个参数

public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("a",1);

        map.computeIfAbsent("c",(k)->2);

        map.forEach((k,v)->{
            System.out.println(k+"-->"+v);
        });
    }
输出结果为:
a-->1
c-->2

computeIfPresent

解释：【存在则计算】，如果map中没有该key，则该键值对不会添加到map中；如果map中已经存在该key，则会把计算出的值覆盖原来的value;由于它是BiFuncation函数接口，因此能处理两个参数

public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("a", 1);

        map.computeIfPresent("a", (oldK, oldV) -> {
            return oldV+1;
        });

        map.forEach((k, v) -> {
            System.out.println(k + "-->" + v);
        });
    }
输出结果为:
a-->2

    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("a", 1);

        map.computeIfPresent("b", (oldK, oldV) -> {
            return oldV+1;
        });

        map.forEach((k, v) -> {
            System.out.println(k + "-->" + v);
        });
    }
输出结果为:
a-->1

compute

解释：【计算】，如果map中没有该key，则会计算出一个符合value类型的值赋给value；如果map中已经存在该key，则会把计算出的值覆盖原来的value.可以当成是computeIfAbsent与computeIfPresent的结合体;由于它是BiFuncation函数接口，因此能处理两个参数

 public static void main(String[] args) {
        // 存在一个需求 如果map中存在key则将原来key的值进行+10
        // 如果map中不存在key 则将此值赋值为1
        Map<String, Integer> map = new HashMap<>();
        map.put("a", 1);
        if (map.containsKey("b")) {
            map.put("b", map.get("b") + 10);
        } else {
            map.put("b", 1);
        }
        map.forEach((k, v) -> {
            System.out.println(k + "-->" + v);
        });
    }
输出结果：
a-->1
b-->1

// 使用computeIfPresent + computeIfAbsent
 public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("a", 1);
        map.computeIfPresent("b",(k,v)->v+10);
        map.computeIfAbsent("b",(k)->1);
//        if (map.containsKey("b")) {
//            map.put("b", map.get("b") + 10);
//        } else {
//            map.put("b", 1);
//        }
        map.forEach((k, v) -> {
            System.out.println(k + "-->" + v);
        });
    }
输出结果：
a-->1
b-->1


// 使用compute优化
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("a", 1);
//        if (map.containsKey("b")) {
//            map.put("b", map.get("b") + 10);
//        } else {
//            map.put("b", 1);
//        }
        map.compute("b", (oldK, oldV) -> oldV == null ? 1 : oldV + 10);

        map.forEach((k, v) -> {
            System.out.println(k + "-->" + v);
        });
    }
输出结果：
a-->1
b-->1

merge

merge(key, value, remappingFunction)

解释：【合并】如果 key 对应的 value 不存在，则返回该 value 值，如果存在，则返回通过 remappingFunction 重新计算后的值

public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("a", 1);
//        if (map.containsKey("b")) {
//            map.put("b", map.get("b") + 10);
//        } else {
//            map.put("b", 1);
//        }
        map.merge("b",1, Integer::sum);

        map.forEach((k, v) -> {
            System.out.println(k + "-->" + v);
        });
    }
输出结果：
a-->1
b-->1