前言
得益于 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。
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 返回旧值,或者返回新的 value 值
示例及效果:
1
2
3
4
5
6
7
|
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)。
参考实现:
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/