Java8中Map的新特性和常用方法

自从 java8 出了一些新特性之后紧接着也出了许多类的新方法例如 Map 在 java8 就新增了许多实用的方法，接下来慢慢介绍也顺便记录一下，可能有一部分人在看官方文档的介绍不是那么的理解或者是看其它博主的文章，我这里就用我所理解的方式来给大家分享一下我对 java8 新增的 Map 方法的理解，首先来看第一个

getOrDefault

可能你们在实际的业务开发当中会使用到 Map 当你想要获取 Map 当中某个 key 的 value 时在之前的写法就是 map.get("BNTang"); 在 java8 当中提供了一个 getOrDefault 意思就是说：从 Map 当中获取 key 为 BNTang 的 value 值，如果存在该 BNTang key 则返回该 key 对应的 value，如果该 BNTang key 不存在，返回第二个形参指定的值这样的写法好处就是可以避免 空指针异常，如果使用之前的方式获取很有可能会返回一个 null 这就会导致你的程序出现异常

/**
 * @author BNTang
 */
public class Test {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();

        Integer result = map.getOrDefault("BNTang", 666);

        System.out.println(result);
    }
}

merge

merge() 方法会先判断指定的 key 是否存在，如果不存在，则添加键值对到 hashMap 中。语法如下，注：hashmap 是 HashMap 类的一个对象。

default V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
    ...
}

参数说明

• key：键
• value：值
• remappingFunction：重新映射函数，用于重新计算值

返回值

如果 key 对应的 value 不存在，则返回该 value 值，如果存在，则返回通过 remappingFunction 重新计算后的值。

/**
 * @author BNTang
 */
public class Test {
    public static void main(String[] args) {
        Map<String, Integer> currentMap = new HashMap<>();
        currentMap.put("BNTang", 2);
        currentMap.put("zs", 1);
        currentMap.put("ls", 3);
        currentMap.put("ww", 4);

        Map<String, Integer> targetMap = new HashMap<>();
        targetMap.put("Jonathan_Lee", 2);
        targetMap.put("zs", 1);
        targetMap.put("ls", 6);

        currentMap.forEach((k, v) -> {
            targetMap.merge(k, v, new BiFunction<Integer, Integer, Integer>() {
                @Override
                public Integer apply(Integer v1, Integer v2) {
                    return v1 + v2;
                }
            });
        });

        System.out.println(targetMap);
    }
}

结果如下

{ww=4, BNTang=2, Jonathan_Lee=2, ls=9, zs=2}

compute

compute() 方法对 hashMap 中指定 key 的值进行重新计算。compute() 方法的语法为：

default V compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
    ...
}

注：hashmap 是 HashMap 类的一个对象。

参数说明

• key：键
• remappingFunction：重新映射函数，用于重新计算值

返回值

如果 key 对应的 value 不存在，则返回该 null，如果存在，则返回通过 remappingFunction 重新计算后的值，如果不存在这个 key，则添加到 hasMap 中。

/**
 * @author BNTang
 */
public class Test {
    public static void main(String[] args) {
        Map<String, Integer> currentMap = new HashMap<>();
        currentMap.put("BNTang", 2);
        currentMap.put("zs", 1);
        currentMap.put("ls", 3);
        currentMap.put("ww", 4);

        Map<String, Integer> targetMap = new HashMap<>();
        targetMap.put("Jonathan_Lee", 2);
        targetMap.put("zs", 1);
        targetMap.put("ls", 6);

        currentMap.forEach((k, v) -> {
            targetMap.compute(k, new BiFunction<String, Integer, Integer>() {
                @Override
                public Integer apply(String s, Integer v1) {
                    return null != v1 ? v1 + v : v;
                }
            });
        });

        System.out.println(targetMap);
    }
}

结果如下

{ww=4, BNTang=2, Jonathan_Lee=2, ls=9, zs=2}

computeIfPresent

computeIfPresent() 方法对 hashMap 中指定 key 的值进行重新计算，前提是该 key 存在于 hashMap 中。computeIfPresent() 方法的语法为：

default V computeIfPresent(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
    ...
}

注：hashmap 是 HashMap 类的一个对象。

参数说明

• key：键
• remappingFunction：重新映射函数，用于重新计算值

返回值

如果 key 对应的 value 不存在，则返回该 null，如果存在，则返回通过 remappingFunction 重新计算后的值。

/**
 * @author BNTang
 */
public class Test {
    public static void main(String[] args) {
        Map<String, Integer> currentMap = new HashMap<>();
        currentMap.put("BNTang", 2);
        currentMap.put("zs", 1);
        currentMap.put("ls", 3);
        currentMap.put("ww", 4);

        Map<String, Integer> targetMap = new HashMap<>();
        targetMap.put("Jonathan_Lee", 2);
        targetMap.put("zs", 1);
        targetMap.put("ls", 6);

        currentMap.forEach((k, v) -> {
            targetMap.computeIfPresent(k, new BiFunction<String, Integer, Integer>() {
                @Override
                public Integer apply(String s, Integer v1) {
                    return v1 + v;
                }
            });
        });

        System.out.println(targetMap);
    }
}

结果如下

{Jonathan_Lee=2, ls=9, zs=2}

computeIfAbsent

computeIfAbsent() 方法对 hashMap 中指定 key 的值进行重新计算，如果不存在这个 key，则添加到 hasMap 中。computeIfAbsent() 方法的语法为：

default V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) {
    ...
}

注：hashmap 是 HashMap 类的一个对象。

参数说明

• key：键
• mappingFunction：重新映射函数，用于重新计算值

返回值

如果 key 对应的 value 不存在，则使用获取 mappingFunction 重新计算后的值，并保存为该 key 的 value，否则返回 value。

/**
 * @author BNTang
 */
public class Test {
    public static void main(String[] args) {
        Map<String, Integer> currentMap = new HashMap<>();
        currentMap.put("BNTang", 2);
        currentMap.put("zs", 1);
        currentMap.put("ls", 3);
        currentMap.put("ww", 4);

        Map<String, Integer> targetMap = new HashMap<>();
        targetMap.put("Jonathan_Lee", 2);
        targetMap.put("zs", 1);
        targetMap.put("ls", 6);

        currentMap.forEach((k, v) -> {
            targetMap.computeIfAbsent(k, new Function<String, Integer>() {
                @Override
                public Integer apply(String s) {
                    return v;
                }
            });
        });

        System.out.println(targetMap);
    }
}

结果如下：

{ww=4, BNTang=2, Jonathan_Lee=2, ls=6, zs=1}

如上的代码没有使用 lambda 表达式去简化方便你们查看

• 目前慢慢记录，持续更新，如有不正确，还请大佬们指正🐤