lambda表达式操作map

Map<Integer, String> map = new HashMap<>(16);
map.put(1, "one");
map.put(2, "two");
map.put(3, "three");
map.put(4, "four");
map.put(5, "five");

// Java7以及之前写法
for (Map.Entry<Integer, String> entry : map.entrySet()) {
    System.out.println(entry.getKey() + "=" + entry.getValue());
}
// 使用Map.forEach()方法，并使用匿名内部类实现BiConsumer接口
map.forEach(new BiConsumer<Integer, String>() {
    @Override
    public void accept(Integer integer, String s) {
        System.out.println("key=" + integer + " value=" + s);
    }
});
// 使用lambda表达式
map.forEach((k,v)-> System.out.println("key="+k+" value="+v));

// Java7以及之前做法
if (map.containsKey(6)) {
    System.out.println(map.get(4));
} else {
    System.out.println("NoValue");
}
// Java8使用Map.getOrDefault()，如果不存在直接返回NoValue
System.out.println(map.getOrDefault(6, "NoValue"));

/*
 * 只有在不存在key值的映射或映射值为null时
 * 才将value指定的值放入到Map中，否则不对Map做更改
 */
map.putIfAbsent(6, "null-six");
map.forEach((k, v) -> {
    System.out.println("k=" + k + " v=" + v);
});

// 只有在当前Map中key正好映射到value时才删除该映射，否则什么也不做
map.remove(5,"five");
map.forEach((k,v)-> System.out.println("key="+k+" value="+v));

// 因为map中key不可重复，因此会替换掉以前key对应的value
map.put(5, "five1");
// 如果存在对应的key，则替换掉对应key的值
map.replace(5, "six");
// map中存在key-value的映射才使用newValue替换掉oldValue
map.replace(5, "five", "newfive");
map.forEach((k, v) -> System.out.println("key=" + k + " value=" + v));

// Java7以及之前替换Map中所有映射关系
for (Map.Entry<Integer, String> entry : map.entrySet()) {
    entry.setValue(entry.getValue().toUpperCase());
}
// 遍历输出映射key-value
map.forEach((k, v) -> System.out.println("key=" + k + " value=" + v));
// 调用replaceAll()方法，并使用匿名内部类实现BiFunction接口
map.replaceAll(new BiFunction<Integer, String, String>() {
    @Override
    public String apply(Integer integer, String s) {
        return s.toUpperCase();
    }
});
// 遍历输出映射key-value
map.forEach((k, v) -> System.out.println("key=" + k + " value=" + v));
// 使用replaceAll()并结合Lambda表达式实现
map.replaceAll((k, v) -> v.toUpperCase());
// 遍历输出映射key-value
map.forEach((k, v) -> System.out.println("key=" + k + " value=" + v));

/*
 * 如果Map中key对应的映射不存在或者为null，则将value（不能是null）关联到key上，否则执行remappingFunction；
 * 如果执行结果非null则用该结果跟key关联，否则在Map中删除key的映射。
 */
// 使用匿名内部类实现BiFunction接口
map.merge(6, "+", new BiFunction<String, String, String>() {
    @Override
    public String apply(String s, String s2) {
        return s + s2;
    }
});
// 遍历输出key-value
map.forEach((k, v) -> System.out.println("key=" + k + " value=" + v));
// 使用lambda表达式实现
map.merge(6, "+", (s, s2) -> s + s2);
// 遍历输出key-value
map.forEach((k, v) -> System.out.println("key=" + k + " value=" + v));

// 使用匿名内部类实现BiFunction接口写法
map.compute(5, new BiFunction<Integer, String, String>() {
  @Override
  public String apply(Integer integer, String s) {
      return s == null ? "null" : s + " is not null";
  }
});
// lambda表达式写法
map.compute(5, (integer, s) -> s == null ? "null" : s + "is not null");
// 遍历输出key-value映射
map.forEach((k, v) -> System.out.println("key=" + k + " value=" + v));

// 实现一个key对应多个值
Map<Integer, Set<String>> map = new HashMap<>(16);
// Java7及以前的实现方式
if (map.containsKey(1)) {
    map.get(1).add("one");
} else {
    Set<String> valueSet = new HashSet<>();
    valueSet.add("one");
    map.put(1, valueSet);
}
// Java8的实现方式 即它会判断一下这个key是否存在并且key对应的value是否为空，
// 如果key存在且key对应的value不为null，则将这个value关联到对应的key上，即在原来的value中新增一个value
// 如果key不存在，则新增一个key-value映射关系
map.computeIfAbsent(1, v -> new HashSet<>()).add("oneone");
// 遍历输出key-value映射
map.forEach((k, v) -> System.out.println("key=" + k + " value=" + v));

Map<Integer, Set<String>> map = new HashMap<>(16);
// Java7及以前的实现方式
if (map.containsKey(1)) {
    map.get(1).add("one");
} else {
    Set<String> valueSet = new HashSet<>();
    valueSet.add("one");
    map.put(1, valueSet);
}
// 匿名内部类实现BiFunction接口，如果key存在并且计算结果不为null时将计算的结果替换掉key对应的原来的值
map.computeIfPresent(8, new BiFunction<Integer, Set<String>, Set<String>>() {
    @Override
    public Set<String> apply(Integer integer, Set<String> strings) {
        Set<String> set = new HashSet<>();
        set.add("888");
        return set;
    }
});
// lambda表达式实现
map.computeIfPresent(8, (integer, strings) -> {
    Set<String> set = new HashSet<>();
    set.add("888");
    return set;
});
// 遍历输出key-value映射
map.forEach((k, v) -> System.out.println("key=" + k + " value=" + v));