Map、HashMap、TreeMap、Collections工具类

一、Map

1、概述：

将键映射到值的对象，一个映射不能包含重复的键，每个键最多只能映射到一个值。

 Map<K,E> map = new HashMap<>();//实例化，使用子类HashMap具体实例化。

2、Map接口和Collection接口的不同

（1）Map是双列的，Collection是单列的

（2）Map的键是唯一的，Collection的子体系Set是唯一的

（3）Map集合的数据结构值针对键有效，跟值无关，Collection集合的数据结构是针对元素有效。

3、Map接口方法

（1）添加功能：
    V put(K key, V value) 将键和对应的值加入Map集合中
    举例：map.put(1001,"王宇");

（2）删除功能：
    void clear() ：清空Map集合
    V remove(Object key) 如果存在指定键，从该Map中删除一个键的映射（键和对应的值），返回删除的键对应的值。

（3）判断功能：
    boolean containsKey(Object key) 如果此映射包含指定键的映射，则返回 true 。
    boolean containsValue(Object value) 如果此Map将一个或多个键映射到指定的值，则返回 true 。
    boolean isEmpty() 如果此Map不包含键值映射，则返回 true 。

（4）获取功能：
    V get(Object key) 返回到指定键所映射的值，或 null如果此映射包含该键的映射。
    Set<K> keySet() 返回此Map中所有键（不包含对应的值）组成的Set集合。

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

    Collection<V> values() 返回此Map中包含的值的Collection集合

Collection<String> values = map.values();

   Set<Map.Entry<K,V>> entrySet() 获取Map中所有元素，元素的类组成是由一个键和一个值组成

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

（5）长度功能：
    int size() 返回此Map中键值映射的数量。

4、遍历

（1）方法一：利用KeySet()方法形成Map集合所有键的Set集合，再用get（Object key）获取每个键对应的值

HashMap<String, String> map = new HashMap<>();

        //向集合中添加元素
        map.put("霞", "洛");
        map.put("蛮王", "寒冰");
        map.put("卢锡安", "塞纳");
        map.put("盖伦", "卡特");

        //通过调用keySet()方法获取Map集合中所有的key
        Set<String> keySet = map.keySet();

        //遍历keySet获取到每一个key
        for (String s : keySet) {
            String value = map.get(s);
            System.out.println(s + ":" + value);
        }
卢锡安:塞纳
蛮王:寒冰
霞:洛
盖伦:卡特

（2）方法二：利用Set<Map.Entry<K,V>> entrySet() 一次性先把所有的键值对获取到，然后在依次获取每一个键值对的key和value

 HashMap<String, String> map = new HashMap<>();

        //2、向集合中添加元素
        map.put("王子1", "白雪公主");
        map.put("王子2", "灰姑凉");
        map.put("王子3", "美人鱼");

        //遍历：一次先把所有的键值对获取到
        //Set<Map.Entry<K,V>> entrySet() 获取Map中所有元素，元素的类组成是由一个键和一个值组成
        Set<Map.Entry<String, String>> set = map.entrySet();

        //遍历集合获取每一个键值对
        for (Map.Entry<String, String> keyValue : set) {
//         System.out.println(keyValue);
            String key = keyValue.getKey();
            String value = keyValue.getValue();
            System.out.println(key + ":" + value);
        }
王子1:白雪公主
王子2:灰姑凉
王子3:美人鱼

二、HashMap

1、特点

         键是哈希表结构，可以保证键的唯一性

2、注意

        HashMap<Student,String>

如果key是自己自定义的一个对象，该类需要重写hashCode()方法和equals()方法
因为put方法的底层，添加元素的标准就是根据hashCode()方法和equals()的值来判断元素是否重复

3、LinkedHashMap:

      class LinkedHashMap extends HashMap implements Map{}

      哈希表和链表实现的Map接口，具有可预测的迭代次序。

      哈希保证的是元素的唯一，保证key是唯一 链表保证是有序的（存储和取出的顺序一致）

