java8 Map中新增的方法介绍

2023年9月7日 141次阅读来源: z_yemu

相信大家都有看到，在 java8 后，大量的方法都包含两个单词，ifAbsent 和 ifPresent。
absent 表示缺席，理解为当前不存在即 ifAbsent 在map中主要意思就是如果 get(key) == null 执行
present 表示当下，理解为当下有值，即 ifPresent 在map中主要的意思就是如果 get(key) != null 执行

这里介绍常用的一些方法：

putIfAbsent(K key, V value) 如果传入key对应的value已经存在，就返回存在的value，不进行替换。
如果不存在或为 get(key)为null，就添加key和value，返回null（简单讲就是返回前一个值）


    /** * putIfAbsent(K key, V value) 如果传入key对应的value已经存在，就返回存在的value，不进行替换。 * 如果不存在或为 get(key)为null，就添加key和value，返回null（简单讲就是返回前一个值） */
    public static void testPutIfAbsent(){
        String ret;
        Map<String, String> map = new HashMap<>();
        ret = map.putIfAbsent("a", "aaa");
// null {a=aaa}
        System.out.println(ret + " " + map);

        ret = map.putIfAbsent("a", "bbb");
// aaa {a=aaa}
        System.out.println(ret + " " + map);

        map.put("b", null);
        ret = map.putIfAbsent("b", "bbb");
// null {a=aaa, b=bbb}
        System.out.println(ret + " " + map);
    }

computeIfPresent(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction)
如果传入的 key 不存在或 get(key)为空，则返回空，不处理。
如果 get(key) 不为空则执行 BiFunction.apply(key,oldValue),
如果执行结果为 null 则删除 key，执行结果不为null 则返回执行结果


    /** * computeIfPresent(K key, * BiFunction<? super K, ? super V, ? extends V> remappingFunction) * 如果传入的 key 不存在或 get(key)为空，则返回空，不处理； * 如果 get(key) 不为空则执行 BiFunction.apply(key,oldValue), 如果执行结果为 null 则删除 key， * 执行结果不为null 则返回执行结果 */
    public static void testComputeIfPresent(){
        String ret;
        Map<String, String> map = new HashMap<>();
        ret = map.computeIfPresent("a", (key, value) -> key + value);
// null {}
        System.out.println(ret + " " + map);

        map.put("a", null);
        ret = map.computeIfPresent("a", (key, value) -> key + value);
// null {a=null}
        System.out.println(ret + " " + map);

        map.put("a", "+aaa");
        ret = map.computeIfPresent("a", (key, value) -> key + value);
// a+aaa {a=a+aaa}
        System.out.println(ret + " " + map);
        ret = map.computeIfPresent("a", (key, value) -> null);
// null {}
        System.out.println(ret + " " + map);
    }

computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction)
如果传入的 key 值不存在，或 get(key) 为 null, 则执行 Function 结果并设置为新值
如果传入的 key 值存在，且 get(key)不为 null, 则忽略函数，直接返回当前值


    /** * computeIfAbsent(K key, * Function<? super K, ? extends V> mappingFunction) * 如果传入的 key 值不存在，或 get(key) 为 null, 则执行 Function 结果并设置为新值 * 如果传入的 key 值存在，且 get(key)不为 null, 则忽略函数，直接返回当前值 * */
    public static void testComputeIfAbsent(){
        String ret;
        Map<String, String> map = new HashMap<>();
        ret = map.computeIfAbsent("a", key -> key + "123");
// a123 {a=a123}
        System.out.println(ret + " " + map);

        ret = map.computeIfAbsent("a", key -> key + "456");
// a123 {a=a123}
        System.out.println(ret + " " + map);

        map.put("a", null);
        ret = map.computeIfAbsent("a", key -> key + "456");
// a123 {a=a123}
        System.out.println(ret + " " + map);

        ret = map.computeIfAbsent("a", key -> null);
// a123 {a=a123}
        System.out.println(ret + " " + map);
    }

replace(K key, V value)
如果传入的 key 存在（无论 get(key) 是否为null），则替换值,返回旧值
如果不存在 key ,则不处理

/** * replace(K key, V value) * 如果传入的 key 存在（无论 get(key) 是否为null），则 替换值,返回 旧值 * 如果不存在 key ,则 不处理 */
    public static void testReplace(){
        String ret;
        Map<String, String> map = new HashMap<>();
        ret = map.replace("a", "abc");
// null {}
        System.out.println(ret + " " + map);

        map.put("a", "ddd");
        ret = map.replace("a", "abc");
// ddd {a=abc}
        System.out.println(ret + " " + map);

        ret = map.replace("a", null);
// abc {a=null}
        System.out.println(ret + " " + map);
    }

