廖雪峰Java5集合-3Map-1使用Map

廖雪峰的视频不全，以下是疯狂Java关于Map的讲解

1.Map定义

Map是一种键值映射表，可以通过key快速查找value，同python的dict。key不允许重复，value可以重复。

Map 集合里保存这两组值，一组值保存Map里的key，一组保存Map里的value，key和value都可以是任何引用类型的数据。



Map确实包含了一个keySet()方法，用于返回key组成的set集合。value类似于一个List，可以重复，通过key来查找。

常用方法：

• Object put(Object key, Object value)：添加一个key-value对，如果当前Map中已有一个与该key相等的key-value对，则新的key-value对会覆盖原来的key-value对。
• void clear()：删除该Map对象中的所有key-value对。

        Map map = new HashMap();
        map.put("杭州", "0571");
        map.put("湖州", "0572");
        map.put("嘉兴", "0573");
        map.put("宁波", "0574");
        System.out.println(map);
        map.clear();
        System.out.println(map);

* boolean containsKey(Object key)：查询Map中是否包含指定的key，如果包含返回true。
* boolean containsValue(Object value)：查询Map是否包含一个或多个value，如果包含则返回true。
```#java
Map map = new HashMap();
map.put("杭州", "0571");
map.put("湖州", "0572");
map.put("嘉兴", "0573");
map.put("宁波", "0574");
System.out.println("map.containsKey(\"宁波\"):"+map.containsKey("宁波"));
System.out.println("map.containsKey(\"厦门\"):"+map.containsKey("厦门"));
System.out.println("map.containsValue(\"0574\"):"+map.containsValue("0574"));
System.out.println("map.containsValue(\"0000\"):"+map.containsValue("0000"));
```

* Object get(Object key)：返回指定key所对应的value；如果Map中不包含这个key，返回null。
* boolean isEmpty()：查询该Map是否为空（即不包含任何key-value对），如果为空则返回true。
* void putAll(Map m)：将指定Map中的key-value对复制到本Map中。
* int size()：返回该Map里的key-value对的个数。
```#java
Map map = new HashMap();
Map map2 = new HashMap();
map.put("杭州", "0571");
map.put("湖州", "0572");
map.put("嘉兴", "0573");
map.put("宁波", "0574");
System.out.println(map.get("宁波"));
System.out.println(map.get("厦门"));
System.out.println(map.isEmpty());
System.out.println(map2.isEmpty());
map2.putAll(map);
System.out.println(map2.toString()+"\t"+map2.size());
```

* Object remove(Object key)：从Map中删除指定的key-value对，返回被删除key所关联的value，如果key不存在，返回null。
* boolean remove(Object key, Object value)：Java8新增，删除指定key、value所对应的key-value对。如果从该Map中删除该key-value对，返回true；否则，返回false。
```#java
Map map = new HashMap();
map.put("杭州", "0571");
map.put("湖州", "0572");
map.put("嘉兴", "0573");
map.put("宁波", "0574");
System.out.println(map.remove("宁波"));
System.out.println(map.remove("厦门"));
System.out.println(map.remove("湖州","0572"));
System.out.println(map.remove("嘉兴","1234"));
```

* Set keySet()：返回该Map中所有key组成的集合。
* Collection values()：返回该Map里所有value组成的Collection。
* Set entrySet()：返回Map中包含的key-value对所组成的Set集合，每个集合元素都是Map.Entry对象（Entry是Map的内部类）。
```#java
Map map = new HashMap();
map.put("杭州", "0571");
map.put("湖州", "0572");
map.put("嘉兴", "0573");
map.put("宁波", "0574");
/**
* 遍历Map：
* * 用for-each循环：
* * 循环key：keySet()
* * 循环key和value： entrySet()
*/
for(Object k:map.keySet()){
System.out.print(k+"=");
System.out.print(map.get(k)+"\t");
}
System.out.println();
System.out.println("value列表："+map.values());
for(Object m:map.entrySet()){
System.out.print(m+"\t");
}
```