LinkedHashMap<String, String> map = new LinkedHashMap<>();

        //向集合中添加元素
        map.put("1234", "hello");
        map.put("4567", "world");
        map.put("3456", "java");
        map.put("7890", "hadoop");
        map.put("1234", "hive");

        //遍历
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> keyValue : entries) {
            String key = keyValue.getKey();
            String value = keyValue.getValue();
            System.out.println(key + ":" + value);
        }
1234:hive
4567:world
3456:java
7890:hadoop

三、TreeMap

1、特点

      键是红黑树结构，可以保证键的排序和唯一性

TreeMap<String, String> map = new TreeMap<>();

2、TreeMap<Student,String>

   当键是自定义类时，因为键是红黑树结构，所以要么自然排序，要么比较器排序（推荐）

 //推荐使用比较器排序，并且用匿名内部类实现
        TreeMap<Student6, String> map = new TreeMap<>(new Comparator<Student6>() {
            @Override
            public int compare(Student6 o1, Student6 o2) {
                //        return 0;
                //判断年龄是否一样
                int i = o1.getAge() - o2.getAge();
                //年龄一样。姓名不一定一样
                int i2 = i == 0 ? o1.getName().compareTo(o2.getName()) : i;

                return i2;
            }
        });

        //2、创建学生对象
        Student6 s1 = new Student6("明旺", 18);
        Student6 s2 = new Student6("王宇", 19);
        Student6 s3 = new Student6("周家祥", 20);
        Student6 s4 = new Student6("明旺", 18);

        //3、向集合中添加元素
        map.put(s1, "男枪");
        map.put(s2, "女警");
        map.put(s3, "卡特");
        map.put(s4, "男枪");

        //4、遍历
        Set<Map.Entry<Student6, String>> entries = map.entrySet();
        for (Map.Entry<Student6, String> keyValue : entries) {
            Student6 key = keyValue.getKey();
            String value = keyValue.getValue();
            System.out.println(key + ":" + value);
        }
Student4{name='明旺', age=18}:男枪
Student4{name='王宇', age=19}:女警
Student4{name='周家祥', age=20}:卡特

四、应用

1、集合嵌套

举例：ArrayList嵌套HashMap

ArrayList<HashMap<String, String>> list = new ArrayList<>();

        //创建2个HashMap对象
        HashMap<String, String> map1 = new HashMap<>();
        map1.put("霞", "洛");
        map1.put("卢锡安", "塞纳");
        map1.put("蛮王", "寒冰");
        map1.put("盖伦", "卡特");

        HashMap<String, String> map2 = new HashMap<>();
        map2.put("邓超", "孙俪");
        map2.put("张杰", "谢娜");
        map2.put("小虎", "冯提莫");

        list.add(map1);
        list.add(map2);

        //遍历
        for (HashMap<String, String> maps : list) {
            Set<Map.Entry<String, String>> entries = maps.entrySet();
            for (Map.Entry<String, String> keyValue : entries) {
                String key = keyValue.getKey();
                String value = keyValue.getValue();
                System.out.println(key + ":" + value);
            }
        }

2、HashMap和Hashtable的区别

(1)HashMap与Hashtable它们存储的元素都是一个一个的键值对

(2)HashMap中的key和value允许为null值，而Hashtable不允许

(3)Hashtable是线程安全的，而HashMap是线程不安全的

五、Collections工具类：针对集合操作的工具类

1：Collections与Collection的区别：

    1、Collection是单列集合的顶层接口，有两大子接口List/Set
    2、Collections是一个针对于集合操作的工具类，可以对集合进行排序，还有查找（二分查找）

 2、方法

public static <T> void sort(List<T> list):排序
public static <T> int binarySearch(List<?> list,T key)：二分查找，前提是list集合有序，返回对应元素的索引
public static <T> T max(Collection<?> coll)：查找最大值，返回最大值
public static void reverse(List<?> list)：将集合反转
public static void shuffle(List<?> list)：随机排序

static <T> List<T> synchronizedList(List<T> list) 返回由指定列表支持的同步（线程安全）列表。

List<Integer> list1 = Collections.synchronizedList(list);
//将ArrayList转换成线程安全的集合，返回的集合和原本的是一个存储空间