package com.jandmin.demo;
import java.util.HashMap;
import java.util.Map;
import java.util.function.BiFunction;
/**
* @Description: java8中的map新方法
* @Author: JandMin
*/
public class MainTest {
public static void main(String[] args) {
//map 新特性
Map<Integer,String> map = new HashMap<Integer,String>();
for(int i=0; i<6; i++){
map.put(i,"val_"+i);
}
map.put(10,null);
//1:遍历
map.forEach((key,value) -> System.out.println(key+":"+value));
//2:V getOrDefault(key,defaultValue):获取key值,如果key不存在则用defaultValue
System.out.println("3-->"+map.getOrDefault(3,"val_66"));//3-->val_3
System.out.println("10-->"+map.getOrDefault(10,"val_66"));//10-->null
System.out.println("11-->"+map.getOrDefault(11,"val_66"));//11-->val_66
//3:V putIfAbsent(K key, V value):根据key匹配Node,如果匹配不到则增加key-value,返回null,如果匹配到Node,如果oldValue不等于null则不进行value覆盖，返回oldValue
System.out.println(map.putIfAbsent(3,"val_66"));//val_3
System.out.println(map.putIfAbsent(10,"val_66"));//null
System.out.println(map.putIfAbsent(11,"val_66"));//null
System.out.println(map.get(3)+"--"+map.get(10)+"--"+map.get(11));//val_3--val_66--val_66
//4:boolean remove(Object key, Object value):根据key匹配node，如果value也相同则删除
System.out.println(map.size());//8
map.remove(10,"66");
map.remove(11,"val_66");
System.out.println(map.size());//7
System.out.println(map.toString());//{0=val_0, 1=val_1, 2=val_2, 3=val_3, 4=val_4, 5=val_5, 10=val_66}
//5:boolean replace(K key, V oldValue, V newValue):根据key匹配node,如果value也相同则使用newValue覆盖返回true，否则返回false
map.put(11,null);
map.replace(3,"3","33");
map.replace(10,"val_66","val_666666");
map.replace(11,null,"val_11");
map.replace(11,null,"val_11");
System.out.println(map.toString());//{0=val_0, 1=val_1, 2=val_2, 3=val_3, 4=val_4, 5=val_5, 10=val_666666, 11=val_11}
/** 6:
* void replaceAll(BiFunction function)：调用此方法时重写BiFunction的Object apply(Object o, Object o2)方法，
* 其中o为key，o2为value，根据重写方法逻辑进行重新赋值。
*/
map.replaceAll((key,value) -> {
if(key == 2){
return value+"222";
}
return value;
});
System.out.println(map.toString());//{0=val_0, 1=val_1, 2=val_2222, 3=val_3, 4=val_4, 5=val_5, 10=val_666666, 11=val_11}
/** 7:
* V compute(K key,BiFunction remappingFunction)：根据key做匹配，根据BiFunction的apply返回做存储的value。
* 匹配到Node做value替换，匹配不到新增node。apply的返回值如果为null则删除该节点，否则即为要存储的value。
*/
System.out.println("---------------------- compute -----------------------");
System.out.println(map.compute(3,new BiFunction() {
@Override
public Object apply(Object key, Object value) {
return key+":"+value;
}
}));//3:val_3 -》用返回值覆盖原来的值，这里用了java7的编码方式，以下均采用java8的lanbda表达式
System.out.println(map.compute(10,(key,value) -> {return value.split("_")[1];}));//666666 -》用返回值覆盖原来的值
System.out.println(map.compute(6,(key,value) -> null));//null -》返回值为null，则删除该key值
System.out.println(map.toString());//{0=val_0, 1=val_1, 2=val_2, 3=3:val_3, 4=val_4, 5=val_5, 10=666666, 11=val_11}
/** 8:
* merge(K key, V value,BiFunctionsuper V, ? super V, ? extends V> remappingFunction):
* 功能大部分与compute相同，不同之处在于BiFunction中apply的参数，入参为oldValue、value，
* 调用merge时根据两个value进行逻辑处理并返回value。
*/
System.out.println(map.merge(3,"val_3",(value,newValue) -> newValue));//val_3 --》返回值覆盖原来的value
System.out.println(map.merge(10,"33334",(a,b) -> (Integer.valueOf(a)+Integer.valueOf(b))+""));//700000
System.out.println(map.merge(8,"88",(oldValue,newValue) -> oldValue+newValue));//88 -》key不存在则新增
System.out.println(map.merge(11,"11",(old,newValue) -> null));//null -》返回值为null,删除该节点
System.out.println(map.toString());//{0=val_0, 1=val_1, 2=val_2, 3=val_3, 4=val_4, 5=val_5, 8=88, 10=700000}
/** 9:
* computeIfAbsent(K key,Functionsuper K, ? extends V> mappingFunction):
* 根据key做匹配Node，（匹配不到则新建然后重排）
* 如果Node有value，则直接返回oldValue，
* 如果没有value则根据Function接口的apply方法获取value，返回value。
* Function接口的apply的入参为key，调用computeIfAbsent时重写Function接口可以根据key进行逻辑处理，
* apply的返回值即为要存储的value。
*/
System.out.println("----------------------computeIfAbsent------------------------");
map.put(8,null);
System.out.println(map.toString());//{0=val_0, 1=val_1, 2=val_2, 3=val_3, 4=val_4, 5=val_5, 8=null, 10=700000}
System.out.println(map.computeIfAbsent(0,key -> key+"000"));//val_0 -》key值存在，直接返回oldValue
System.out.println(map.computeIfAbsent(7,key -> "value_"+key));//value_7 -》key匹配不到，直接新增，返回值为value
System.out.println(map.computeIfAbsent(8,key -> "88"));//88 -》key匹配到了，value为null，返回值作为value
System.out.println(map.toString());//{0=val_0, 1=val_1, 2=val_2, 3=val_3, 4=val_4, 5=val_5, 7=value_7, 8=88, 10=700000}
/** 10:
* V computeIfPresent(K key,BiFunction remappingFunction)：
* 根据key做匹配，如果匹配不上则返回null,匹配上根据BiFunction的apply方法获取value，返回value。
* BiFunction接口的apply的入参为key、oldValue，调用computeIfPresent时重写Function接口
* 可以根据key和oldValue进行逻辑处理，apply的返回值如果为null则删除该节点，否则即为要存储的value。
*/
map.remove(7);
map.remove(8);
map.replace(10,null);
map.remove(0,"val_0");//value匹配到了删除
map.remove(1,"val_0");//value匹配失败，不会删除
System.out.println(map.toString());//{1=val_1, 2=val_2, 3=val_3, 4=val_4, 5=val_5, 10=null}
System.out.println(map.computeIfPresent(3,(key,value) -> key+":"+value));//3:val_3 -》key存在，根据返回值修改value
System.out.println(map.computeIfPresent(0,(key, value) -> "0000"));//null -》key不存在，返回null,不做任何操作
System.out.println(map.computeIfPresent(1,(key, value) -> null));//null -》key存在，根据返回值修改value
System.out.println(map.computeIfPresent(10,(key,value) -> "val_10"));//null -》oldValue值为null，删除节点
System.out.println(map.toString());//{2=val_2, 3=3:val_3, 4=val_4, 5=val_5, 10=null}
/** 比较
* compute：根据key做匹配，key,value为参数，匹配到Node做value替换，匹配不到新增node。apply的返回值为null则删除该节点。
* merge：oldValue，newValue作为为参数，其它功能于compute类似
* computeIfAbsent：根据key匹配，参数为key,存在且value不为null，不做修改，为null用返回值作为value，不存在则新增
* computeIfPresent：key,value作为参数，存在,原来的值为null不做操作，否则返回值作为新的value覆盖原来；不存在，不做操作；返回值为null删除该节点
*
*/
}
}
原文：https://blog.csdn.net/ItRuler/article/details/81002264
computeIfAbsent
存在且value不为null，则返回value
不满足上述条件下，先检查Function返回值，若为null，返回null
存在但value为null，则将Function返回值作为value，返回value
不存在，新建节点，将Function返回值作为value，返回value
使用场景：从map中获取所需要的value，若其为null，就用准备好的值即Function的返回值
原做法：
Map<Integer, List<String>> map = new HashMap<>();
map.put(1, new ArrayList<>(Arrays.asList("1","2","3")));
System.out.println(map);
List<String> strings = map.get(1);
if (strings == null){
strings = new ArrayList<>();
}
strings.add("4");
System.out.println(map);
输出：
{1=[1, 2, 3]}
{1=[1, 2, 3, 4]}
修改后做法：
Map<Integer, List<String>> map = new HashMap<>();
map.put(1, new ArrayList<>(Arrays.asList("1","2","3")));
System.out.println(map);
map.computeIfAbsent(1, e -> new ArrayList<>()).add("4");
System.out.println(map);
computeIfPresent
存在且value不为null：1，BiFunction返回值为null，删除该节点；2，BiFunction返回值不为null，作为新value，返回其值
不存在或其value为null，返回null
使用场景：更新map中存在的且其value值不为null的键值对的值
原文：https://blog.csdn.net/sinat_34976604/article/details/82055250
