一. 概述
1. Map集合称为双列集合，格式：{key1=value1, key2=value2,.....},一次需要存一对数据作为一个元素。
2. Map集合的每个元素"key=value"称为一个键值对/键值对对象/一个Entry对象，Map集合也被称为"键值对集合"。
3. Map集合的所有键是不允许重复的，但值可以重复，键和值是一一对应的，每一个键只能找到对于的值。
① HashMap(由键决定特点)：无序、不重复、无索引。(用的最多)
② LinkedHashMap(由键决定特点)：有序、不重复、无索引
③ TreeMap(由键决定特点)：按照大小默认升序排序、不重复、无索引
public static void main(String[] args) {Map<String, String> map = new HashMap();map.put("1", "1");map.put("1", "2");map.put("卡莎", "泰坦");map.put("霞", "泰坦");map.put(null, null);//无序、不重复、无索引System.out.println(map);//{null=null, 1=2, 卡莎=泰坦, 霞=泰坦}Map<Integer, String> map1 = new TreeMap<>();map1.put(1, "张飞");map1.put(5, "霞");map1.put(3, "洛");map1.put(2, "璐璐");按照大小默认升序排序、不重复、无索引System.out.println(map1);//{1=张飞, 2=璐璐, 3=洛, 5=霞}}二. Map常用方法
1. Map是所有双列集合的父类，他的方法是所有双列集合都可以继承使用的。
| public int size() | 获取集合大小 |
| public void clear() | 清空集合 |
| public boolean isEmpty() | 判断集合是否为空，为空则返回true，否则返回false |
| public V get (Object key) | 根据键获取值 |
| public V remove(Object key) | 根据键删除元素，返回被删除元素的值 |
| public boolean containsKey(Object key) | 判断是否包含某个键，包含则返回true否则返回false |
| public boolean containsValue(Object value) | 判断是否包含某个值，包含则返回true否则返回false |
| public Set<K> keySet() | 获取map集合的全部键 |
| public Collection<V> values() | 获取map集合的全部值 |
| putAll(map) | 把其他Map集合的数据全部放入一个集合中 |
public static void main(String[] args) {Map<String, String> map = new HashMap();map.put("1", "1");map.put("1", "2");map.put("卡莎", "泰坦");map.put("霞", "泰坦");map.put(null, null);//无序、不重复、无索引System.out.println(map);//{null=null, 1=2, 卡莎=泰坦, 霞=泰坦}//1. public int size() 获取集合大小System.out.println(map.size());//4//2. public void clear() 清空集合map.clear();//3. public boolean isEmpty() 判断集合是否为空，为空则返回true，否则返回falseSystem.out.println(map.isEmpty());//true//4. public V get (Object key) 根据键获取值map.put("1", "1");map.put("卡莎", "泰坦");map.put("霞", "泰坦");System.out.println(map.get("卡莎"));//泰坦//5. public V remove(Object key) 根据键删除元素，返回被删除元素的值System.out.println(map.remove(1));//nullSystem.out.println(map.remove("1"));//1//6. public boolean containsKey(Object key) 判断是否包含某个键，包含则返回true否则返回falseSystem.out.println(map.containsKey("霞"));//true//7. public boolean containsValue(Object value) 判断是否包含某个值，包含则返回true否则返回falseSystem.out.println(map.containsValue("泰坦"));//true//8. public Set<K> keySet() 获取map集合的全部键Set<String> set = map.keySet();System.out.println(set);//[1, 卡莎, 霞]//9. public Collection<V> values() 获取map集合的全部值Collection<String> c = map.values();System.out.println(c);//10. 把其他Map集合的数据全部放入一个集合中Map<String, String> map2 = new HashMap<>();map2.putAll(map);System.out.println(map2);//{霞=泰坦, 卡莎=泰坦}}三. Map集合的遍历方式
1. 键找值：先获取Map集合全部的键，在通过遍历键来找值。
| 方法名称 | 说明 |
| public Set<K> keySet() | 获取所有键的集合 |
| public V get(Object key) | 根据键获取对应的值 |
2. 键值对：把"键值对"看成一个整体进行遍历
| 方法名称 | 说明 |
| Set<Map.Entry<K,V>> entrySet() | 获取所有“键值对”的集合 |
| K getKey() | 获取键 |
| V getValue() | 获取值 |
3. Lambda：JDK8开始之后的新技术。
| 方法名称 | 说明 |
| default void forEach(BiConsumer<? super K, ? super V> action) | 结合lambda遍历map集合 |
public static void main(String[] args) {//map集合的遍历方法//1. 键找值：先获取Map集合全部的键，在通过遍历键来找值。Map<String, String> map = new HashMap();map.put("1", "1");map.put("2", "2");map.put("卡莎", "泰坦");map.put("霞", "洛");// public Set<K> keySet() 获取所有键的集合// public V get(Object key) 根据键获取对应的值Set<String> set = map.keySet();for (String key : set) {System.out.println(key + "---->" + map.get(key));}//2. 键值对：把"键值对"看成一个整体进行遍历//Set<Map.Entry<K,V>> entrySet() 获取所有“键值对”的集合Set<Map.Entry<String, String>> entries = map.entrySet();for (Map.Entry<String, String> entry : entries) {//K getKey() 获取键//V getValue() 获取值System.out.println(entry.getKey() + "---->" + entry.getValue());}//3.Lambda：JDK8开始之后的新技术。//default void forEach(BiConsumer<? super K, ? super V> action) 结合lambda遍历map集合map.forEach((key, value) -> {System.out.println(key + "---->" + value);});}四. HashMap 集合
0. 方法基本都是继承Map集合
1. HashMap(由键决定特点)：无序(添加的元素顺序与获取出的数据顺序可能不一样)、不重复、无索引。(用的最多)；是一种增删改查数据性能都较好的集合
2. HashMap底层原理：HashMap跟HashSet的底层原理是一模一样的，都是基于哈希表实现的；Set系列集合的底层原理就是基于Map实现的，只是Set集合中的元素只要键数据，不要值数据。
3. 哈希表是一种增删改查数据性能都较好的数据结构。JDK8之前哈希表=数组+链表；JDK8之后：数组+链表+红黑树
4. HashMap的键依赖hashCode()方法和equals()方法保证键的唯一；如果存储的自定义类型的对象，可以通过重写hashCode()方法和equals()方法，保证多个对象内容一样时，HashMap集合就能认为是重复的数据。
五. LinkdeHashMap 集合
0. 方法基本都是继承Map集合
1. LinkedHashMap(由键决定特点)：有序(添加的元素顺序与获取出的数据顺序一样)、不重复、无索引
2. 底层原理：底层数据结构依然是基于哈希表实现的，只是每一个键值对元素又额外多了一个双链表的机制记录元素顺序；LinkedHashSet集合的底层原理就是LinkedHashMap
六. TreeMap 集合
0. 方法基本都是继承Map集合
1. TreeMap(由键决定特点)：按照大小默认升序排序、不重复、无索引
2. 底层原理：TreeMap跟TreeSet集合的底层原理是一样的，都是基于红黑树实现的排序。
3. TreeMap集合也支持两种方式来指定排序规则
① 让类实现Comparable接口，重写比较规则
② TreeMap集合有一个有参数构造器，支持创建Comparator比较器对象，指定比较规则
//方式1. Comparable:让该类对象实现Comparable(比较规则)接口，然后重写compareTo方法，自己制定比较规则
public class Student implements Comparable<Student>{private String name;private int age;private double score;public Student() {}public Student(String name, int age, double score) {this.name = name;this.age = age;this.score = score;}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;}public double getScore() {return score;}public void setScore(double score) {this.score = score;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +", score=" + score +'}';}@Overridepublic int compareTo(Student o) {//左边对象 大于 右边对象 返回正整数//左边对象 小于 右边对象 返回负整数//左边对象 等于 右边对象 返回0//如按照成绩排序 默认升序/*if (this.score > o.score) {return 1;}else if (this.score < o.score) {return -1;}else {return 0;}*/return Double.compare(this.getScore(), o.getScore());//升序//降序的话：//左边对象 大于 右边对象 返回负整数//左边对象 小于 右边对象 返回正整数//左边对象 等于 右边对象 返回0/* if (this.score > o.score) {return -1;}else if (this.score < o.score) {return 0;}else {return 0;}return Double.compare(o.getScore(), this.getScore());//降序*/}
}
public static void main(String[] args) {Map<Student, String> m = new TreeMap();Student student = new Student("卡莎", 18, 99);Student student1 = new Student("泰坦", 19, 93);Student student2 = new Student("伊泽", 16, 98);Student student3 = new Student("璐璐", 14, 96);m.put(student,"虚空之女");m.put(student1,"深海泰坦");m.put(student2,"探险家");m.put(student3,"仙灵女巫");//1. 让类实现Comparable接口，重写compareTo比较规则System.out.println(m);//2. TreeMap集合有一个有参数构造器，支持创建Comparator比较器对象，指定比较规Map<Student, String> m2 = new TreeMap(new Comparator<Student>() {@Overridepublic int compare(Student o1, Student o2) {return o1.getAge() - o2.getAge();}});//Map<Student, String> m2 = new TreeMap<>(( o1, o2)-> o1.getAge() - o2.getAge());m2.putAll(m);System.out.println(m2);}七. 集合的嵌套
1. 集合的嵌套指的是集合中的元素又是一个集合。
public static void main(String[] args) {//集合的嵌套 map嵌套ArrayListMap<String, List<String>> map = new HashMap();List<String> list = new ArrayList();list.add("东城区");list.add("西城区");list.add("朝阳区");list.add("丰台区");list.add("石景山区");list.add("海淀区");list.add("海淀区");map.put("北京市", list);List<String> list2 = new ArrayList();Collections.addAll(list2,"石家庄", "唐山", "秦皇岛", "邯郸");map.put("河北省", list2);//遍历map.forEach( (k,v) -> {System.out.println(k + "--->" + v);});
}