第一章 Map集合 1.1 概述 现实生活中，我们常会看到这样的一种集合：IP地址与主机名，身份证号与个人，系统用户名与系统用户对象等，这种一一对应的关系，就叫做映射。Java提供了专门的集合类用来存放这种对象关系的对象，即java.util.Map接口。
我们通过查看Map接口描述，发现Map接口下的集合与Collection接口下的集合，它们存储数据的形式不同，如下图。
Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。Map中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值。Collection中的集合称为单列集合，Map中的集合称为双列集合。需要注意的是，Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。 1.2 Map常用子类 通过查看Map接口描述，看到Map有多个子类，这里我们主要讲解常用的HashMap集合、LinkedHashMap集合。
HashMap<K,V> ：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。LinkedHashMap<K,V> ：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。tips：Map接口中的集合都有两个泛型变量<K,V>,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量<K,V>的数据类型可以相同，也可以不同。
1.3 Map接口中的常用方法 Map接口中定义了很多方法，常用的如下：
public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。public V get(Object key) 根据指定的键，在Map集合中获取对应的值。boolean containsKey(Object key) 判断集合中是否包含指定的键。public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。Map接口的方法演示
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 public class Demo01Map public static void main (String[] args) show04(); } public static void show01 () Map<String,Integer> map=new HashMap<>(); System.out.println(map.put("水冰儿" , 19 )); System.out.println(map.put("水冰儿" , 20 )); System.out.println(map.put("云韵" , 30 )); System.out.println(map.put("焰灵姬" , 28 )); System.out.println(map); } public static void show02 () Map<String,Integer> map=new HashMap<>(); map.put("水冰儿" , 19 ); map.put("焰灵姬" , 28 ); map.put("妙妙" , 18 ); System.out.println(map); System.out.println(map.remove("水冰儿" )); System.out.println(map); System.out.println(map.remove("林志颖" )); System.out.println(map); } public static void show03 () Map<String,Integer> map=new HashMap<>(); map.put("水冰儿" , 19 ); map.put("焰灵姬" , 28 ); map.put("妙妙" , 18 ); System.out.println(map); System.out.println(map.get("水冰儿" )); System.out.println(map.get("紫女" )); } public static void show04 () Map<String,Integer> map=new HashMap<>(); map.put("水冰儿" , 19 ); map.put("焰灵姬" , 28 ); map.put("妙妙" , 18 ); System.out.println(map.containsKey("水冰儿" )); System.out.println(map.containsKey("焰灵姬啊" )); } }
1.4 Map集合遍历——键找值方式 键找值方式：即通过元素中的键，获取键所对应的值
分析步骤：
获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键。方法提示:keyset() 遍历键的Set集合，得到每一个键。 根据键，获取键所对应的值。方法提示:get(K key) 代码演示：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 public class Demo02Map public static void main (String[] args) Map<String, Integer> map=new HashMap<>(); map.put("水冰儿" , 19 ); map.put("妙妙" , 22 ); map.put("焰灵姬" , 28 ); for (String key:map.keySet()) { System.out.print(key); System.out.println(map.get(key)); } } }
遍历图解：
1.5 Entry键值对对象 我们已经知道，Map中存放的是两种对象，一种称为key (键)，一种称为value (值)，它们在在Map中是一一对应关系，这一对对象又称做Map中的一个Entry(项)。Entry将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。
既然Entry表示了一对键和值，那么也同样提供了获取对应键和对应值得方法：
public K getKey()：获取Entry对象中的键。public V getValue()：获取Entry对象中的值。在Map集合中也提供了获取所有Entry对象的方法：
public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。1.6 Map集合遍历——键值对方式 键值对方式：即通过集合中每个键值对(Entry)对象，获取键值对(Entry)对象中的键与值。
操作步骤与图解：
获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。方法提示:entrySet()。
遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象。
通过键值对(Entry)对象，获取Entry对象中的键与值。 方法提示:getkey() getValue()
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 public class Demo03Map public static void main (String[] args) Map<String, Integer> map=new HashMap<>(); map.put("水冰儿" , 19 ); map.put("妙妙" , 22 ); map.put("焰灵姬" , 28 ); Set<Entry<String, Integer>> set=map.entrySet(); for (Entry<String,Integer> ii:set) { System.out.println(ii.getKey()+ii.getValue()); } } }
遍历图解：
tips：Map集合不能直接使用迭代器或者foreach进行遍历。但是转成Set之后就可以使用了。
1.7 HashMap存储自定义类型键值 HashMap存储自定义类型键值
Map集合保证key是唯一的：作为key的元素，必须重写hashCode()和equals()方法，以保证元素的唯一
练习
每个妹子（姓名，年龄）都有自己的出处。那么，既然有对应关系，则将妹子对象和动漫出处存储到map集合中。
妹子作为键，出处作为值——show02方法
出处作为键，妹子作为值——show01方法
代码演示
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 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; } @Override public int hashCode () final int prime = 31 ; int result = 1 ; result = prime * result + age; result = prime * result + ((name == null ) ? 0 : name.hashCode()); return result; } @Override public boolean equals (Object obj) if (this == obj) return true ; if (obj == null ) return false ; if (getClass() != obj.getClass()) return false ; Person other = (Person) obj; if (age != other.age) return false ; if (name == null ) { if (other.name != null ) return false ; } else if (!name.equals(other.name)) return false ; return true ; } @Override public String toString () return "Person [name=" + name + ", age=" + age + "]" ; } } public class Demo03HashMapSavePerson public static void main (String[] args) show01(); } public static void show01 () HashMap<String,Person> map=new HashMap<>(); map.put("斗罗大陆" , new Person("水冰儿" ,18 )); map.put("斗破苍穹" , new Person("云韵" ,30 )); map.put("天行九歌" , new Person("焰灵姬" ,28 )); map.put("梦塔雪迷城" , new Person("妙妙" ,22 )); map.put("斗破苍穹" , new Person("美杜莎" ,32 )); Set<Entry<String, Person>> set=map.entrySet(); Iterator<Entry<String,Person>> i=set.iterator(); while (i.hasNext()) { Entry<String, Person> entry=i.next(); System.out.println(entry.getKey()+"=====" +entry.getValue()); } } public static void show02 () HashMap<Person,String> map=new HashMap<>(); map.put(new Person("水冰儿" ,18 ),"斗罗大陆" ); map.put(new Person("云韵" ,30 ),"斗破苍穹" ); map.put(new Person("焰灵姬" ,28 ),"天行九歌" ); map.put(new Person("妙妙" ,22 ),"梦塔雪迷城" ); map.put(new Person("美杜莎" ,32 ),"斗破苍穹" ); map.put(new Person("美杜莎" ,31 ),"斗破苍穹" ); for (Person p:map.keySet()) { System.out.println(p+"===" +map.get(p)); } } }
当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须重写对象的hashCode和equals方法(如果忘记，请回顾HashSet存放自定义对象)。 如果要保证map中存放的key和取出的顺序一致，可以使用java.util.LinkedHashMap集合来存放。 1.8 LinkedHashMap 我们知道HashMap保证成对元素唯一，并且查询速度很快，可是成对元素存放进去是没有顺序的，那么我们要保证有序，还要速度快怎么办呢？
在HashMap下面有一个子类LinkedHashMap，它是链表和哈希表组合的一个数据存储结构。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 public class Demo05LinkedHashMap public static void main (String[] args) HashMap<String, Integer> map=new HashMap<String, Integer>(); map.put("水冰儿" , 19 ); map.put("妙妙" , 22 ); map.put("焰灵姬" , 28 ); System.out.println(map); LinkedHashMap<String,Integer> list=new LinkedHashMap<String, Integer>(); list.put("水冰儿" , 19 ); list.put("妙妙" , 22 ); list.put("焰灵姬" , 28 ); System.out.println(list); } }
1.9 Hashtable HashMap:底层是一个哈希表，是一个线程不安全的集合，是多线程的集合，速度快。可以存储null值，null键
Hashtable:底层是一个哈希表，是一个线程安全的集合，是单线程集合，速度慢。不能存储null值，null键
Hashtable(Vector)在jdk1.2之后，被更先进的集合HashMap(ArrayList)取代了。
Hashtable的子类Properties仍然活跃在历史舞台，Properties集合是一个唯一和IO流相结合的集合。
Hashtable代码演示：
1 2 3 4 5 6 7 8 9 10 11 12 13 14 public class Demo06Hashtable public static void main (String[] args) HashMap<String,Integer> map=new HashMap<String,Integer>(); map.put("a" , null ); map.put(null , null ); map.put(null ,1 ); System.out.println(map); Hashtable<String, Integer> table=new Hashtable<String, Integer>(); } }
1.10 Map集合练习 需求：
计算一个字符串中每个字符出现次数。
分析：
获取一个字符串对象 创建一个Map集合，键代表字符，值代表次数。 遍历字符串得到每个字符。 判断Map中是否有该键。 如果没有，第一次出现，存储次数为1；如果有，则说明已经出现过，获取到对应的值进行++，再次存储。 打印最终结果 代码：
javascript实现方法
1 2 3 4 5 6 7 8 9 10 11 12 13 14 let arr="chenchuancheng" ;let obj={};for (let i=0 ;i<arr.length;i++){ let key=arr[i]; if (obj[key]){ obj[key]++; }else { obj[key]=1 ; } } console .log(arr);for (let i in obj){ console .log(i+"出现了" +obj[i]+"次" ); }
java实现方法
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 public class Demo07Practice public static void main (String[] args) String str="chenchuancheng" ; String[] strArr=str.split("" ); LinkedHashMap<String, Integer> list=new LinkedHashMap<String, Integer>(); for (String s:strArr) { if (list.containsKey(s)) { int num=list.get(s); list.put(s, ++num); }else { list.put(s,1 ); } } Set<Entry<String,Integer>> set=list.entrySet(); for (Entry<String,Integer> i:set) { System.out.println(i.getKey()+"出现了" +i.getValue()+"次" ); } } }
1.11 JDK9对集合添加的优化 通常，我们在代码中创建一个集合（例如，List 或 Set ），并直接用一些元素填充它。 实例化集合，几个 add方法 调用，使得代码重复。
1 2 3 4 5 6 7 8 9 public class Demo01 public static void main (String[] args) List<String> list = new ArrayList<>(); list.add("abc" ); list.add("def" ); list.add("ghi" ); System.out.println(list); } }
jdk9新特性
List接口，Set接口，Map接口，里面增加了一个静态的方法of，可以给集合一次性地添加多个元素
使用前提
当集合中元素的个数已经确定了，不再改变的时候使用
注意
of方法只适用于List、Set、Map，不使用与接口的实现类，比方说ArrayList、HashSet、HashMap of方法的返回值是一个不能改变的集合，集合不能再使用add或者put方法添加元素，会抛出异常 Set接口和Map接口在调用of方法的时候，不能有重复的元素，否则也会抛出异常。 例子
1 2 3 4 5 6 7 8 9 10 11 public class HelloJDK9 public static void main (String[] args) Set<String> str1=Set.of("a" ,"b" ,"c" ); System.out.println(str1); Map<String,Integer> str2=Map.of("a" ,1 ,"b" ,2 ); System.out.println(str2); List<String> str3=List.of("a" ,"b" ); System.out.println(str3); } }
需要注意以下两点：
1:of()方法只是Map，List，Set这三个接口的静态方法，其父类接口和子类实现并没有这类方法，比如 HashSet，ArrayList等待；
2:返回的集合是不可变的；
第二章 模拟斗地主洗牌发牌 2.1 案例介绍 按照斗地主的规则，完成洗牌发牌的动作。
具体规则：
组装54张扑克牌将 54张牌顺序打乱 三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。 查看三人各自手中的牌（按照牌的大小排序）、底牌 规则：手中扑克牌从大到小的摆放顺序：大王,小王,2,A,K,Q,J,10,9,8,7,6,5,4,3
2.2 案例需求分析 准备牌： 完成数字与纸牌的映射关系：
使用双列Map(HashMap)集合，完成一个数字与字符串纸牌的对应关系(相当于一个字典)。
洗牌： 通过数字完成洗牌发牌
发牌： 将每个人以及底牌设计为ArrayList,将最后3张牌直接存放于底牌，剩余牌通过对3取模依次发牌。
存放的过程中要求数字大小与斗地主规则的大小对应。
将代表不同纸牌的数字分配给不同的玩家与底牌。
看牌： 通过Map集合找到对应字符展示。
通过查询纸牌与数字的对应关系，由数字转成纸牌字符串再进行展示。
2.3 实现代码步骤 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 public class DouDiZhu public static void main (String[] args) List<String> colors = List.of("♥" , "♠" , "♣" , "♦" ); List<String> numbers = List.of("2" , "A" , "K" , "Q" , "J" , "10" , "9" , "8" , "7" , "6" , "5" , "4" , "3" ); Map<Integer, String> poker = new HashMap<Integer, String>(); int key = 0 ; poker.put(key++, "大王" ); poker.put(key++, "小王" ); for (String number : numbers) { for (String color : colors) { poker.put(key++, color + number); } } List<Integer> pokerKey = new ArrayList<Integer>(); for (int i = 0 ; i < 54 ; i++) { pokerKey.add(i); } Collections.shuffle(pokerKey); ArrayList<Integer> no01 = new ArrayList<Integer>(); ArrayList<Integer> no02 = new ArrayList<Integer>(); ArrayList<Integer> no03 = new ArrayList<Integer>(); ArrayList<Integer> noDiPai = new ArrayList<Integer>(); for (int i = 0 ; i < pokerKey.size(); i++) { Integer p = pokerKey.get(i); if (i >= 51 ) { noDiPai.add(p); } else if (i % 3 == 0 ) { no01.add(p); } else if (i % 3 == 1 ) { no02.add(p); } else if (i % 3 == 2 ) { no03.add(p); } } Collections.sort(no01); Collections.sort(no02); Collections.sort(no03); Collections.sort(noDiPai); ArrayList<String> player01 = new ArrayList<String>(); ArrayList<String> player02 = new ArrayList<String>(); ArrayList<String> player03 = new ArrayList<String>(); ArrayList<String> diPai = new ArrayList<String>(); for (Integer i : no01) { player01.add(poker.get(i)); } for (Integer i : no02) { player02.add(poker.get(i)); } for (Integer i : no03) { player03.add(poker.get(i)); } for (Integer i : noDiPai) { diPai.add(poker.get(i)); } System.out.println("焰灵姬：" + player01); System.out.println("水冰儿：" + player02); System.out.println("紫女：" + player03); System.out.println("底牌：" + diPai); } }