boolean replace(K key, V oldValue, V newValue)
如果传入的 key 不存在，则返回 false,
如果传入的 key 存在，且指定的 oldValue = get(key) 采用 newValue 替代旧值，返回 ture
如果传入的 key 存在，但指定的 oldValue != get(key) 则不处理，返回 false

  /** * boolean replace(K key, V oldValue, V newValue) * 如果传入的 key 不存在，则返回 false, * 如果传入的 key 存在，且指定的 oldValue = get(key) 采用 newValue 替代旧值，返回 ture * 如果传入的 key 存在，但指定的 oldValue != get(key) 则不处理，返回 false */
    public static void testReplace2(){
        boolean ret;
        Map<String, String> map = new HashMap<>() ;
        ret = map.replace("a", null, "aaa");
// false {}
        System.out.println(ret + " " + map);

        map.put("a", null);
        ret = map.replace("a", null, "aaa");
// true {a=aaa}
        System.out.println(ret + " " + map);

        ret = map.replace("a", "aaa", null);
// true {a=null}
        System.out.println(ret + " " + map);

        ret = map.replace("a", "aaa", "bbb");
// false {a=null}
        System.out.println(ret + " " + map);
    }

replaceAll(BiFunction<? super K, ? super V, ? extends V> function)
对 Map 中的每一个元素应用函数 Bifunction, 新值为 Bifunction.apply(k,v) 的返回值

 /** * replaceAll(BiFunction<? super K, ? super V, ? extends V> function) * 对 Map 中的每一个元素应用函数 Bifunction, 新值为 Bifunction.apply(k,v) 的返回值 */
    public static void testReplaceAll(){
        Map<String, String> map = new HashMap<>() ;
        map.put("a", "aaa");
        map.put("b", "bbb");
        map.put("c", null);
// {a=aaa, b=bbb, c=null}
        System.out.println(map);
        map.replaceAll((key, value) -> key + "-" + value);
// {a=a-aaa, b=b-bbb, c=c-null}
        System.out.println(map);
    }

V compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction)
无论 key 是否存在，get(key) 是否为null, 都执行 BiFunciton , 但 key 不存在时，默认 get(key) 为 null;
BiFunction 执行结果作为 key 的新值，但 BiFunction 返回 null时，则是删除该 key , 返回null,
其他情况就返回结果为新值

compute 方法是 testComputeIfAbsent 和 testComputeIfPresent 的结合体
无论 key 是否为空都执行，结果集为 null 则删除key

/** * V compute(K key, * BiFunction<? super K, ? super V, ? extends V> remappingFunction) * 无论 key 是否存在，get(key) 是否为null, 都执行 BiFunciton , 但 key 不存在时，默认 get(key) 为 null * BiFunction 执行结果作为 key 的新值，但 BiFunction 返回 null时， 则是删除该 key * 返回结果为新的值 * * compute 方法是 testComputeIfAbsent 和 testComputeIfPresent 的结合体, * 无论 key 是否为空都执行，结果集为 null 则删除key */
    public static void testCompute(){
        String ret;
        Map<String, String> map = new HashMap<>() ;
        ret = map.compute("a", (key, value) -> "a" + value);
// anull {a=anull}
        System.out.println(ret + " " + map);
        ret = map.compute("a", (key, value) -> "a" + value);
// aanull {a=aanull}
        System.out.println(ret + " " + map);
        ret = map.compute("a", (key, value) -> null);
// null {}
        System.out.println(ret + " " + map);
    }

merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction)
如果指定的 key 不存在，或 get(key) 为 null 时，则将 value 作为新值
如果get(key) 不为null 则执行 BiFunction.apply(oldValue,value) 作为新值，
如果新值为 null, 则删除该 key.返回 null,
如果新值不为 null, 则返回

/** * merge(K key, V value, * BiFunction<? super V, ? super V, ? extends V> remappingFunction) * 如果指定的 key 不存在，或 get(key) 为 null 时，则将 value 作为新值 * 如果get(key) 不为null 则执行 BiFunction.apply(oldValue,value) 作为新值， * 如果新值为 null, 则删除该 key.返回 null, * 如果新值不为 null, 则返回 */
    public static void testMerge(){
        String ret;
        Map<String, String> map = new HashMap<>() ;
        ret = map.merge("a", "aa", (oldValue, value) -> oldValue + "-" + value);
// aa {a=aa}
        System.out.println(ret + " " + map);

        ret = map.merge("a", "bb", (oldValue, value) -> oldValue + "-" + value);
        System.out.println(ret + " " + map);

        ret = map.merge("a", "bb", (oldValue, value) -> null);
        System.out.println(ret + " " + map);

        map.put("a", null);
        ret = map.merge("a", "aa", (oldValue, value) -> oldValue + "-" + value);
        System.out.println(ret + " " + map);

        map.put("a", null);
        ret = map.merge("a", "bb", (oldValue, value) -> null);
        System.out.println(ret + " " + map);

        ret = map.merge("a", null, (oldValue, value) -> oldValue + "-" + value);
        System.out.println(ret + " " + map);
    }

    原文作者：z_yemu
    原文地址: https://blog.csdn.net/z_yemu/article/details/89926791
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。