Map中包含一个内部类Entry，该类封装了一个key-value对。Entry包含如下三个方法：
* Object getKey()：返回该Entry里包含的key值。
* Object getValue()：返回该Entry里包含的value值。
* Object setValue(V value)：设置该Entry里包含的value值，并返回新设置的value值。
```#java
Map map = new HashMap();
map.put("杭州", "0571");
map.put("湖州", "0572");
map.put("嘉兴", "0573");
map.put("宁波", "0574");
Iterator> it = map.entrySet().iterator();
while (it.hasNext()){
Map.Entry entry = it.next();
if (entry.getKey().equals("宁波")){
entry.setValue("010");
}
System.out.println("key="+entry.getKey()+"\t value="+entry.getValue());
}
```

## 2.Java8为Map新增的方法
Java8除了为Map增加了remove(Object key,Object value)默认方法，还增加了如下方法：
### 2.1.Object compute(Object key, BiFunction remappingFunction)
该方法使用remappingFunction根据原key-value对计算一个新value。
* 新value不为null：如果存在key，就用新value覆盖覆盖原value；如果key不存在，就添加一个新的键值对。
* 新value为null，原value不为null：原键值对存在，就删除原键值对；
* 原value，新value同时为null，原键值对存在，就删除该键值对。
```#java
Map map = new HashMap();
map.put("杭州", "0571");
map.put("湖州", "0572");
map.put("嘉兴", null);
map.put("宁波", "0574");
//key-宁波存在，覆盖
map.compute("宁波",(key,value) -> value+"hello world");
//key-广州不存在，添加
map.compute("广州",(key,value) -> "yangcheng");
System.out.println(map);
//删除key宁波
map.compute("宁波",(key,value) -> null);
System.out.println(map);
//删除key嘉兴
map.compute("嘉兴",(key,value)-> null);
System.out.println(map);
//key厦门不存在，不做操作
map.compute("厦门",(key,value) -> null);
System.out.println(map);
```

### 2.2.Object computeIfAbsent(Object key,Function mappingFunction)
* 如果key在map中不存在，就用mappingFunction根据key计算一个新的结果作为value，并添加该键值对。
* key在Map中存在，对应的value为null，则使用mappingFunction根据key计算一个新的结果作为value覆盖原有value。
* key在Map中存在，对应的value不为null，什么也不做。
```#hava
Map map = new HashMap();
map.put("杭州", "0571");
map.put("湖州", "0572");
map.put("嘉兴", null);
map.put("宁波", "0574");
System.out.println(map);
//不存下key厦门，就添加该键值对
map.computeIfAbsent("厦门",(key)->((String)key).length());
System.out.println(map);
//存在key杭州，且value不为null，不做任何操作
map.computeIfAbsent("杭州",(key)->null);
System.out.println(map);
//存在key嘉兴，且value为null
map.computeIfAbsent("嘉兴",(key)->((String)key).length());
System.out.println(map);
```

### 2.3.Object computeIfPresent(Object key, BiFunction remappingFunction)
* 如果传给该方法的key对应的value不为null，就用remappingFunction根据(key,value)计算一个新的结果：
* 如果计算结果不为null，就覆盖原有的value
* 如果计算结果为null，就删除该键值对
* 如果key在map中不存在或key对应的value为null，会报java.lang.NullPointerException
```#java
Map map = new HashMap();
map.put("杭州", "0571");
map.put("湖州", "0572");
map.put("嘉兴", null);
map.put("宁波", "0574");
System.out.println(map);
//删除原键值对
map.computeIfPresent("杭州",(key,value)->null);
System.out.println("删除杭州:"+map);
//覆盖原value
map.computeIfPresent("宁波",(key,value)->(String)key+(String)value).toString();
System.out.println("覆盖宁波："+map);
//key对应的value为null
try {
map.computeIfPresent("厦门", (key, value) -> (String) key + (String) value).toString();
}catch (java.lang.NullPointerException e){
System.out.println("不存在厦门:"+map);
}
//key不存在
try {
map.computeIfPresent("嘉兴", (key, value) -> (String) key + (String) value).toString();
}catch (java.lang.NullPointerException e){
System.out.println("不存在嘉兴:"+map);
}
```

### 2.4void forEach(BiConsumer action)
该方法是Java8为Map新增的一个遍历key-value对的方法
```#java
Map map = new HashMap();
map.put("杭州", "0571");
map.put("湖州", "0572");
map.put("嘉兴", null);
map.put("宁波", "0574");
map.forEach((key,value)-> System.out.println((String)key+(String)value));
```

