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>