集合（三）：Map;HashMap;LinkedHashMap;TreeMap;集合嵌套

集合（三）

Map

	将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。所有Map集合的数据结构，只跟键有关，跟值没关系，键相同，值覆盖 

一、HashMap

1、概述及特点

	基于哈希表的 Map 接口的实现。允许使用 null 值和 null 键。键值对无序（存取顺序）。线程不安全，效率高。

2、HashMap常用方法

Map集合的功能概述
	a:添加功能 
		V put(K key,V value):添加元素。
			如果键是第一次存储，就直接存储元素，返回null
			如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值
	b:删除功能
		void clear():移除所有的键值对元素
		V remove(Object key)：根据键删除键值对元素，并把值返回
	c:判断功能
		boolean containsKey(Object key)：判断集合是否包含指定的键
		boolean containsValue(Object value):判断集合是否包含指定的值
		boolean isEmpty()：判断集合是否为空
	d:获取功能
		Set<Map.Entry<K,V>> entrySet(): 返回一个键值对的Set集合
		V get(Object key):根据键获取值
		Set<K> keySet():获取集合中所有键的集合
		Collection<V> values():获取集合中所有值的集合
		int size()：获取集合中的键值对的对数

3、HashMap常用方法测试

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Blog {
    public static void main(String[] args) {
        HashMap<String, Integer> hashMap = new HashMap<>();
        /*-----添加元素-----*/
        Integer oldValue = hashMap.put("aaa", 111);//之前没存过"aaa"键，返回null
        System.out.println(oldValue);  //null
        Integer oldValue1 = hashMap.put("aaa", 222);//键相同，值替换，返回被替换掉的值
        System.out.println(oldValue1); //111
        hashMap.put("bbb",222);
        System.out.println(hashMap);//{aaa=222, bbb=222}
        /*-----删除元素-----*/
        Integer aaa = hashMap.remove("aaa");//根据键删除指定键值对
        System.out.println(hashMap);//{bbb=222}
        System.out.println(aaa);//222
        hashMap.clear();//清空集合
        System.out.println(hashMap);//{}
        /*-----判断功能-----*/
        hashMap.put("ccc",333);
        boolean c = hashMap.containsKey("ccc");//判断集合是否包含指定键
        System.out.println(c);//true
        boolean c1 = hashMap.containsValue(333);//判断集合是否包含指定键值
        System.out.println(c1);//true
        boolean empty = hashMap.isEmpty();//判断集合是否为空
        System.out.println(empty);//false
        /*-----获取功能-----*/
        Set<Map.Entry<String, Integer>> set = hashMap.entrySet();//获取键值对的set集合
        hashMap.get("ccc");//根据键获取值 //333
        Set<String> keySet = hashMap.keySet();//获取所有键的set集合
        Collection<Integer> values = hashMap.values();//获取所有值的集合
        hashMap.size();//获取集合的长度
    }
}

4、Map集合的遍历

A:方式一：先获取键，再通过键找值

public static void traversingWayOne(HashMap<String, Integer> hashMap) {
        Set<String> keySet = hashMap.keySet();
        //遍历keySet集合，找值
        for (String s : keySet) {
            System.out.println(s);//键
            Integer value = hashMap.get(s);
            System.out.println(value);//值
        }
    }

B:方式二：先获取键值对，再获取键和值

public static void traversingWayTwo(HashMap<String, Integer> hashMap) {
        Set<Map.Entry<String, Integer>> set = hashMap.entrySet();
        //遍历键值对集合，找键和值
        for (Map.Entry<String, Integer> entry : set) {
            String key = entry.getKey();
            System.out.println(key);
            Integer value = entry.getValue();
            System.out.println(value);
        }
    }

5、HaShMap保证键唯一性

//重写hashCode方法 和 equals 方法
import java.util.HashMap;
import java.util.Objects;

public class Blog2 {
    public static void main(String[] args) {
        //HashMap 之所以能够保证元素的唯一性，是靠元素重写 equals()和hashCode()方法来保证的，如果元素不重写该方法，则不能保证元素的唯一性
        //合理重写hashCode 方法，可以减少调用equals()的次数，也称之为减少碰撞
        HashMap<Student,String> hashMap = new HashMap<>();
        hashMap.put(new Student("张三",23),"1");
        hashMap.put(new Student("李四",27),"1");
        hashMap.put(new Student("王五",26),"1");
        hashMap.put(new Student("张三",23),"1");
        hashMap.put(new Student("李四",27),"1");
        hashMap.put(new Student("王五",26),"1");
        hashMap.put(new Student("赵六",25),"1");
        hashMap.put(new Student("张三",24),"1");
        hashMap.put(new Student("曾七",23),"1");
        System.out.println(hashMap);
    }
}
class Student{
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}
运行结果：
{Student{name='张三', age=23}=1, Student{name='李四', age=27}=1, Student{name='王五', age=26}=1, Student{name='赵六', age=25}=1, Student{name='张三', age=24}=1, Student{name='曾七', age=23}=1}