### 2.5Object getOrDefault(Object key, V defaultValue)
获取指定key对应的value，如果key不存在，则返回defaultValue
```#java
map.put("杭州", "0571");
map.put("湖州", "0572");
map.put("嘉兴", null);
map.put("宁波", "0574");
System.out.println(map.getOrDefault("杭州","hello world"));
System.out.println(map.getOrDefault("广州","hello world"));
```
## 2.6Object merge(Object key, Object value, BiFunction remappingFunction)
注意：参数value不能null，否则会报java.lang.NullPointerException的错误
该方法中value和remappingFunction二选一使用，如果key对应的value为null或key不存在，使用value，否则使用remappingFunction
* key对应的value为null
* key存在，对应的value为null，将参数value覆盖原value
* 如果key不存在，新建key-value键值对
key存在，map对应的value不为为null，remappingFunction根据key、原value重新计算：
* 如果计算结果不为null，就用结算结果覆盖原value
* 如果计算结果为null，就删除原键值对
```#java
Map map = new HashMap();
map.put("杭州", "0571");
map.put("湖州", "0572");
map.put("嘉兴", null);
map.put("宁波", "0574");
//key存在，对应的value不为null，将计算结果覆盖新value
map.merge("杭州","1234",(key,value)->((String)(key)+(String)value).length());
System.out.println(map);
//key存在，对应的value不为null，新value为null，删除键值对
map.merge("湖州","1234",(key,value)->null);
System.out.println(map);
//key不存在，新建键值对
map.merge("厦门","1234",(key,value)->((String)(key)+(String)value).length());
System.out.println(map);
//key存在，对应的value为null，用1234覆盖原value
map.merge("嘉兴","1234",(key,value)->((String)(key)+(String)value).length());
System.out.println(map);
//value参数不能为null，否则会报异常
map.merge("厦门", null, (key, value) -> ((String) (key) + (String) value).length());
System.out.println(map);
```

### 2.7Object putIfAbsent(Object key, Object value)
该方法检测key对应的value是否为null
* 如果key不存在，就添加一个新的键值对
* 如果key对应的value为null，使用参数value覆盖null
* 如果key对应的value不为null，什么都不做
```#java
Map map = new HashMap();
map.put("杭州", "0571");
map.put("湖州", "0572");
map.put("嘉兴", null);
map.put("宁波", "0574");
System.out.println(map);
//key不存在
map.putIfAbsent("广州","021");
//key对应的value为null
map.putIfAbsent("嘉兴","1234");
System.out.println(map);
//key对应的value不为null
map.putIfAbsent("嘉兴","hello");
System.out.println(map);
```

### 2.8Object repalce(Object key,Object value)
将Map中指定的key对应的value替换为新value。如果key不存在，返回null，不会添加新的键值对。
```#java
Map map = new HashMap();
map.put("杭州", "0571");
map.put("湖州", "0572");
map.put("嘉兴", null);
map.put("宁波", "0574");
System.out.println(map);
map.replace("广州","1234");
map.replace("嘉兴","5678");
System.out.println(map);
```

### 2.9boolean replace(K key, V oldValue, V newValue)
如果在Map中找到指定的key-oldValue对，则替换为newValue并返回true，否则返回false.
newValue为null，不会报错，但执行结果为false，不会执行替换
```#java
Map map = new HashMap();
map.put("杭州", "0571");
map.put("湖州", "0572");
map.put("嘉兴", null);
map.put("宁波", "0574");
System.out.println(map.replace("杭州","0571","杭州0571"));
System.out.println(map.replace("湖州","0752",null));
System.out.println(map.replace("嘉兴",null,"嘉兴1234"));
System.out.println(map.replace("广州","010","羊城"));
```

### 2.10replaceAll(BiFunction function)
该方法使用BiFunction对原key-value对指定计算，并将结果作为该key-value对的value值。
```#java
Map map = new HashMap();
map.put("杭州", "0571");
map.put("湖州", "0572");
map.put("嘉兴", null);
map.put("宁波", "0574");
map.replaceAll((key,value)->((String)key+(String)value).toString());
System.out.println(map);
```