hashMap jdk1.8新增方法
阿新 • • 發佈：2020-11-17
hashMap jdk1.8新增方法
| 方法名稱 | 解釋 | 引數 |
|---|---|---|
| compute | 嘗試計算用於指定鍵和其當前對映的值的對映（或 null如果沒有當前對映）。 |
compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction) |
| computeIfAbsent | 如果指定的鍵尚未與值相關聯（或對映到 null ），則嘗試使用給定的對映函式計算其值，並將其輸入到此對映中，除非 null 。 |
computeIfAbsent(K key, Function<? super K,? extends |
| computeIfPresent | 如果指定的金鑰的值存在且非空，則嘗試計算給定金鑰及其當前對映值的新對映。 | computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction) |
| getOrDefault | 返回到指定鍵所對映的值，或 defaultValue如果此對映包含該鍵的對映 |
getOrDefault(Object key, V defaultValue) |
| merge | 如果指定的鍵尚未與值相關聯或與null相關聯，則將其與給定的非空值相關聯。 | merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction) |
| putIfAbsent | 如果指定的鍵尚未與某個值相關聯（或對映到 null ），則將其與給定值相關聯並返回 null ，否則返回當前值。 |
putIfAbsent(K key, V value) |
compute
compute根據value可以自行判斷是否更改當前value值
public static void main(String[] args) { Map<String,Integer> map = new HashMap<>(); Backpack a = new Backpack("大箱子",1); Backpack b = new Backpack("大箱子",12); Backpack c = new Backpack("小箱子",13); Backpack d = new Backpack("中箱子",14); Backpack e = new Backpack("中箱子",11); Backpack f = new Backpack("小箱子",12); List<Backpack> backpacks = Arrays.asList(a, b, c, d, e, f); //compute根據value可以自行判斷是否更改當前value值 //lambda寫法 backpacks.forEach(backpack->map.compute(backpack.getName(),(k,v)->v==null?backpack.getNum():v+backpack.getNum())); //普通寫法 for (int i = 0; i < backpacks.size(); i++) { Backpack backpack = backpacks.get(i); BiFunction<String, Integer, Integer> bif =new BiFunction<String, Integer, Integer>() { @Override public Integer apply(String key, Integer value) { if(value==null){ return backpack.getNum(); }else{ return value+backpack.getNum(); } } }; map.compute(backpack.getName(),bif); } System.out.println(map); } //輸出：{小箱子=25, 中箱子=25, 大箱子=13}
computeIfAbsent
computeIfAbsent根據key值進行判斷，如果有值將不進行修改，沒有值進行賦值
public static void main(String[] args) {
Map<String,Integer> map = new HashMap<>();
Backpack a = new Backpack("大箱子",1);
Backpack b = new Backpack("大箱子",12);
Backpack c = new Backpack("小箱子",13);
Backpack d = new Backpack("中箱子",14);
Backpack e = new Backpack("中箱子",11);
Backpack f = new Backpack("小箱子",12);
List<Backpack> backpacks = Arrays.asList(a, b, c, d, e, f);
//computeIfAbsent根據key值進行判斷，如果有值將不進行修改，沒有值進行賦值
//lambda寫法
backpacks.forEach(backpack->map.computeIfAbsent(backpack.getName(),v->backpack.getNum()));
//普通寫法
for (int i = 0; i <backpacks.size() ; i++) {
Backpack backpack = backpacks.get(i);
Function<String, Integer> function = new Function<String, Integer>() {
@Override
public Integer apply(String key) {
return backpack.getNum();
}
};
map.computeIfAbsent(backpack.getName(), function);
}
System.out.println(map);
}
//輸出：{小箱子=13, 中箱子=14, 大箱子=1}
computeIfPresent
computeIfPresent 根據key值進行判斷，如果沒有值不進行賦值，如果有值並且非null，將自行判斷是否更改當前值
public static void main(String[] args) {
Map<String,Integer> map = new HashMap<>();
Backpack a = new Backpack("大箱子",1);
Backpack b = new Backpack("大箱子",12);
Backpack c = new Backpack("小箱子",13);
Backpack d = new Backpack("中箱子",14);
Backpack e = new Backpack("中箱子",11);
Backpack f = new Backpack("小箱子",12);
List<Backpack> backpacks = Arrays.asList(a, b, c, d, e, f);
//computeIfPresent 根據key值進行判斷，如果沒有值不進行賦值，如果有值並且非null，將自行判斷是否更改當前值
//lambda寫法
backpacks.forEach(backpack->map.computeIfPresent(backpack.getName(),(k,v)->v==null?backpack.getNum():v+backpack.getNum()));
//普通寫法
for (int i = 0; i < backpacks.size(); i++) {
Backpack backpack = backpacks.get(i);
BiFunction<String, Integer, Integer> bif =new BiFunction<String, Integer, Integer>() {
@Override
public Integer apply(String key, Integer value) {
if(value==null){
return backpack.getNum();
}else{
return value+backpack.getNum();
}
}
};
map.computeIfPresent(backpack.getName(),bif);
}
System.out.println(map);
}
//輸出：{}
getOrDefault
getOrDefault獲取指定key，如果不存在，返回指定預設value
public static void main(String[] args) {
Map<String,Integer> map = new HashMap<>();
//map.put("超級大箱子", 2);
//getOrDefault獲取指定key，如果不存在，返回指定預設value
Integer num = map.getOrDefault("超級大箱子", 34);
map.put("超級大箱子", num);
System.out.println(map);
}
//key存在時輸出：{超級大箱子=2}
//key不存在時輸出：{超級大箱子=34}
merge
merge 根據key進行判斷，如果存在將不進行操作，如果不存在,可以自行判斷新舊值處理
public static void main(String[] args) {
Map<String,Integer> map = new HashMap<>();
Integer num = map.getOrDefault("超級大箱子", 34);
map.put("超級大箱子", num);
//merge 根據key進行判斷，如果存在將不進行操作，如果不存在,可以自行判斷新舊值處理
//lambda寫法
map.merge("超級大箱子",3,(oldValue,newValue) -> oldValue+newValue);
//普通寫法
BiFunction<Integer, Integer, Integer> biFunction =new BiFunction<Integer, Integer, Integer>() {
@Override
public Integer apply(Integer integer, Integer integer2) {
System.out.println(integer);
System.out.println(integer2);
return integer + integer2;
}
};
map.merge("超級大箱子", 3, biFunction);
System.out.println(map);
}
//key不存在時輸出：{超級大箱子=3}
//key存在時輸出：{超級大箱子=37}
putIfAbsent
putIfAbsent 根據當前key進行判斷，如果存在不進行更改，如果不存在將進行賦值
public static void main(String[] args) {
Map<String,Integer> map = new HashMap<>();
//map.put("小盒子",122);
//putIfAbsent 根據當前key進行判斷，如果存在不進行更改，如果不存在將進行賦值
map.putIfAbsent("小盒子",12);
System.out.println(map);
}
//key存在時輸出：{小盒子=122}
//key不存在時輸出：
class Backpack{
private String name;//名稱
private int num;//數量
public Backpack(String name,int num){
this.name=name;
this.num=num;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
}