方法列表

• default V putIfAbsent(K key, V value)
  如果指定的 key 存在，若 key 的值不为 null，该方法不做任何操作，若 key 的值为 null，将指定的 value 关联给 key 并保存到当前集合；若指定的 key 不存在， 将指定的 value 关联给 key 并保存到当前集合
• default V getOrDefault(Object key, V defaultValue)
  如果指定的 key 存在（不管值是否为 null），该方法不做任何操作；若 key 不存在，将指定的 value 关联给 key 并保存到当前集合
• default V compute(K key, BiFunction<!--? super K-->, ? super V, ? extends V remappingFunction)
  将 remappingFunction 的计算结果的 value 关联到指定的 key；若指定的 key 不存在于当前集合，会在当前集合中创建 key 以及 key 对应的 value
• default computeIfAbsent(K key, Function<!--? super K, ? extends V--> mappingFunction)
  当 key 为 null 或 key 所对应的 value 为 null 时，执行该方法，将 mappingFunction 的计算结果的 value 关联到指定的 key；若指定的 key不存在于当前集合，会在当前集合中创建 key 以及 key 所对应的 value
• default computeIfPersent(K key, BiFunction<!--? super K, ? super V, ? extends V--> remappingFunction)
  当 key 不为 null 并且 key 所对应的 value 不为 null 时，执行该方法，将 remappingFunction 的计算结果的 value 关联到指定的 key；若指定的 key 不存在于当前集合，不会创建 key
• default V merge(K key, V value, BiFunction<!--? super V, ? super v, ? extends V--> remappingFunction)
  如果指定的 key 不存在或 key 的值为 null，将指定的 value 设置为 key 的值；否则根据 key 的旧的值 oldValue，value 计算出新的值 newValue，如果 newValue 为 null，则删除该 key，否则设置 key 的值为 newValue
  -default boolean remove(Object key, Object value)
  如果 key 的值与指定的值 value 相等（equals),则从当前集合中移除这个 key
• default V replace(K key, V value)
  若 key 存在，将 key 的旧值替换成指定的 value；若 key 不存在，不会将指定的 key，value 保存到当前集合
• default boolean replace(K key, V oldValue, V newValue)
  若 key 存在，key 关联的旧值与指定的 oldValue 相等，将 key 关联的旧值替换为指定的 newValue
• default void replaceAll(BiFunction<!--? super K, ? super V, ? extends V function)
  将 function 的返回值 用来替换当前集合中的所有 key 的值

方法示例

• default V putIfAbsent(K key, V value)

