Map 新增方法小结
## putIfAbsent 方法如果原 map 中对应 key 的值为为 null 返回旧值，或者返回新的 value 值
示例及效果：
```java
String ret;
Map<String, String> map = new HashMap<>();
ret = map.putIfAbsent("a", "aaa"); //ret 为"aaa", map 为 {"a":"aaa"}
ret = map.putIfAbsent("a", "bbb"); //ret 为 "aaa", map 还是 {"a":"aaa"}
map.put("b", null);
ret = map.putIfAbsent("b", "bbb"); //ret 为 "bbb", map 为 {"a":"aaa","b":"bbb"}
```
## computeIfPresent 方法
方法原型 `V computeIfPresent(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction)`，如果指定的 key 存在并且相关联的 value 不为 null 时，根据旧的 key 和 value 计算 newValue 替换旧值，newValue 为 null 则从 map 中删除该 key; key 不存在或相应的值为 null 时则什么也不做，方法的返回值为最终的 map.get(key)。
示例及效果：
```java
String ret;
Map<String, String> map = new HashMap<>();
//ret null, map 为 {}
ret = map.computeIfPresent("a", (key, value) -> key + value);
//map 为 ["a":null]
map.put("a", null);
//ret null, map 为 {"a":null}
ret = map.computeIfPresent("a", (key, value) -> key + value);
map.put("a", "+aaa");
//ret "a+aaa", map 为 {"a":"a+aaa"}
ret = map.computeIfPresent("a", (key, value) -> key + value);
//ret 为 null, map 为 {}，计算出的 null 把 key 删除了
ret = map.computeIfPresent("a", (key, value) -> null);
```
计算出的值为 null 时直接删除 key 而不是设置对应 key 的值为 null, 这能照顾到值不能为 null 的 Map 实现，如 Hashtable 和 ConcurrentMap。
## computeIfAbsent 方法
方法原型 `V computeIfAbsent(K key, Function<? super <, ? extends V> mappingFunction)`, 与上一个方法相反，如果指定的 key 不存在或相关的 value 为 null 时，设置 key 与关联一个计算出的非 null 值，计算出的值为 null 的话什么也不做 (不会去删除相应的key)。如果 key 存在并且对应 value 为 null 的话什么也不做。同样，方法的返回值也是最终的 map.get(key)。
示例及效果：
```java
String ret;
Map<String, String> map = new HashMap<>();
ret = map.computeIfAbsent("a", key -> key + "123"); //ret "a123", map 为 {"a":"a123"}
ret = map.computeIfAbsent("a", key -> key + "456"); //ret "a123", map 为 {"a":"a123"}
map.put("a", null);
ret = map.computeIfAbsent("a", key -> key + "456"); //ret "a456", map 为 {"a":"a456"}
ret = map.computeIfAbsent("a", key -> null); //ret 为 "a456", map 为 {"a":"a456"}
```
## replace(K key, V value) 方法
只要 key 存在，不管对应值是否为null，则用传入的 value 替代原来的值。即使传入的 value 是 null 也会用来替代原来的值，而不是删除，注意这对于 value 不能为null 值的Map实现将会造成 NullPointerException。key 不存在不会修改 Map 的内容，返回值总是原始的 map.get(key) 值。
示例及效果：
```java
String ret;
Map<String, String> map = new HashMap<>();
ret = map.replace("a", "abc"); //ret 为 null，map 为 {}
map.put("a", "ddd");
ret = map.replace("a", "abc"); //ret 为 "ddd", map 为 {"a":"abc"}
ret = map.replace("a", null); //ret 为 "abc", map 为 {"a":null}
ret = map.replace("a", "ddd"); //ret 为 null, map 为 {"a":"ddd"}
```
## replace(K key, V oldValue, V newValue)
当且仅当 key 存在，并且对应值与 oldValue 不相等，才用 newValue 作为 key 的新相关联值，返回值为是否进行了替换。
示例及效果：
```
boolean ret;
Map<String, String> map = new HashMap<>() ;
ret = map.replace("a", null, "aaa"); //ret 为 false, map 为 {}
map.put("a", null);
ret = map.replace("a", null, "aaa"); //ret 为 true, map 为 {"a":"aaa"}
ret = map.replace("a", "aaa", null); //ret 为 true, map 为 {"a":null}
ret = map.replace("a", "aaa", "bbb");//ret 为 false, map 为 {"a":null}
```
## replaceAll 方法
方法原型 `void replaceAll(BiFunction<? super K, ? super V, ? extends V> function)`。它更像一个传统函数型语言的 map 函数，即对于 Map 中的每一个元素应用函数 function, 输入为 key 和value。
示例及效果：
```java
Map<String, String> map = new HashMap<>() ;
map.put("a", "aaa");
map.put("b", "bbb"); //map 为 {"a":"aaa","b":"bbb"}
map.replaceAll((key, value) -> key + "-" + value); //map 为 {"a":"a-aaa","b":"b-bbb"}
```
## remove(key, value)
这个也不用多说，key 与 value 都匹配时才删除。
参考实现：
```java
if (map.containsKey(key) && Objects.equals(map.get(key), value)) {
map.remove(key);
return true;
} else
return false;
```
## compute 方法
方法原型` V compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction)`, 它是 computeIfAbsent 与 computeIfPresent的结合体。也就是既不管 key 存不存在，也不管 key 对应的值是否为 null, compute 死活都要设置与 key 相关联的值，或者计算出的值为 null 时删除相应的 key, 返回值为最终的 map.get(key)。
示例及效果：
```java
String ret;
Map<String, String> map = new HashMap<>() ;
ret = map.compute("a", (key, value) -> "a" + value); //ret="anull", map={"a":"anull"}
ret = map.compute("a", (key, value) -> "a" + value); //ret="aanull", map={"a":"aanull"}
ret = map.compute("a", (key, value) -> null); //ret=null, map={}
```
## merge 方法
方法原型` V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFucntion)` 如果指定的 key 不存在，或相应的值为 null 时，则设置value 为相关联的值。否则根据 key 对应的旧值和 value 计算出新的值 newValue，newValue 为 null 时，删除该 key, 否则设置 key 对应的值为newValue。方法的返回值也是最终的map.get(key) 值。
注意 value 不能为 null 值
示例及效果：
```java
String ret;
Map<String, String> map = new HashMap<>() ;
//ret="aa", map={"a":"aa"}
ret = map.merge("a", "aa", (oldValue, value) -> oldValue + "-" + value);
//ret="aa-bb", map={"a":"aa-bb"}
ret = map.merge("a", "bb", (oldValue, value) -> oldValue + "-" + value);
//ret=null, map={}
map.put("a", null);
ret = map.merge("a", "bb", (oldValue, value) -> null);
//ret="aa", map={"a":"aa"}
ret = map.merge("a", "aa", (oldValue, value) -> oldValue + "-" + value);
map.put("a", null);
//ret="bb", map={"a":"bb"}
ret = map.merge("a", "bb", (oldValue, value) -> null);
//NullPointerException, value 不能为 null
ret = map.merge("a", null, (oldValue, value) -> oldValue + "-" + value);
```
Map.Entry comparingByKey 和comparingByValue 方法
另外介绍一下 Map.Entry 新加的两个排序方法，它们分别有无参与带 Comparator 参数可嵌套使用的两个版本。`comparingByKey(), comparingByKey(Comparator<? super K> cmp), comparingByValue()` 和 `comparingByValue(Comparator<? super V> cmp)`。
示例代码如下：
```java
// comparingByKey 和comparingByValue
map.entrySet().stream().sorted(Map.Entry.comparingByKey()).collect(Collectors.toList());
map.entrySet().stream().sorted(Map.Entry.comparingByKey(String::compareTo)).collect(Collectors.toList());
map.entrySet().stream().sorted(Map.Entry.comparingByValue()).collect(Collectors.toList());
map.entrySet().stream().sorted(Map.Entry.comparingByValue(String::compareTo)).collect(Collectors.toList());
``` 感谢分享，先收藏了
页:
[1]