map新增的方法：
- getOrDefault
- forEach
- putIfAbsent
- compute
- computeIfAbsent
- computeIfPresent
- merge
- remove(key,value)
- replace
- replaceAll
getOrDefault
default V getOrDefault(Object key, V defaultValue) {
V v;
return (((v = get(key)) != null) || containsKey(key))
? v
: defaultValue;
}
如果Map中不存在该key，可以提供一个默认值，方法会返回改默认值。如果存在该key，返回键对应的值。
java8之前的写法：
Map<String, String> map = new HashMap<>();
String value = "D";
if(map.containsKey("d")) {
value = map.get("d");
}
java8：
String value = map.getOrDefault("d", "D");
forEach
default void forEach(BiConsumer<? super K, ? super V> action) {
Objects.requireNonNull(action);
for (Map.Entry<K, V> entry : entrySet()) {
K k;
V v;
try {
k = entry.getKey();
v = entry.getValue();
} catch(IllegalStateException ise) {
// this usually means the entry is no longer in the map.
throw new ConcurrentModificationException(ise);
}
action.accept(k, v);
}
}
forEach遍历map，对map中的每个映射执行action指定的操作。
比如：
Map<String, String> map = new HashMap<>();
map.put("a", "A");
map.put("b", "B");
// 遍历
map.forEach((k, v)-> {
System.out.println(k + "=" + v);
map.put(k, k + v);
});
// 输出
// a=A
// b=B
map.forEach((k, v)-> {
System.out.println(k + "=" + v);
});
// 输出
// a=aA
// b=bB
putIfAbsent
default V putIfAbsent(K key, V value) {
V v = get(key);
if (v == null) {
v = put(key, value);
}
return v;
}
V putIfAbsent(K key, V value)只有在不存在key值的映射或者映射值为null，才将value值赋值给key。否则不做修改。该方法将条件判断和赋值合二为一。
比如：
Map<String, String> map = new HashMap<>();
map.put("a", "A");
map.put("b", "B");
String e = map.putIfAbsent("e", "E");
String b = map.putIfAbsent("b", "E");
System.out.println("返回e="+e); //返回e=null
System.out.println("键e="+map.get("e"));//键e=E
System.out.println("返回b="+b);//返回b=B
System.out.println("键b="+map.get("b"));//键b=B
remove(key,value)
default boolean remove(Object key, Object value) {
Object curValue = get(key);
if (!Objects.equals(curValue, value) ||
(curValue == null && !containsKey(key))) {
return false;
}
remove(key);
return true;
}
只有在当前Map中key映射的值等于value时才删除该映射，否则什么也不做。
Map<String, String> map = new HashMap<>();
map.put("a", "A");
map.put("b", "B");
map.remove("a", "B");
map.remove("b", "B");
System.out.println(map.get("a")); // A
System.out.println(map.get("b")); // null
replace(K key, V value)
default V replace(K key, V value) {
V curValue;
if (((curValue = get(key)) != null) || containsKey(key)) {
curValue = put(key, value);
}
return curValue;
}
只有在当前Map中包含key,才用value去替换原来的值，否则什么也不做。
Map<String, String> map = new HashMap<>();
map.put("a", "A");
map.put("b", "B");
map.replace("c", "1");
map.replace("b", "1");
System.out.println(map.get("c")); // null
System.out.println(map.get("b")); // 1
replace(K key, V oldValue, V newValue)
default boolean replace(K key, V oldValue, V newValue) {
Object curValue = get(key);
if (!Objects.equals(curValue, oldValue) ||
(curValue == null && !containsKey(key))) {
return false;
}
put(key, newValue);
return true;
}
只有在当前Map中key的映射存在且映射的值等于oldValue时才用newValue去替换原来的值，否则什么也不做。
Map<String, String> map = new HashMap<>();
map.put("a", "A");
map.put("b", "B");
map.replace("a", "1", "2");
map.replace("b", "B", "2");
System.out.println(map.get("a")); // A
System.out.println(map.get("b")); // 2
replaceAll
default void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
Objects.requireNonNull(function);
for (Map.Entry<K, V> entry : entrySet()) {
K k;
V v;
try {
k = entry.getKey();
v = entry.getValue();
} catch(IllegalStateException ise) {
// this usually means the entry is no longer in the map.
throw new ConcurrentModificationException(ise);
}
// ise thrown from function is not a cme.
v = function.apply(k, v);
try {
entry.setValue(v);
} catch(IllegalStateException ise) {
// this usually means the entry is no longer in the map.
throw new ConcurrentModificationException(ise);
}
}
}
该方法签名为replaceAll(BiFunction<? super K,? super V,? extends V> function)，作用是对Map中的每个映射执行function指定的操作，并用function的执行结果替换原来的value
比如：
Map<String, String> map = new HashMap<>();
map.put("a", "A");
map.put("b", "B");
map.replaceAll((k, v) -> v.toLowerCase());
map.forEach((k, v)-> {
System.out.println(k + "=" + v);
});
// a=a
// b=b
merge
default V merge(K key, V value,
BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
Objects.requireNonNull(remappingFunction);
Objects.requireNonNull(value);
V oldValue = get(key);
V newValue = (oldValue == null) ? value :
remappingFunction.apply(oldValue, value);
if(newValue == null) {
remove(key);
} else {
put(key, newValue);
}
return newValue;
}
value和remappingFunction不能为null
如果Map中key对应的映射不存在或者为null，则将value关联到key上；否则执行remappingFunction，如果执行结果为null则删除key的映射，否则用该结果跟key关联。
比如：
Map<String, String> map = new HashMap<>();
map.put("e", "E");
map.merge("f", "F", String::concat);
map.merge("e", "F", String::concat);
System.out.println("map.get(\"f\")="+map.get("f")); // map.get("f")=F
System.out.println("map.get(\"e\")="+map.get("e")); // map.get("e")=EF
compute
default V compute(K key,
BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
Objects.requireNonNull(remappingFunction);
// 获取key对应的值
V oldValue = get(key);
//获取新值
V newValue = remappingFunction.apply(key, oldValue);
// 如果新值为null，并且key存在，则删除key；否则把新值赋值给key
if (newValue == null) {
// delete mapping
if (oldValue != null || containsKey(key)) {
// something to remove
remove(key);
return null;
} else {
// nothing to do. Leave things as they were.
return null;
}
} else {
// add or replace old mapping
put(key, newValue);
return newValue;
}
}
比如：
Map<String, String> map = new HashMap<>();
map.put("b", "B");
String val = map.compute("b", (k, v) -> null);
String val2 = map.compute("c", (k, v) -> v + "+v");
System.out.println(val); // null
System.out.println(val2); // null+v
computeIfAbsent
default V computeIfAbsent(K key,
Function<? super K, ? extends V> mappingFunction) {
Objects.requireNonNull(mappingFunction);
V v;
if ((v = get(key)) == null) {
V newValue;
if ((newValue = mappingFunction.apply(key)) != null) {
put(key, newValue);
return newValue;
}
}
return v;
}
当Map中不存在key值的映射或映射值为null时，调用mappingFunction，并在mappingFunction执行结果非null时，将结果赋值给key。
比如(输入每个字母的位置)：
List<String> list = Lists.newArrayList("a", "b", "b", "c", "c", "c", "d", "d", "d", "f", "f", "g");
Map<String, List<Integer>> positionsMap = new HashMap<>();
for (int i = 0; i < list.size(); i++) {
positionsMap.computeIfAbsent(list.get(i), k -> Lists.newArrayListWithCapacity(1)).add(i);
}
System.out.println(positionsMap);
// {a=[0], b=[1, 2], c=[3, 4, 5], d=[6, 7, 8], f=[9, 10], g=[11]}
