java8中Map的10个常用新方法

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

    原文作者:鱿鱼ing
    原文地址: https://blog.csdn.net/qq_30831935/article/details/92785856
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