6、HashMap和Hashtable关系

	HashMap：可以存null值null键，线程不安全，效率高
	Hashtable：不能存null值null键，线程安全，效率低
	其余大致相同。

二、LinkedHashMap

1、概述及特点

	Map 接口的哈希表和链表实现，具有可预知的迭代顺序(元素有序),并且唯一，可以存储null键null值。元素的有序性由链表数据结构保证，唯一性由哈希表数据结构保证，Map集合的数据结构只和键有关。

2、演示

import java.util.LinkedHashMap;

public class Blog3 {
    public static void main(String[] args) {
        LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<>();
        linkedHashMap.put("aaa",111);
        linkedHashMap.put("bbb",222);
        linkedHashMap.put(null,null);
        System.out.println(linkedHashMap);
    }
}
运行结果：
{aaa=111, bbb=222, null=null}

Process finished with exit code 0

三、TreeMap

1、概述及特点

	键的数据结构是二叉树,可保证键的排序和唯一性，序分为自然排序和比较器排序，键不允许插入null，线程不安全，效率高

2、演示

import java.util.Comparator;
import java.util.TreeMap;

public class Blog4 {
    public static void main(String[] args) {
        //传入比较器方式：1、可以自己创建一个Comparator<T>接口的子类，并实现 compare方法，传入该接口的子类对象
        //              2、使用匿名内部类，传入比较器，并实现compare方法
        TreeMap<Student,String> treeMap = new TreeMap<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int num=o1.getAge()-o2.getAge();
                int num1=num==0?o1.getName().compareTo(o2.getName()):num;
                return num1;
            }
        });
        treeMap.put(new Student("张三",23),"a");
        treeMap.put(new Student("李四",27),"a");
        treeMap.put(new Student("王五",26),"a");
        treeMap.put(new Student("张三",23),"a");
        treeMap.put(new Student("李四",27),"a");
        treeMap.put(new Student("王五",26),"a");
        treeMap.put(new Student("赵六",25),"a");
        treeMap.put(new Student("张三",24),"a");
        treeMap.put(new Student("曾七",23),"a");
        //按照年龄从小到大排序
        System.out.println(treeMap);
    }
}
class Student{
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
运行结果：
{Student{name='张三', age=23}=a, Student{name='曾七', age=23}=a, Student{name='张三', age=24}=a, Student{name='赵六', age=25}=a, Student{name='王五', age=26}=a, Student{name='李四', age=27}=a}

四、集合嵌套

/*
传智播客
    jc 基础班
        张三    20
        李四    22
    jy 就业班
        王五    21
        赵六    23
        
        HashMap嵌套HashMap
        HashMap再嵌套ArrayList
*/
        
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Blog {
    public static void main(String[] args) {
        ArrayList<Student> jcList = new ArrayList<>();
        jcList.add(new Student("张三",20));
        jcList.add(new Student("李四",22));
        ArrayList<Student> jyList = new ArrayList<>();
        jyList.add(new Student("王五",21));
        jyList.add(new Student("赵六",23));
        HashMap<String, ArrayList<Student>> listMap = new HashMap<>();
        listMap.put("jc\t基础班",jcList);
        listMap.put("jy\t就业班",jyList);
        HashMap<String, HashMap<String, ArrayList<Student>>> maxMap = new HashMap<>();
        maxMap.put("传智播客",listMap);
        Set<Map.Entry<String, HashMap<String, ArrayList<Student>>>> entries = maxMap.entrySet();
        for (Map.Entry<String, HashMap<String, ArrayList<Student>>> entry : entries) {
            String key = entry.getKey();
            System.out.println(key);
            HashMap<String, ArrayList<Student>> value = entry.getValue();
            Set<Map.Entry<String, ArrayList<Student>>> entries1 = value.entrySet();
            for (Map.Entry<String, ArrayList<Student>> stringArrayListEntry : entries1) {
                String key1 = stringArrayListEntry.getKey();
                System.out.println("\t"+key1);
                ArrayList<Student> value1 = stringArrayListEntry.getValue();
                for (Student student : value1) {
                    String name = student.getName();
                    int age = student.getAge();
                    System.out.println("\t\t"+name+"\t  "+age);
                }
                System.out.println();            }
        }
    }
}
class Student{
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
运行结果：
传智播客
	jc	基础班
		张三	  20
		李四	  22

	jy	就业班
		王五	  21
		赵六	  23

集合小结