Java--Map集合

现实生活中，我们经常会看到这样的一种集合：IP地址与主机名，省份证号与个人，系统用户名与用户对象等，这种——对应的关系，就叫做映射。Java提供了专门的集合类用来存放这种对象关系的对象，即java.util.Map接口。
Collection与Map:

• Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。
• Map中的集合、元素是成对存在的（理解为夫妻）。每个元素由键与值两部分组成，通过键可以找到对应的值。
• Collection中的集合称为单列集合，Map中的集合称为双列集合。
• Notice：Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。

一、java.util.Map<k,v>集合

1. 特点

• Map集合是一个双列集合，一个元素包含两个值（一个key，一个value）。
• Map集合中的元素，key和value的数据类型可以相同，也可以不同。
• Map集合中的元素，key是不允许重复的，value是可以重复的。
• Map集合中的元素，key和value是一一对应的。

2. Map接口中的常用方法：
   （1）public V put(K key, V value):将指定的键与指定的值添加到Map集合中。
   返回值：V
   储存键值对的时候，key不重复，返回值V是null；
   储存键值对的时候，key重复，会使用新的value替换map中重复的value，返回被替换的值。

import java.util.HashMap;
import java.util.Map;

public class MapDemo {
    public static void main(String[] args) {
        show01();
    }
    public static void show01() {
        Map<String,String> map = new HashMap<>();
        String v1 = map.put("白凤九","小九");
        System.out.println("v1:" + v1);     //v1:null

        String v2 = map.put("白凤九","小白");
        System.out.println("v2:" + v2);     //v2:小九

        System.out.println(map);//{白凤九=小白}

        map.put("rb","白凤九");
        map.put("ym", "浅浅");
        map.put("bq","浅浅");
        System.out.println(map);//{rb=白凤九, 白凤九=小白, ym=浅浅, bq=浅浅}
    }
}

（2）public V remove(Object key)：把指定的键所对应的键值对元素在Map集合中删除，返回被删除元素的值。
返回值：V
key存在，v返回被删除的值；
key不存在，v返回null。

import java.util.HashMap;
import java.util.Map;

public class Demo02Map {
    public static void main(String[] args) {
    show01();
    }
    public static void show01() {
        Map<String, Integer> map = new HashMap<>();
        map.put("白凤九", 170);
        map.put("白小九", 165);
        map.put("阿兰若", 168);
        System.out.println(map);//{白凤九=170, 白小九=165, 阿兰若=168}

        Integer v1 = map.remove("白小九");
        System.out.println("v1:" + v1);//v1:165
        System.out.println(map);//{白凤九=170, 阿兰若=168}

        Integer v2 = map.remove("浅浅");
        //int v2 = map.remove("浅浅");//自动拆箱    NullPointerException
        System.out.println("v2:" + v2);//v2:null
        System.out.println(map);//{白凤九=170, 阿兰若=168}
    }
}

（3）public V get(Object key):根据指定的键，在Map集合中获取对应的值。
返回值 ：V
key存在，返回对应的value；
key不存在，返回null。

import java.util.HashMap;
import java.util.Map;

public class Demo03get {
    public static void main(String[] args) {
        show03();
    }
    public static void show03() {
        Map<String, Integer> map = new HashMap<>();
        map.put("白凤九", 170);
        map.put("白小九", 165);
        map.put("阿兰若", 168);

        Integer v1 = map.get("白小九");
        System.out.println("v1:" + v1);//v1:165

        Integer v2 = map.get("迪丽热巴");
        System.out.println("v2:" + v2);//v2:null
    }
}

（4）public boolean containsKey(Object key):判断集合中是否包含指定的键。
返回值 V：
key存在，返回对应的value值；
key不存在，返回null。

{
    public static void main(String[] args) {
        show01();
    }
    public static void show01() {
        Map<String, Integer> map = new HashMap<>();
        map.put("白凤九", 170);
        map.put("白小九", 165);
        map.put("阿兰若", 168);

        boolean b1 = map.containsKey("白小九");
        System.out.println("b1:" + b1);//b1:true

        boolean b2 = map.containsKey("浅浅");
        System.out.println("b2:" + b2);//b2:false

    }
}

3. 遍历Map集合
   第一种遍历方式：通过键找值的方式
   Map集合中的方法：
   Set keySet():返回此映射中包含的键的Set视图。
   实现步骤：
   （1）使用Map集合中的方法keySet()，把Map集合所有的key取出，存储到一个Set集合中；
   （2）遍历set集合，获取Map集合中的每一个key；
   （3）通过Map集合中的方法get(key)，通过key找到value。

public class Demo05KeySet {
    public static void main(String[] args) {
        show01();
    }
    public static void show01() {
        Map<String, Integer> map = new HashMap<>();
        map.put("白凤九", 170);
        map.put("白小九", 165);
        map.put("阿兰若", 168);

        Set<String> set = map.keySet();

        Iterator<String> it = set.iterator();
        while(it.hasNext()) {
            String key = it.next();
            Integer value = map.get(key);
            System.out.println(key + "=" + value);

            System.out.println("============");

           for(String key2 : set) {
               Integer value2 = map.get(key2);
               System.out.println(key2 + "=" + value2);
           }
        }
    }
}

