java8Map 中新增的⽅法介绍
相信⼤家都有看到，在 java8 后，⼤量的⽅法都包含两个单词，ifAbsent 和 ifPresent。
absent 表⽰缺席，理解为当前不存在 即 ifAbsent 在map中主要意思就是 如果 get(key) == null 执⾏present 表⽰当下，理解为当下有值， 即 ifPresent 在map中主要的意思就是 如果 get(key) != null 执⾏这⾥介绍常⽤的⼀些⽅法：
putIfAbsent(K key, V value) 如果传⼊key对应的value已经存在，就返回存在的value，不进⾏替换。如果不存在或为 get(key)为null，就添加key和value，返回null（简单讲就是返回前⼀个值）computeIfPresent(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction)
如果传⼊的 key 不存在或 get(key)为空，则返回空，不处理。
如果 get(key) 不为空则执⾏ BiFunction.apply(key,oldValue),
如果执⾏结果为 null 则删除 key，执⾏结果不为null 则返回执⾏结果 /** * putIfAbsent(K key, V value) 如果传⼊key 对应的value 已经存在，就返回存在的value ，不进⾏替换。 * 如果不存在或为 get(key)为null ，就添加key 和value ，返回null （简单讲就是返回前⼀个值） */ public static void testPutIfAbsent (){ String ret ; Map <String , String > map = new HashMap <>(); ret
= map .putIfAbsent ("a", "aaa");// null {a=aaa} System .out .println (ret + " " + map ); ret = map .putIfAbsent ("a", "bbb");// aaa {a=aaa} System .out .println (ret + " " + map ); map .put ("b", null ); ret = map .putIfAbsent ("b", "bbb");// null {a=aaa, b=bbb} System .out .println (ret + " " + map ); }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction)
如果传⼊的 key 值不存在，或 get(key) 为 null, 则执⾏ Function 结果并设置为新值
如果传⼊的 key 值存在，且 get(key)不为 null, 则忽略函数，直接返回当前值
/** * computeIfPresent(K key, * BiFunction<? super K, ? super V, ? extends V> remappingFunction) * 如果传⼊的 key 不存在或 get(key)为空，则返回空，不处理； * 如果 get(key) 不为空则执⾏ BiFunction.apply(key,oldValue), 如果执⾏结果为 null 则删除 key ， * 执⾏结果不为null 则返回执⾏结果 */ public static void testComputeIfPresent (){ String ret ; Map <String , String > map = new HashMap <>(); ret = map puteIfPresent ("a", (key , value ) -> key + value );// null {} System .out .println (ret + " " + map ); map .put ("a", null ); ret = map puteIfPresent ("a", (key , value ) -> key + value );// null {a=null} System .out .println (ret + " " + map ); map .put ("a", "+aaa"); ret = map puteIfPresent ("a", (key , value ) -> key + value );// a+aaa {a=a+aaa} System .out .println (ret + " " + map ); ret =
map puteIfPresent ("a", (key , value ) -> null );// null {} System .out .println (ret + " " + map ); }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28 /** * computeIfAbsent(K key, * Function<? super K, ? extends V> mappingFunction) * 如果传⼊的 key 值不存在，或 get(key) 为 null, 则执⾏ Function 结果并设置为新值 * 如果传⼊的 key 值存在，且 get(key)不为 null, 则忽略函数，直接返回当前值 * */ public static void testComputeIfAbsent (){ String ret ; Map <String , String > map = new HashMap <>(); ret = map puteIfAbsent ("a", key -> key + "123");// a123 {a=a123} System .out .println (ret + " " + map ); ret = map puteIfAbsent ("a", key -> key + "456");// a123 {a=a123} System .out .println (ret + " " + map ); map .put ("a", null ); ret = map puteIfAbsent ("a", key -> key + "456");// a123 {a=a123} System .out .println (ret + " " + map ); ret = map .c
omputeIfAbsent ("a", key -> null );// a123 {a=a123} System .out .println (ret + " " + map ); }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
replace(K key, V value)
如果传⼊的 key 存在（⽆论 get(key) 是否为null），则 替换值，返回 旧值如果不存在 key ，则 不处理
boolean replace(K key, V oldValue, V newValue)
如果传⼊的 key 不存在，则返回 false,
如果传⼊的 key 存在，且指定的 oldValue = get(key) 采⽤ newValue 替代旧值，返回 ture 如果传⼊的 key 存在，但指定的 oldValue != get(key) 则不处理，返回 false
replaceAll(BiFunction<? super K, ? super V, ? extends V> function)
对 Map 中的每⼀个元素应⽤函数 Bifunction, 新值为 Bifunction.apply(k,v) 的返回值/** * replace(K key, V value) * 如果传⼊的 key 存在（⽆论 get(key) 是否为null ），则 替换值，返回 旧值 * 如果不存在 key ，则 不处理 */ public static void testReplace (){ String ret ; Map <String , String > map = new HashMap <>(); ret = map .replace ("a", "abc");// null {} System .out .println (ret + " " + map ); map .put ("a", "ddd"); ret = map .replace ("a", "abc");// ddd {a=abc} System .out .println (ret + " " + map ); ret = map .replace ("a", null );// abc {a=null} System .out .println (ret + " " + map ); }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 /** * boolean replace(K key, V oldValue, V newValue) * 如果传⼊的 key 不存在，则返回 false, * 如果传⼊的 key 存在，且指定的 oldValue = get(key) 采⽤ newValue 替代旧值，返回 ture * 如果传⼊的 key 存在，但指定的 oldValue != get(key) 则不处理，返回 false */ public static void testReplace2(){ boolean ret ; Map <String , String > map = new HashMap <>() ; ret = map .replace ("a", null , "aaa");// false {} System .out .println (ret + " " + map ); map .put ("a", null ); ret = map .replace ("a", null , "aaa");// true {a=aaa} System .out .println (ret + " " + map ); ret = map .replace ("a", "aaa", null );// true {a=null} System .out .println (ret + " " + map ); ret = map .replace ("a", "aaa", "bbb");// false {a=null} System .out .println (ret + " " + map ); }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
V compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction)
⽆论 key 是否存在，get(key) 是否为null, 都执⾏ BiFunciton , 但 key 不存在时，默认 get(key) 为 null;BiFunction 执⾏结果作为 key 的新值，但 BiFunction 返回 null时， 则是删除该 key , 返回null，其他情况就返回结果为新值
compute ⽅法是 testComputeIfAbsent 和 testComputeIfPresent 的结合体
java replace方法⽆论 key 是否为空都执⾏，结果集为 null 则删除key merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction)
如果指定的 key 不存在，或 get(key) 为 null 时，则将 value 作为新值
如果get(key) 不为null 则执⾏ BiFunction.apply(oldValue,value) 作为新值，
如果新值为 null, 则删除该 key.返回 null,
如果新值不为 null, 则返回
/** * replaceAll(BiFunction<? super K, ? super V, ? extends V> function) * 对 Map 中的每⼀个元素应⽤函数 Bifunction, 新值为 Bifunction.apply(k,v) 的返回值 */ public static void testReplaceAll (){ Map <String , String > map = new HashMap <>() ; map .put ("a", "aaa"); map .put ("b", "bbb"); map .put ("c", null );// {a=aaa, b=bbb, c=null} System .out .println (map ); map .replaceAll ((key , value ) -> key + "-" + value );// {a=a-aaa, b=b-bbb, c=c-null} System .out .println (map ); }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15/** * V compute(K key, * BiFunction<? super K, ? super V, ? extends V> remappingFunc
tion) * ⽆论 key 是否存在，get(key) 是否为null, 都执⾏ BiFunciton , 但 key 不存在时，默认 get(key) 为 null * BiFunction 执⾏结果作为 key 的新值，但 BiFunction 返回 null 时， 则是删除该 key * 返回结果为新的值 * * compute ⽅法是 testComputeIfAbsent 和 testComputeIfPresent 的结合体, * ⽆论 key 是否为空都执⾏，结果集为 null 则删除key */ public static void testCompute (){ String ret ; Map <String , String > map = new HashMap <>() ; ret = map pute ("a", (key , value ) -> "a" + value );// anull {a=anull} System .out .println (ret + " " + map ); ret = map pute ("a", (key , value ) -> "a" + value );// aanull {a=aanull} System .out .println (ret + " " + map ); ret = map pute ("a", (key , value ) -> null );// null {} System .out .println (ret + " " + map ); }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/** * merge(K key, V value, * BiFunction<? super V, ? super V, ? extends V> remappingFunction) * 如果指定的 key 不存在，或 get(key) 为 null 时，则将 value 作为新值 * 如果get(key) 不为null 则执⾏ BiFunction.apply(oldValue,value) 作为新值， * 如果新值为 null, 则删除该 key.返回 null, * 如果新值不为 null, 则返回 */ public static void testMerge (){ String ret ; Map <String , String > map = new HashMap <>() ; ret = map .merge ("a", "aa", (oldValue , value ) -> oldValue + "-" + value );// aa {a=aa} System .out .println (ret + " " + map ); ret = map .merge ("a", "bb", (oldValue , value ) -> oldValue + "-" + value ); System .out .println (ret + " " + map ); ret = map .merge ("a", "bb", (oldValue , value ) -> null ); Syste
m .out .println (ret + " " + map ); map .put ("a", null ); ret = map .merge ("a", "aa", (oldValue , value ) -> oldValue + "-" + value ); System .out .println (ret + " " + map ); map .put ("a", null ); ret = map .merge ("a", "bb", (oldValue , value ) -> null ); System .out .println (ret + " " + map ); ret = map .merge ("a", null , (oldValue , value ) -> oldValue + "-" + value ); System .out .println (ret + " " + map ); }12345678910111213141516171819202122232425262728293031
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论