Java 8 Map新增方法

方法列表

• default V putIfAbsent(K key, V value)
  若是指定的 key 存在，若 key 的值不为 null，该方法不作任何操做，若 key 的值为 null，将指定的 value 关联给 key 并保存到当前集合；若指定的 key 不存在， 将指定的 value 关联给 key 并保存到当前集合
• default V getOrDefault(Object key, V defaultValue)
  若是指定的 key 存在（无论值是否为 null），该方法不作任何操做；若 key 不存在，将指定的 value 关联给 key 并保存到当前集合
• default V compute(K key, BiFunction<!--? super K-->, ? super V, ? extends V remappingFunction)
  将 remappingFunction 的计算结果的 value 关联到指定的 key；若指定的 key 不存在于当前集合，会在当前集合中建立 key 以及 key 对应的 value
• default computeIfAbsent(K key, Function<!--? super K, ? extends V--> mappingFunction)
  当 key 为 null 或 key 所对应的 value 为 null 时，执行该方法，将 mappingFunction 的计算结果的 value 关联到指定的 key；若指定的 key不存在于当前集合，会在当前集合中建立 key 以及 key 所对应的 value
• default computeIfPersent(K key, BiFunction<!--? super K, ? super V, ? extends V--> remappingFunction)
  当 key 不为 null 而且 key 所对应的 value 不为 null 时，执行该方法，将 remappingFunction 的计算结果的 value 关联到指定的 key；若指定的 key 不存在于当前集合，不会建立 key
• default V merge(K key, V value, BiFunction<!--? super V, ? super v, ? extends V--> remappingFunction)
  若是指定的 key 不存在或 key 的值为 null，将指定的 value 设置为 key 的值；不然根据 key 的旧的值 oldValue，value 计算出新的值 newValue，若是 newValue 为 null，则删除该 key，不然设置 key 的值为 newValue
  -default boolean remove(Object key, Object value)
  若是 key 的值与指定的值 value 相等（equals),则从当前集合中移除这个 key
• default V replace(K key, V value)
  若 key 存在，将 key 的旧值替换成指定的 value；若 key 不存在，不会将指定的 key，value 保存到当前集合
• default boolean replace(K key, V oldValue, V newValue)
  若 key 存在，key 关联的旧值与指定的 oldValue 相等，将 key 关联的旧值替换为指定的 newValue
• default void replaceAll(BiFunction<!--? super K, ? super V, ? extends V function)
  将 function 的返回值 用来替换当前集合中的全部 key 的值

---

方法示例

• default V putIfAbsent(K key, V value)

public class App 
{
    public static void main( String[] args )
    {
        Map<String,Object--> hashMap = new HashMap&lt;&gt;();
        hashMap.put("name",null);
        hashMap.put("country","china");
	// putIfAbsent 方法将值为 null 的键 name 赋值为 mike，并返回键 name 的旧值 null
        System.out.println("putIfAbsent('name', 'mike')的返回值：" + hashMap.putIfAbsent("name", "mike"));	
	// putIfAbsent 方法不改变键为 country 的值，由于键 country 的值为 china（不为 null），并返回旧值 china
        System.out.println("putIfAbsent('country', 'japan')的返回值：" + hashMap.putIfAbsent("country", "japan"));	
        hashMap.forEach((k,v) -&gt; System.out.println(k + ":" + v));	
    }
}
~~out:putIfAbsent('name', 'mike')的返回值：null
~~out:putIfAbsent('country', 'japan')的返回值：china
~~out:country:china
~~out:name:mike

• default V getOrDefault(Object key, Object value)

public class App 
{
    public static void main( String[] args )
    {
        Map<string,object> hashMap = new HashMap&lt;&gt;();
        hashMap.put("name",null);
        // 若键 name 不存在， getOrDefault 将指定的值 tom 关联给键 name，并保存到 hashMap中；
        // 若键 name 存在（无论值是否为 null）；getOrDefault 将不作任何操做
        hashMap.getOrDefault("name", "tom");
        hashMap.forEach((k,v) -&gt; System.out.println(k + ":" + v));
    }
}
~~out:name:null

• default V compute(K key, BiFunction<!--? super K-->, ? super V, ? extends V) remappingFunction

public class App 
{
    public static void main( String[] args )
    {
        Map<string,object> hashMap = new HashMap&lt;&gt;();
        hashMap.put("name","tom");
        // compute 方法将键 name 的值赋为 函数式接口 BiFunction 的实现类方法 apply 的返回结果；若 apply 的返回结果为 null ，键 name 将会被从 hashMap 中移除；若 hashMap 中没有键 name，compute 会将指定的 key 和它对应计算的 value 存入 hashMap中
        hashMap.compute("name", new BiFunction<string, object, object>() {
            @Override
            public Object apply(String s, Object o) {
                return o;
            }
        });
        // lambda 写法
        hashMap.compute("name",(k,v) -&gt; "tom");
        hashMap.forEach((k,v) -&gt; System.out.println(k + ":" + v));
    }
}
~~out:name:tom

• default computeIfAbsent(K key, Function<!--? super K, ? extends V--> mappingFunction)

public class App 
{
    public static void main( String[] args )
    {
        Map<string,object> hashMap = new HashMap&lt;&gt;();
        hashMap.put("name",null);
        // 键 name 的值为 null ，符合执行 computeIfAbsent 方法的执行条件，将 apply 方法返回的值 jerry 关联给指定的键 name；
        // 若键 name 的值不为 null；不符合执行 computeIfAbsent 方法的执行条件，所以 apply 方法的返回值不会影响键 name 对应的值 value
        hashMap.computeIfAbsent("name", new Function<string, object>() {
            @Override
            public Object apply(String s) {
                return "jerry";
            }
        });
        // lambda 写法
        //hashMap.computeIfAbsent("name", k -&gt; "jerry");
        hashMap.forEach((k,v) -&gt; System.out.println(k + ":" + v));
    }
}
~~out:name:jerry