第二种遍历方式：使用Entry对象遍历
Map集合中的方法：
Set<Map.Entry<K,V>> entrySet():返回此映射中包含的映射关系的Set视图。
实现步骤：
（1）使用Map集合中的方法entrySet(),把Map集合中多个Entry对象取出来，储存到一个Set集合中；
（2）遍历Set集合，获取每一个Entry对象；
（3）使用Entry对象中的方法getKey()和getValue()获取键与值。

public class Demo06EntrySet {
    public static void main(String[] args) {
        show01();
    }
    public static void show01() {
        Map<String, Integer> map = new HashMap<>();
        map.put("白凤九", 170);
        map.put("白小九", 165);
        map.put("阿兰若", 168);

        Set<Map.Entry<String, Integer>> set = map.entrySet();

        Iterator<Map.Entry<String, Integer>> it = set.iterator();
        while (it.hasNext()) {
            Map.Entry<String, Integer> entry = it.next();

            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + "=" +value);
        }

        System.out.println("=========");

        for(Map.Entry<String,Integer> entry: set) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + "=" +value);
        }
    }
}

HashMap存储自定义类型键值：
Map集合保证key是唯一的：
作为key的元素，必须重写hashCode方法和equals方法，以保证key唯一。

二、LinkedHashMap<k,v>集合

java.util.HashMap<k,v>集合 implements Map<k,v> 接口
特点：

• HashMap集合底层是哈希表：查询的速度特别快
  JDK1.8之前：数组+单向链表
  JDK1.8之后：数组+单向链表/红黑树（链表的长度超过8）：提高查询速度
• hashMap集合是一个无序的集合，存储元素和取出元素的顺序可能不一致

java.util.LinkedHashMap<k,v> 集合 extends HashMap<k,v>集合

• LinkedHashMap集合底层是哈希表+链表（保证迭代的顺序）
• LinkedHashMap集合是一个有序的集合，存储元素和取出元素的顺序是一致的。

import java.util.HashMap;
import java.util.LinkedHashMap;

public class Demo08LinkedHashMap {
    public static void main(String[] args) {
        HashMap<String,String> map = new HashMap<>();
        map.put("a","A");
        map.put("c","C");
        map.put("b","B");
        map.put("d","D");
        map.put("a","D");
        System.out.println(map);key不允许重复，无序（输入输出顺序不一致） //{a=D, b=B, c=C, d=D}

        LinkedHashMap<String,String> linked = new LinkedHashMap<>();
        linked.put("a","A");
        linked.put("c","C");
        linked.put("b","B");
        linked.put("d","D");
        linked.put("a","D");
        System.out.println(linked);//key不允许重复，有序 //{a=D, c=C, b=B, d=D}
    }
}

三、java.util.Hashtable<K, V>集合

java.util.Hashtable<K, V>集合 implements Map<K,V>接口

1.与hashMap对比：
Hashtable:底层也是一个哈希表，是一个线程安全的集合，是单线程集合，速度慢。
HashMap:底层是一个哈希表，是一个线程不安全的集合，是多线程的集合，速度快。

Hashtable集合(之前学过的所有集合):可以储存null值，null键
HashMap集合:不能储存null键，null键

Hashtable集合是最早期的双列集合，和Vector集合一样，在JDK1.2后被HashMap、ArrayList取代
Hashtable的子类Properties依然活跃在历史舞台，它是唯一一个和IO流相结合的集合。

import java.util.HashMap;
import java.util.Hashtable;

public class Demo09Hashtable {
    public static void main(String[] args) {
        HashMap<String,String> map = new HashMap<>();
        map.put(null,"a");
        map.put("B",null);
        map.put(null,null);
        System.out.println(map);//{null=null, B=null}第一个被取代

        Hashtable<String,String> table = new Hashtable<>();
//        table.put(null,"a");//NullPointerException
//        table.put("B",null);//NullPointerException
//        table.put(null,null);//NullPointerException
    }
}

四、JDK9的新特性

List接口、Ste接口、Map接口：里面增加了一个静态的方法of，可以给集合一次性添加多个元素。

1. 使用前提：当集合中储存的元素的个数已经确定，不再改变是使用。
2. Notice：

• of方法只适用于List接口、Set接口、Map接口，不适用于接口的实现类；
• of方法的返回值是一个不能改变的集合，集合不能再使用add，put方法添加元素，会抛出异常；
• Set接口和Map接口在调用of方法的时候，不能有重复的元素，否则会抛出异常。

import java.util.List;
import java.util.Map;
import java.util.Set;

public class DemoJDK9 {
    public static void main(String[] args) {
        List<String> list = List.of("a", "b", "a", "c", "d");
        System.out.println(list);//[a,b,a,c,d]
        list.add("e");//UnsupportedOperationException：不支持操作异常

        //Set<String> set = Set.of("a", "b", "a", "c", "d");//有重复元素//IllegalArgumentException非法参数异常
        Set<String> set = Set.of("a", "b", "c", "d");
        System.out.println(set);//[a,b,c,d]
        set.add("e");//UnsupportedOperationException：不支持操作异常

        Map<String,Integer> map = new Map.of("张三",18,"李四",19,"王五",20);//不能有重复元素
        System.out.println(map);
        map.put("赵四",20);//UnsupportedOperationException：不支持操作异常
    }
}