得益于 Java 8 的 default 方法特性,Java 8 对 Map 增加了不少实用的默认方法,像 getOrDefault
, forEach
, replace
, replaceAll
, putIfAbsent
, remove(key, value)
, computeIfPresent
, computeIfAbsent
, compute
和merge
方法。另外与 Map 相关的 Map.Entry
也新加了多个版本的 comparingByKey
和 comparingByValue
方法。
为达到熟练运用上述除 getOrDefault
和 forEach
外的其他方法,有必要逐一体验一番,如何调用,返回值以及调用后的效果如何。看看每个方法不至于 Java 8 那么多年还总是 if(map.containsKey(key))...
那样的老套操作。
前注:Map 新增方法对 present 的判断是 map.containsKey(key) && map.get(key) != null,简单就是 map.get(key) != null,也就是即使 key 存在,但对应的值为 null 的话也视为 absent。absent 就是 map.get(key) == null。
不同 Map 实现对 key/value 是否能为 null 有不同的约束, HashMap, LinkedHashMap, key 和 value 都可以为 null 值,TreeMap 的 key 为不能为 null, 但 value 可以为 null, 而 Hashtable, ConcurrentMap 则 key 和 value 都不同为 null。一句话 absent/present 的判断是 map.get(key) 是否为 null。
方法介绍的顺序是它们相对于本人的生疏程度而定的。每个方法介绍主要分两部分,参考实现代码与示例代码执行效果。参考实现代码摘自 JDK 官方的 Map JavaDoc。
getOrDefault 方法
本想忽略这个方法的测试,因为涉及到 key 存在,值为 null 的情况。当 key 不存在或相关联的值为 null 时,返回默认值,否则返回实际值。不要认为 key 存在时总是返回 map.get(key) 的值。
参考实现:
1 2 |
V v = get(key); return v != null ? v : defaultValue; |
示例及效果:
1 2 3 4 5 6 |
String ret; Map<String, String> map = new HashMap<>(); ret = map.getOrDefault("a", "1111"); //ret 为 "1111" map.put("a", null); System.out.println(map.containsKey("a")); //true ret = map.getOrDefault("a", "2222"); //ret 为 "2222" |
putIfAbsent 方法
方法原型 V putIfAbsent(K key, V value)
, 如果 key 不存在或相关联的值为 null, 则设置新的 key/value 值。
参考实现:
1 2 3 4 5 |
V v = get(key); if (v == null) { v = put(key, value); } return v; |
如果原 map 中对应 key 的值为 null(或不存在) 则返回 null
值,或者返回新的 value 值
如果想要没有 key 对应的值(或为 null) 时,加入新值后马上返回新的值的话就该用后面的 computeIfAbsent
方法
1 2 |
String ret = map.computeIfAbsent("key", key -> "abc"); // map 为空时执行上面语句后 ret 的值为刚加入的 "abc" |
示例及效果:
1 2 3 4 5 6 7 |
String ret; Map<String, String> map = new HashMap<>(); ret = map.putIfAbsent("a", "aaa"); //ret 为 null, map 为 {"a":"aaa"} ret = map.putIfAbsent("a", "bbb"); //ret 为 "aaa", map 还是 {"a":"aaa"} map.put("b", null); ret = map.putIfAbsent("b", "bbb"); //ret 为 null, 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)。
参考实现:
1 2 3 4 5 6 7 8 |
if (map.get(key) != null) { V oldValue = map.get(key); V newValue = remappingFunction.apply(key, oldValue); if (newValue != null) map.put(key, newValue); else map.remove(key); } |
示例及效果:
1 2 3 4 5 6 7 8 |
String ret; Map<String, String> map = new HashMap<>(); ret = map.computeIfPresent("a", (key, value) -> key + value); //ret null, map 为 {} map.put("a", null); //map 为 ["a":null] ret = map.computeIfPresent("a", (key, value) -> key + value); //ret null, map 为 {"a":null} map.put("a", "+aaa"); ret = map.computeIfPresent("a", (key, value) -> key + value); //ret "a+aaa", map 为 {"a":"a+aaa"} ret = map.computeIfPresent("a", (key, value) -> null); //ret 为 null, map 为 {},计算出的 null 把 key 删除了 |
计算出的值为 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)。
参考实现:
1 2 3 4 5 |
if (map.get(key) == null) { V newValue = mappingFunction.apply(key); if (newValue != null) map.put(key, newValue); } |
示例及效果:
1 2 3 4 5 6 7 |
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) 值。
参考实现:
1 2 3 4 |
if (map.containsKey(key)) { return map.put(key, value); } else return null; |
示例及效果:
1 2 3 4 5 6 7 |
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 的新相关联值,返回值为是否进行了替换。
参考实现:
1 2 3 4 5 |
if (map.containsKey(key) && Objects.equals(map.get(key), value)) { map.put(key, newValue); return true; } else return false; |
示例及效果:
1 2 3 4 5 6 7 |
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。
参考实现:
1 2 |
for (Map.Entry<K, V> entry : map.entrySet()) entry.setValue(function.apply(entry.getKey(), entry.getValue())); |
示例及效果:
1 2 3 4 |
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 都匹配时才删除。
参考实现:
1 2 3 4 5 |
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)。
参考实现:
1 2 3 4 5 6 7 8 9 10 11 12 13 |
V oldValue = map.get(key); V newValue = remappingFunction.apply(key, oldValue); if (oldValue != null ) { if (newValue != null) map.put(key, newValue); else map.remove(key); } else { if (newValue != null) map.put(key, newValue); else return null; } |
示例及效果:
1 2 3 4 5 |
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) 值。
参考实现:
1 2 3 4 5 6 7 |
V oldValue = map.get(key); V newValue = (oldValue == null) ? value : remappingFunction.apply(oldValue, value); if (newValue == null) map.remove(key); else map.put(key, newValue); |
注意 value 不能为 null 值
示例及效果:
1 2 3 4 5 6 7 8 9 10 |
String ret; Map<String, String> map = new HashMap<>() ; ret = map.merge("a", "aa", (oldValue, value) -> oldValue + "-" + value); //ret="aa", map={"a":"aa"} ret = map.merge("a", "bb", (oldValue, value) -> oldValue + "-" + value); //ret="aa-bb", map={"a":"aa-bb"} ret = map.merge("a", "bb", (oldValue, value) -> null); //ret=null, map={} map.put("a", null); ret = map.merge("a", "aa", (oldValue, value) -> oldValue + "-" + value); //ret="aa", map={"a":"aa"} map.put("a", null); ret = map.merge("a", "bb", (oldValue, value) -> null); //ret="bb", map={"a":"bb"} ret = map.merge("a", null, (oldValue, value) -> oldValue + "-" + value); //NullPointerException, value 不能为 null |
Map.Entry comparingByKey 和 comparingByValue 方法
另外介绍一下 Map.Entry 新加的两个排序方法,它们分别有无参与带 Comparator 参数可嵌套使用的两个版本。comparingByKey()
, comparingByKey(Comparator<? super K> cmp)
, comparingByValue()
和 comparingByValue(Comparator<? super V> cmp)
。
示例代码如下:
1 2 3 4 |
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()); |
本文链接 https://yanbin.blog/java-8-map-new-added-methods/, 来自 隔叶黄莺 Yanbin Blog
[版权声明] 本文采用 署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0) 进行许可。
[…] 注:Map 新增方法对 present 的判断是 map.containsKey(key) && map.get(key) != null,简单就是 map.get(key) != null,也就是即使 key 存在,但对应的值为 null 的话也视为 absent。absent 就是 map.get(key) == null。 不同 Map 实现对 key/value 是否能为 null 有不同的约束, HashMap, LinkedHashMap, key 和 value 都可以为 null 值,TreeMap 的 key 为不能为 null, 但 value 可以为 null, 而 Hashtable, ConcurrentMap 则 key 和 value 都不同为 null。一句话 absent/present 的判断是 map.get(key) 是否为 null。 阅读全文 >> […]