java8对map新增强的方法

java8对map新增强的方法：
getOrDefault(key,value);

 default V getOrDefault(Object key, V defaultValue) {
        V v;
       //只要满足一个条件就返回v：key对应的值不为null；或者map中有这个key
        return (((v = get(key)) != null) || containsKey(key))
            ? v
            : defaultValue;
    }

eg：map.getOrDefault(“1”, “20”)；
如果map中有key为1的，就返回这个key对应的value，即使这个key对应的是nul。
如果没有这个key，就返回默认值–》就是第二个参数20。
putIfAbsent(K key, V value)；源码

default V putIfAbsent(K key, V value) {
        //先通过这个key获取value
        V v = get(key);
        if (v == null) {
       //只有当value为null时，才新增到map中，否则还是原来的value
       //即只有当map中没有key或者有这个key但是对应的v为null，才赋值成功
            v = put(key, value);
        }

        return v;
    }

map.put(“1”,“1”);
map.putIfAbsent(“1”,“2”);//map里还是(“1”,“1”)
map.put(“33”,null);
map.putIfAbsent(“33”,“2”);//map里改为(“33”,“2”)
map.putIfAbsent(“11”,“2”);//正常的put
迭代map的新方法：foreach

default void forEach(BiConsumer<? super K, ? super V> action) {
        Objects.requireNonNull(action);
        //底层还是通过迭代器entrySet()获取Set<Map.Entry<K, V>>
        for (Map.Entry<K, V> entry : entrySet()) {
            K k;
            V v;
            try {
                k = entry.getKey();
                v = entry.getValue();
            } catch(IllegalStateException ise) {
                // this usually means the entry is no longer in the map.
                throw new ConcurrentModificationException(ise);
            }
            //获取到k和v，进行自定义的处理
            action.accept(k, v);
        }
    }

测试代码

//这里的(k,v)===》action.accept(k, v);
map.forEach(
             (k,v)->{//自定义处理
                System.out.println("forEach"+"key"+k+"value"+v);
             }
        );

map.replaceAll源码：

default void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
//function就是我们调用时写的自定义方法
        Objects.requireNonNull(function);
        //一样获取到
        for (Map.Entry<K, V> entry : entrySet()) {
            K k;
            V v;
            try {
                k = entry.getKey();
                v = entry.getValue();
            } catch(IllegalStateException ise) {
                // this usually means the entry is no longer in the map.
                throw new ConcurrentModificationException(ise);
            }
			//将kv交给自定义方法function处理，并将处理后的v返回
            v = function.apply(k, v);
            try {
                entry.setValue(v);
            } catch(IllegalStateException ise) {
                // this usually means the entry is no longer in the map.
                throw new ConcurrentModificationException(ise);
            }
        }
    }

测试代码：

map.replaceAll(//function
                //这里就是 v = function.apply(k, v);
                //==function.apply(k, v);
                (k,v)->{
                    //通过自定义方法修改v的值，再重新放到map中
                    if ("33".equals(k))  ;
                    else v="newV";
                return v;//==  返回作为v，继续走源码中v = function.apply(k, v);后面的代码
            }
        );

putIfAbsent(K key, V value)：
源码:只有当key对应的value为null时才能put进去。

default V putIfAbsent(K key, V value) {
        V v = get(key);
        if (v == null) {
            v = put(key, value);
        }
        return v;
    }

remove源码：

default boolean remove(Object key, Object value) {
		//获取到key对应的value：curValue 
        Object curValue = get(key);
        //只有两种情况有任何一个满足就会导致无法删除
       //条件1：当传来的参数value和map中key对应的value不相等
       //条件2：map中key对应的value不为null，同时map中没有这个key
        if (!Objects.equals(curValue, value) ||
            (curValue == null && !containsKey(key))) {
            return false;
        }
        remove(key);
        return true;
    }

replace源码：两种替换，条件不一样

//替换并返回结果
default boolean replace(K key, V oldValue, V newValue) {
        //获取到key对应的value：curValue
        Object curValue = get(key);
         //只有两种情况有任何一个满足就会导致返回false
       //条件1：当传来的参数oldValue和map中key对应的value不相等
       //条件2：map中key对应的value为null，同时map中没有这个key
        if (!Objects.equals(curValue, oldValue) ||
            (curValue == null && !containsKey(key))) {
            return false;
        }
        put(key, newValue);
        return true;
    }