• default computeIfPersent(K key, BiFunction<!--? super K, ? super V, ? extends V--> remappingFunction)

public class App 
{
    public static void main( String[] args )
    {
        Map<string,object> hashMap = new HashMap&lt;&gt;();
        hashMap.put("name","tom");
        // 键 name 的值为 tom，符合 computeIfPresent 方法的执行条件，将 apply 方法的返回值 mike 关联给指定的键 name
        // 若键 name 不存在于 hashMap 中，apply 方法不会将 name-mike 存入当前 hashMap
        // 若键 name 对应的值为 null，不会将 apply 的返回值 mike 关联给键 name
        hashMap.computeIfPresent("name", new BiFunction<string, object,object>(){
            @Override
            public Object apply(String s, Object o) {
                return "mike";
            }
        });
        // lambda 写法
        // hashMap.computeIfPresent("name", (k,v) -&gt; "mike");
        hashMap.forEach((k,v) -&gt; System.out.println(k + ":" + v));
    }
}
~~out:name:mike

• default V merge(K key, V value, BiFunction<!--? super V, ? super v, ? extends V--> remappingFunction)

public class App 
{
    public static void main( String[] args )
    {
        Map<string,object> hashMap = new HashMap&lt;&gt;();
        hashMap.put("name","jerry");
        // 键 name 的值不为 null，将 name 的值关联为 apply 方法计算出的新值 jerry-&gt;tom;
        // 若键 name 不存在或者键 name 的值为 null，merge 方法指定的 value 关联给键 name，不执行 apply 方法；
        // 若 name 存在且 name 的值不为 null，而 apply 方法返回的值为 null ，那么 hashMap 中的键 name 将被移除
        hashMap.merge("name", "tom", new BiFunction<object,object, object>() {
            @Override
            // o 为旧值 jerry；o2 为给定的值 tom
            public Object apply(Object o, Object o2) {
                return (String)o + "-&gt;" + o2;
            }
        });
        // lambda 写法
        // hashMap.merge("name", "tom", (oldValue, newValue) -&gt; oldValue + "-&gt;" + newValue);
        hashMap.forEach((k,v) -&gt; System.out.println(k + ":" + v));
    }
}
~~out:jerry-&gt;tom

• default boolean remove(Object key, Object value)

public class App 
{
    public static void main( String[] args )
    {
        Map<string,object> hashMap = new HashMap&lt;&gt;();
        hashMap.put("name","jerry");
        hashMap.put("country", "china");
		// remove 方法中指定的键 name 的值 jerry 与当前 hashMap 中键 name 的值一致，所以键 name 从 hashMap 中被移除
        hashMap.remove("name","jerry");
        hashMap.forEach((k,v) -&gt; System.out.println(k + ":" + v));
    }
}
~~out:country:china

• default V replace(K key, V value)

public class App 
{
    public static void main( String[] args )
    {
        Map<string,object> hashMap = new HashMap&lt;&gt;();
        hashMap.put("name",null);
        // 若键 name 存在(无论值是否为 null)，将键 name 的值 null 替换为 replace 方法指定的值 tom
        // 若键 name 不存在，不会将 replace 指定的键 name 和值 tom 保存到当前 hashMap 中
        hashMap.replace("name","tom");
        hashMap.forEach((k,v) -&gt; System.out.println(k + ":" + v));
    }
}
~~out:name:tom

• default boolean replace(K key, V oldValue, V newValue)

public class App 
{
    public static void main( String[] args )
    {
        Map<string,object> hashMap = new HashMap&lt;&gt;();
        hashMap.put("name",null);
        // 若键 name 存在（无论键 name 的值是否为 null），若键 name 的旧值 null 与 replace 方法中指定的 oldValue 相等，将键 name 的旧值 null 替换为 replace 方法中指定的 newValue
        hashMap.replace("name",null,"jerry");
        hashMap.forEach((k,v) -&gt; System.out.println(k + ":" + v));
    }
}
~~out:name:jerry

• default void replaceAll(BiFunction<!--? super K, ? super V, ? extends V function)

public class App 
{
    public static void main( String[] args )
    {
        Map<String,Object--> hashMap = new HashMap&lt;&gt;();
        hashMap.put("name",null);
        hashMap.put("sex","man");
        hashMap.put("country","china");
        // 用 apply 方法的返回值将键 name 的值替换为 name-&gt;null,将键 sex 的值替换为 sex-&gt;man,将键 country 的值替换为 country-&gt;china
        hashMap.replaceAll(new BiFunction<string, object, object>() {
            @Override
            // s:旧的 key；o:旧的 value
            public Object apply(String s, Object o) {
                return s + "-&gt;" + o;
            }
        });
        // lambda 写法
        // hashMap.replaceAll((k,v) -&gt; k + "-&gt;" + v);
        hashMap.forEach((k,v) -&gt; System.out.println(k + ":" + v));
    }
}
~~out:country:country-&gt;china
~~out:sex:sex-&gt;man
~~out:name:name-&gt;null
```</string,></string,object></string,object></string,object></object,object,></string,object></string,></string,object></string,></string,object></string,></string,object></string,object>