public class App
{public static void main( String[] args ){Map<String,Object--> hashMap = new HashMap&lt;&gt;();hashMap.put("name",null);hashMap.put("country","china");// putIfAbsent 方法将值为 null 的键 name 赋值为 mike，并返回键 name 的旧值 nullSystem.out.println("putIfAbsent('name', 'mike')的返回值：" + hashMap.putIfAbsent("name", "mike")); // putIfAbsent 方法不改变键为 country 的值，因为键 country 的值为 china（不为 null），并返回旧值 chinaSystem.out.println("putIfAbsent('country', 'japan')的返回值：" + hashMap.putIfAbsent("country", "japan")); hashMap.forEach((k,v) -&gt; System.out.println(k + ":" + v));   }
}
~~out:putIfAbsent('name', 'mike')的返回值：null
~~out:putIfAbsent('country', 'japan')的返回值：china
~~out:country:china
~~out:name:mike

• default V getOrDefault(Object key, Object value)

public class App
{public static void main( String[] args ){Map<string,object> hashMap = new HashMap&lt;&gt;();hashMap.put("name",null);// 若键 name 不存在， getOrDefault 将指定的值 tom 关联给键 name，并保存到 hashMap中；// 若键 name 存在（不管值是否为 null）；getOrDefault 将不做任何操作hashMap.getOrDefault("name", "tom");hashMap.forEach((k,v) -&gt; System.out.println(k + ":" + v));}
}
~~out:name:null

• default V compute(K key, BiFunction<!--? super K-->, ? super V, ? extends V) remappingFunction

public class App
{public static void main( String[] args ){Map<string,object> hashMap = new HashMap&lt;&gt;();hashMap.put("name","tom");// compute 方法将键 name 的值赋为 函数式接口 BiFunction 的实现类方法 apply 的返回结果；若 apply 的返回结果为 null ，键 name 将会被从 hashMap 中移除；若 hashMap 中没有键 name，compute 会将指定的 key 和它对应计算的 value 存入 hashMap中hashMap.compute("name", new BiFunction<string, object, object>() {@Overridepublic Object apply(String s, Object o) {return o;}});// lambda 写法hashMap.compute("name",(k,v) -&gt; "tom");hashMap.forEach((k,v) -&gt; System.out.println(k + ":" + v));}
}
~~out:name:tom

• default computeIfAbsent(K key, Function<!--? super K, ? extends V--> mappingFunction)

public class App
{public static void main( String[] args ){Map<string,object> hashMap = new HashMap&lt;&gt;();hashMap.put("name",null);// 键 name 的值为 null ，符合执行 computeIfAbsent 方法的执行条件，将 apply 方法返回的值 jerry 关联给指定的键 name；// 若键 name 的值不为 null；不符合执行 computeIfAbsent 方法的执行条件，因此 apply 方法的返回值不会影响键 name 对应的值 valuehashMap.computeIfAbsent("name", new Function<string, object>() {@Overridepublic Object apply(String s) {return "jerry";}});// lambda 写法//hashMap.computeIfAbsent("name", k -&gt; "jerry");hashMap.forEach((k,v) -&gt; System.out.println(k + ":" + v));}
}
~~out:name:jerry

• default computeIfPersent(K key, BiFunction<!--? super K, ? super V, ? extends V--> remappingFunction)

public class App
{public static void main( String[] args ){Map<string,object> hashMap = new HashMap&lt;&gt;();hashMap.put("name","tom");// 键 name 的值为 tom，符合 computeIfPresent 方法的执行条件，将 apply 方法的返回值 mike 关联给指定的键 name// 若键 name 不存在于 hashMap 中，apply 方法不会将 name-mike 存入当前 hashMap// 若键 name 对应的值为 null，不会将 apply 的返回值 mike 关联给键 namehashMap.computeIfPresent("name", new BiFunction<string, object,object>(){@Overridepublic Object apply(String s, Object o) {return "mike";}});// lambda 写法// hashMap.computeIfPresent("name", (k,v) -&gt; "mike");hashMap.forEach((k,v) -&gt; System.out.println(k + ":" + v));}
}
~~out:name:mike

• default V merge(K key, V value, BiFunction<!--? super V, ? super v, ? extends V--> remappingFunction)

public class App
{public static void main( String[] args ){Map<string,object> hashMap = new HashMap&lt;&gt;();hashMap.put("name","jerry");// 键 name 的值不为 null，将 name 的值关联为 apply 方法计算出的新值 jerry-&gt;tom;// 若键 name 不存在或者键 name 的值为 null，merge 方法指定的 value 关联给键 name，不执行 apply 方法；// 若 name 存在且 name 的值不为 null，而 apply 方法返回的值为 null ，那么 hashMap 中的键 name 将被移除hashMap.merge("name", "tom", new BiFunction<object,object, object>() {@Override// o 为旧值 jerry；o2 为给定的值 tompublic Object apply(Object o, Object o2) {return (String)o + "-&gt;" + o2;}});// lambda 写法// hashMap.merge("name", "tom", (oldValue, newValue) -&gt; oldValue + "-&gt;" + newValue);hashMap.forEach((k,v) -&gt; System.out.println(k + ":" + v));}
}
~~out:jerry-&gt;tom

• default boolean remove(Object key, Object value)

public class App
{public static void main( String[] args ){Map<string,object> hashMap = new HashMap&lt;&gt;();hashMap.put("name","jerry");hashMap.put("country", "china");// remove 方法中指定的键 name 的值 jerry 与当前 hashMap 中键 name 的值一致，因此键 name 从 hashMap 中被移除hashMap.remove("name","jerry");hashMap.forEach((k,v) -&gt; System.out.println(k + ":" + v));}
}
~~out:country:china

• default V replace(K key, V value)

public class App
{public static void main( String[] args ){Map<string,object> hashMap = new HashMap&lt;&gt;();hashMap.put("name",null);// 若键 name 存在(不管值是否为 null)，将键 name 的值 null 替换为 replace 方法指定的值 tom// 若键 name 不存在，不会将 replace 指定的键 name 和值 tom 保存到当前 hashMap 中hashMap.replace("name","tom");hashMap.forEach((k,v) -&gt; System.out.println(k + ":" + v));}
}
~~out:name:tom

• default boolean replace(K key, V oldValue, V newValue)

public class App
{public static void main( String[] args ){Map<string,object> hashMap = new HashMap&lt;&gt;();hashMap.put("name",null);// 若键 name 存在（不管键 name 的值是否为 null），若键 name 的旧值 null 与 replace 方法中指定的 oldValue 相等，将键 name 的旧值 null 替换为 replace 方法中指定的 newValuehashMap.replace("name",null,"jerry");hashMap.forEach((k,v) -&gt; System.out.println(k + ":" + v));}
}
~~out:name:jerry

• default void replaceAll(BiFunction<!--? super K, ? super V, ? extends V function)

public class App
{public static void main( String[] args ){Map<String,Object--> hashMap = new HashMap&lt;&gt;();hashMap.put("name",null);hashMap.put("sex","man");hashMap.put("country","china");// 用 apply 方法的返回值将键 name 的值替换为 name-&gt;null,将键 sex 的值替换为 sex-&gt;man,将键 country 的值替换为 country-&gt;chinahashMap.replaceAll(new BiFunction<string, object, object>() {@Override// s:旧的 key；o:旧的 valuepublic Object apply(String s, Object o) {return s + "-&gt;" + o;}});// lambda 写法// hashMap.replaceAll((k,v) -&gt; k + "-&gt;" + v);hashMap.forEach((k,v) -&gt; System.out.println(k + ":" + v));}
}
~~out:country:country-&gt;china
~~out:sex:sex-&gt;man
~~out:name:name-&gt;null
```</string,></string,object></string,object></string,object></object,object,></string,object></string,></string,object></string,></string,object></string,></string,object></string,object>