//替换
default V replace(K key, V value) {
        V curValue;
         //map中key对应的value不为null，或者map中有这个key
         //就回将传来的参数value赋值为map中KEY为参数key对应的value
        if (((curValue = get(key)) != null) || containsKey(key)) {
            curValue = put(key, value);
        }
        return curValue;
    }

computeIfAbsent：

default V computeIfAbsent(K key,
            Function<? super K, ? extends V> mappingFunction) {
        Objects.requireNonNull(mappingFunction);
        V v;
        //判断传来的key对应的value是否为null
        if ((v = get(key)) == null) {//为null，才执行下面的
            V newValue;
        //再执行动态增强的自定义方法，返回的结果不为null，就赋值到map，并返回newValue
      //newValue = mappingFunction.apply(key)对应的就是我们调用时要实现的方法体
            if ((newValue = mappingFunction.apply(key)) != null) {
       		//自定义方法体返回的结果不为null，就将返回的结果放到map中，并return 
                put(key, newValue);
                return newValue;
            }
        }

        return v;
    }

测试代码：

String s = map.computeIfAbsent("33", k -> "fanhui");
String s2 = map.computeIfAbsent("333", k -> "fanhui");
System.out.println(s);//2
System.out.println(s2);//fanhui

computeIfPresent：源码
使用方法跟上一个差不多，不再写测试类了

default V computeIfPresent(K key,
            BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
            //首先判断自定义方法函数有没有写
        Objects.requireNonNull(remappingFunction);
        V oldValue; //判断传来的key对应的value是否为null，不为null才执行下面的
        if ((oldValue = get(key)) != null) {
        //再执行动态增强的自定义方法
      //newValue = mappingFunction.apply(key)对应的就是我们调用时要实现的方法体
            V newValue = remappingFunction.apply(key, oldValue);
            if (newValue != null) {
            //返回的结果不为null，就赋值到map，并返回newValue
                put(key, newValue);
                return newValue;
            } else {
            //返回的结果为null，就移除map中的这个key
                remove(key);
                return null;
            }
        } else {
            return null;
        }
    }

compute:源码

default V compute(K key,
            BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
        Objects.requireNonNull(remappingFunction);
        V oldValue = get(key);
//调用自定义扩展的方法，获取结果
        V newValue = remappingFunction.apply(key, oldValue);
        //如果返回的结果为空
        if (newValue == null) {
            //这个key存在或者这个key对应的old值不为null，就删除这个key
            if (oldValue != null || containsKey(key)) {
                //删除这个key
                remove(key);
                return null;
            } else {
                // nothing to do. Leave things as they were.
                return null;
            }
        //如果返回的结果不为空，直接将返回的结果作为value，put到map中
        } else {
            // add or replace old mapping
            put(key, newValue);
            return newValue;
        }
    }

测试代码：

Map<String,String> map=new HashMap<String, String>();
        map.putIfAbsent("1","3");
        map.compute("1",
                (k,v)->{
                    System.out.println(k);//1
                    System.out.println(v);//3
                    return "2";
                }
                );
        System.out.println(map.get("1"));//2
        map.compute("1",
                (k,v)->{
                    return null;
                }
                );
        System.out.println(map.get("1"));//null
        System.out.println(map.containsKey("1"));//false

源码：merge

default V merge(K key, V value,
            BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
        Objects.requireNonNull(remappingFunction);
        Objects.requireNonNull(value);
        //获取map中的老值
        V oldValue = get(key);
        //判断oldValue为null，就赋值newValue为value，否则就调用自定义方法获取返回值作为newValue
        V newValue = (oldValue == null) ? value :
                   remappingFunction.apply(oldValue, value);
        //最终如果newValue为null，就删除这个key
        if(newValue == null) {
            remove(key);
        } else {//不为null就放到map中
            put(key, newValue);
        }
        return newValue;
    }

测试代码：

Map<String,String> map=new HashMap<>();
        map.put("7777","7777");
        map.put("8888","8888");
        map.merge("7777","新增值7777",
                (k,v)->{
                    System.out.println("调用自定义方法7777");
                    return "返回值7777";
                }
                );
        map.merge("8888","新增值8888",
                (k,v)->{
                    System.out.println("调用自定义方法8888");
                    return null;
                }
        );
        map.merge("9999","新增值9999",
                    (k,v)->{
                        System.out.println("调用自定义方法9999");
                        return null;
                    }
                );
        map.forEach((k,v)->{
            System.out.println("forEach"+"key"+k+"value"+v);
            /*forEachkey7777value返回值7777
            * forEachkey9999value新增值9999
            * 8888被删除*/
        });