第一章 Map集合
1.1 概述
我们通过查看Map接口描述，发现Map接口下的集合Collection接口下的集合，他们存储数据的形式不同，如下图：
- Collection中的集合，元素是孤立存在的，向集合中存储元素采用一个个元素的方式存储。
- Map中的集合，元素是成对存在的。每个元素由键与值两部分组成，通过键与值两个部分组成，通过键可以找所对应的值。
- Collection中的集合称为单列集合，Map中的集合称为双列集合。
- 需要我们注意的是：Map中的集合不能包含重复的键，值可以重复，每个键只能对应一个值。
1.2 Map的常用子类
通过查看Map接口描述，看到Map有多个子类，我们主要学HashMap集合，LinkedHashMap集合。
- HashMap：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一，不重复，需要重写键的hashCode()，equals()方法。
- LinkedHashMap：HashMap下有一个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素存取的顺序一致；通过哈希表结构可以保证键的唯一，不重复，需要重写键的hashCode方法，equals方法。
1.3 Map接口中的常用方法
Map接口中定义了很多方法，常用的如下：
- public V put(K key, V value)：把指定的键与指定的值添加到Map集合中。
- public V remove(Object key)：把指定的键所对应的键值对元素在Map集合中删除，返回被删除元素的值。
- public V get(Object key)：根据指定的键，在Map集合中获取对应的值。
- public Set<K> keySet()：获取Map集合中所有的键，存储到Set集合。
- public Set<Map.Entry<K, V>> entrySet()：获取到Map集合中所有的键值对对象的集合。
- 代码如下：
package com.it.day04code.Map;/*
* java.util.Map<k, v>集合
* Map集合的特点：
* 1、Map集合是一个双列集合，一个元素包含两个值（一个key，一个value）
* 2、Map结婚中的元素，key和value的数据类型可以相同，也可以不同。
* 3、Map集合中的元素，key是不允许重复的，value是可以重复的。
* 4、Map集合中的元素，key和value是一一对应。
* java.util.HashMap<k, v>集合 implements Map<k, v>接口
* HashMap集合的特点：
* 1、HashMap集合底层是哈希表：查询速度非常快。
* JDK1.8之前：数组+单向链表
* JDK1.8之后：数组+单向链表/红黑树，提高查询速度
* 2、hashMap集合是一个无序的集合，存储元素和取出元素的顺序有可能不一致。
* java.util.LinkedHashMap<k, v>集合 extends HashMap<k, v>集合
* LinkedHashMap特点：
* 1、LinkedHashMap结婚底层是哈希表+链表（保证了迭代的顺序）
* 2、LinkedHashMap集合是一个有序的集合，存储元素和取出元素的顺序是一致的。
*
* */import java.util.HashMap;
import java.util.Map;public class Demo01Map {public static void main(String[] args) {// show01();// show02();// show03();show04();}/** boolean containsKey(Object key) 判断集合中是否包含指定的键。* 包含返回true，不包含返回false** */private static void show04() {// 创建Map集合对象Map<String, Integer> map = new HashMap<>();map.put("赵丽颖", 168);map.put("杨颖", 165);map.put("林志玲", 178);System.out.println(map);boolean v1 = map.containsKey("赵丽颖");System.out.println("v1:" + v1);boolean v2 = map.containsKey("tiger");System.out.println("v2:" + v2);}/** public V get(Object key) 根据指定的键，在Map集合中获得对应的值* 返回值：* key存在返回对应的值* key不存在返回null** */private static void show03() {// 创建Map集合对象Map<String, Integer> map = new HashMap<>();map.put("赵丽颖", 168);map.put("杨颖", 165);map.put("林志玲", 178);System.out.println(map);Integer v1 = map.get("杨颖");System.out.println("v1:" + v1);Integer v2 = map.get("tiger");System.out.println("v2:" + v2);}/** public V remove(Object key)：把指定的键所对应的键值对元素在map集合中删除，返回被删除元素的值* 返回值：V* key存在返回被删除的值* key不存在返回null*** */private static void show02() {// 创建Map集合对象Map<String, Integer> map = new HashMap<>();map.put("赵丽颖", 168);map.put("杨颖", 165);map.put("林志玲", 178);System.out.println(map);Integer v1 = map.remove("林志玲");System.out.println("v1:" + v1);System.out.println(map);Integer v2 = map.remove("tiger");System.out.println("v2:" + v2);System.out.println(map);}/** public V put(K key, V value)：把指定的键与指定的值添加到Map集合中。* 返回值：v* 存储键值对的时候，key不重复，返回值v是null* 存储键值对的时候，key重复，会使用新的value替换map中重复的value，返回值是被替换的value值* */private static void show01() {// 创建Map集合对象，多态Map<String, String> map = new HashMap<>();String v1 = map.put("tiger", "trony1");System.out.println("v1:" + v1);String v2 = map.put("tiger", "trony2");System.out.println("v2:" + v2);System.out.println(map);map.put("冷锋", "龙小云");map.put("杨过", "小龙女");map.put("尹志平", "小龙女");System.out.println(map);}}
注意：使用put方法时，若指定的键（key）在集合中没有，则没有这个键对应的值，返回null，并把指定的键值添加到集合中。若指定的键在集合中存在，则返回值为集合中键对应的值，并把指定键所对应的值，替换成为新值。
1.4 Map集合遍历键找值的方式
- 键找值的方式：即通过元素中的键，获取键所对应的值。
- 分析步骤：
- 获取Map中的所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键，方法提示：keySet()
- 遍历键的Set集合，得到每一个键。
- 根据键，获取键所对应的值，方法提示：get(K key)
package com.it.day04code.Map;/*
* Map集合中的第一种遍历方式：通过键找值的方式
* Map集合中的方法：
* Set<K> keySet() 返回此映射中包含的键的set视图
* 实现步骤：
* 1、使用Map集合中的方法keySet()，把Map集合所有的key取出来，存储到一个set集合中
* 2、遍历set集合，获取Map集合中每一个key
* 3、通过Map集合中的方法get(key)，通过key找到value
*
* */import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;public class Demo02KeySet {public static void main(String[] args) {// 创建Map集合对象Map<String, Integer> map = new HashMap<>();map.put("赵丽颖", 168);map.put("杨颖", 165);map.put("林志玲", 178);System.out.println(map);// 使用Map集合中的方法keySet()，把Map集合所有的key取出来，存储到一个set集合中Set<String> set = map.keySet();// 遍历set集合，获取Map集合中每一个key// 使用迭代器遍历Set集合Iterator<String> it = set.iterator();while (it.hasNext()) {System.out.println(map.get(it.next()));}System.out.println("=======================");// 使用增强for遍历set集合for (String name : set) {System.out.println(map.get(name));}}
}
1.5 Entry键值对对象
在之前我们可以看到，Map中存放的是两种对象，一种称为key(键)，一种称为value(值)，它们在Map中是一一对应关系，这一对对对象又称作Map中的一个Entry（项）。Entry将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历Map集合的时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。
- 既然Entry表示了一对键和值，那么也同样提供了获取对应键和对应值的方法：
- public E getKey()：获取Entry对象中的键。
- public V getValue()：获取Entry对象中的值。
- 在Map集合中获取所有Entry对象的方法：
- public Set<Map.Entry<K, V>> entrySet()：获取到Map集合中所有的键值对对象的集合。
1.6 Map集合遍历键值对方式
- 键值对方式：即通过集合中每个键值对对象，获取键值对对象中的键与值。
- 操作步骤：
- 获取Map集合中，所有的键值对对象，以set集合形式返回，方法提示：entrySet()
- 遍历包含键值对对象的Set结合，得到每一个键值对对象。
- 通过键值对对象，获取Entry对象中的键与值，方法提示：getKey()，getValue()
- 代码如下：
package com.it.day04code.Map;/*
* map集合遍历的第二种方式：
* Map集合中的方法：
* Set<Map.Entry<K, V>> entrySet() 返回此映射中包含的映射关系的set视图
*
* 实现步骤：
* 1、使用map集合中的方法entrySet()，把Map结婚中多个Entry对象取出来，存储到一个Set集合中
* 2、遍历Set集合，获取每一个Entry对象
* 3、使用Entry对象中的方法getKey()和getValue()获取键与值
*
* */import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;public class Demo03EntrySet {public static void main(String[] args) {// 创建Map集合对象Map<String, Integer> map = new HashMap<>();map.put("赵丽颖", 168);map.put("杨颖", 165);map.put("林志玲", 178);System.out.println(map);// 使用map集合中的方法entrySet()，把Map结婚中多个Entry对象取出来，存储到一个Set集合中Set<Map.Entry<String, Integer>> set = map.entrySet();// 遍历Set集合，获取每一个Entry对象// 使用迭代器遍历Set集合Iterator<Map.Entry<String, Integer>> it = set.iterator();while (it.hasNext()) {Map.Entry<String, Integer> entry = it.next();System.out.println(entry.getKey() + "=" + entry.getValue());}System.out.println("=====================");// 使用增强for循环遍历for (Map.Entry<String, Integer> entry : set) {System.out.println(entry.getKey() + "=" + entry.getValue());}}
}
1.7 HashMap存储自定义类型键值
编写类：
package com.it.day04code.HashMap;import java.util.Objects;public class Person {private String name;private int age;public Person() {}public Person(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;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +'}';}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Person person = (Person) o;return age == person.age &&Objects.equals(name, person.name);}@Overridepublic int hashCode() {return Objects.hash(name, age);}
}
编写测试类：
package com.it.day04code.HashMap;/*
* HashMap存储自定义类型键值
* Map集合保证key是唯一的：
* 作为key的元素必须要重写hashCode方法和equals方法，以保证key唯一
*
* */import java.util.HashMap;
import java.util.Map;
import java.util.Set;public class Demo01HashMapSavePerson {public static void main(String[] args) {// show01();show02();}/** HashMap存储自定义类型键值* key：Person类型* Person类就必须重写hashCode方法和equals方法，以保证key唯一* value：String类型* value可以重复** */private static void show02() {// 创建一个HashMap集合HashMap<Person, String> map = new HashMap<>();// 往集合中添加元素map.put(new Person("女王", 18), "英国");map.put(new Person("秦始皇", 18), "秦国");map.put(new Person("普京", 18), "俄罗斯");map.put(new Person("女王", 18), "毛里求斯");// 使用entrySet和增强for遍历Map集合Set<Map.Entry<Person, String>> set = map.entrySet();for (Map.Entry<Person, String> entry : set) {System.out.println(entry.getKey() + "=" + entry.getValue());}}/** HashMap存储自定义类型键值* key：String类型* String类重写hashCode方法和equals方法，可以保证key唯一** value：Person类型* value可以重复(同名同年龄视为同一个人)** */private static void show01() {// 创建HashMap集合HashMap<String, Person> map = new HashMap<>();// 往集合中添加元素map.put("北京", new Person("张三", 18));map.put("上海", new Person("李四", 19));map.put("广州", new Person("王五", 20));map.put("北京", new Person("赵六", 18));// 使用keySet加增强for遍历Map集合Set<String> set = map.keySet();for(String key : set) {System.out.println(key + "-->" + map.get(key));}}}
- 当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须重写对象的hashCode和equals方法。
- 如果要保证map中存放的key和取出的顺序一致，可以使用java.util.LinkedHashMap。
1.8 LinkedHashMap
在前面我们学到HashMap保证成对元素的唯一，并且查询速度很快，可是对成对元素存放进去是没有顺序的，那么我们要保证有序，就可以使用LinkedHashMap子类，它是一个链表和哈希表的一个数据存储结构。代码如下：
package com.it.day04code.LinkedHashMap;/*
* java.util.LinkedHashMap<K, V> extends HashMap<K, V>
* Map接口的哈希表和链表实现，具有可预知的迭代顺序
* 底层原理：
* 哈希表+链表（记录元素的顺序）
* */import java.util.HashMap;
import java.util.LinkedHashMap;public class Demo01LinkedHashMap {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");System.out.println(map); // key值不允许重复，无序LinkedHashMap<String, String> linked = new LinkedHashMap<>();linked.put("a", "a");linked.put("c", "c");linked.put("b", "b");linked.put("d", "d");System.out.println(linked); // key不允许重复，有序的集合}
}
1.9 Map集合练习
需求： 计算一个字符串中每个字符出现次数。
import java.util.HashMap;
import java.util.Scanner;public class Demo01Main {public static void main(String[] args) {HashMap<Character, Integer> map = new HashMap<>();System.out.println("请输入一个字符串：");String input = new Scanner(System.in).next();char[] chars = input.toCharArray();for (int i = 0; i < chars.length; i++) {char ch = chars[i];if (map.containsKey(ch)) {Integer integer = map.get(ch);integer += 1;map.put(ch, integer);} else {map.put(ch, 1);}}System.out.println(map);}
}
第二章 补充知识点
2.1 JDK9对集合添加的优化
通常我们在代码中创建一个集合，并且直接用一些元素来填充它，实力化集合，集合add方法重复使用，在JDK9中，添加了集中集合工厂方法，用来方便我们创建少量元素的集合，map实例。代码如下：
/*
* JDK的新特性：
* List接口，Set接口，Map接口：里面增加了一个静态方法of，可以一次性的添加多个元素
* static <E> List<E> of (E... element)
* 使用前提：当集合中存储的元素的个数已经确定了，不再改变时使用
* 注意：
* 1、of方法只适用于List接口，Set接口，Map接口，不适用于接口的实现类。
* 2、of方法的返回值是一个不能改变的集合，集合不能再使用add，put方法添加元素，会抛出异常。
* 3、Set接口和Map接口在调用of方法的时候，不能有重复元素，否则会抛出异常
*
* */import java.util.List;
import java.util.Map;
import java.util.Set;public class Demo01JDK9 {public static void main(String[] args) {List<String> list = List.of("a", "b", "c", "d");System.out.println(list);// list.add("w"); // UnsupportedOperationException：不支持操作异常// Set<String> set = Set.of("a", "b", "c", "d", "a"); // IllegalArgumentException：非法参数异常// System.out.println(set);Map<String, Integer> map = Map.of("张三", 18, "李四", 19);System.out.println(map);// map.put("赵四", 20); // UnsupportedOperationException}
}
第三章 斗地主案例重写
需求我们之前讲过，这里用map重写一下该案例：
package com.it.day04code.FightLord;import java.util.*;public class Demo01Main {public static void main(String[] args) {List<String> color = List.of("??", "??", "??", "??");List<String> no = List.of("2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3");List<String> card = new ArrayList<>();for (int i = 0; i < color.size(); i++) {for (int i1 = 0; i1 < no.size(); i1++) {String str = color.get(i) + no.get(i1);card.add(str);}}Map<Integer, String> cards = new HashMap<>();for (int i = 0; i < 54; i++) {if (i == 0) {cards.put(i, "大王");} else if (i == 1) {cards.put(i, "小王");} else {cards.put(i, card.get(i - 2));}}List<Integer> index = new ArrayList<>();for (int i = 0; i < 54; i++) {index.add(i);}Collections.shuffle(index);ArrayList<Integer> p1 = new ArrayList<>();ArrayList<Integer> p2 = new ArrayList<>();ArrayList<Integer> p3 = new ArrayList<>();ArrayList<Integer> dipai = new ArrayList<>();for (int i = 0; i < index.size(); i++) {if (i > 50) {dipai.add(index.get(i));} else if (i % 3 == 0) {p1.add(index.get(i));} else if (i % 3 == 1) {p2.add(index.get(i));} else if (i % 3 == 2) {p3.add(index.get(i));}}Collections.sort(p1);Collections.sort(p2);Collections.sort(p3);Collections.sort(dipai);for (int i = 0; i < p1.size(); i++) {if (i == 0) {System.out.printf("p1:");}System.out.printf(cards.get(p1.get(i)) + " ");}for (int i = 0; i < p2.size(); i++) {if (i == 0) {System.out.printf("\np2:");}System.out.printf(cards.get(p2.get(i)) + " ");}for (int i = 0; i < p3.size(); i++) {if (i == 0) {System.out.printf("\np3:");}System.out.printf(cards.get(p3.get(i)) + " ");}for (int i = 0; i < dipai.size(); i++) {if (i == 0) {System.out.printf("\ndipai：");}System.out.printf(cards.get(dipai.get(i)) + " ");}}
}