1 package cn.temptation;
2
3 import java.util.HashMap;
4 import java.util.Map;
5
6 public class Sample01 {
7 public static void main(String[] args) {
8 /*
9 * Collection接口及其子接口、实现类 等 称为 单列集合
10 * Map接口及其子接口、实现类等 称为 双列集合
11 *
12 * 接口 Map<K,V>：映射，将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。
13 *
14 * Map（映射）由两部分组成：键（Key）和值（Value）
15 *
16 * 特点：
17 * 1、一个映射不能包含重复的键
18 * 2、每个键最多只能映射到一个值
19 * 3、映射中的键值对是无序的
20 *
21 * 理解Map（映射）：
22 * 联想地图，能唯一确定地点使用的是坐标，地图上没有两个相同的坐标
23 * 但是地图上可以有相同的地名，比如不同省份下的区县可能名字相同，但是它们的坐标是不同的
24 * 地图上的坐标就是键，地名就是值
25 *
26 * Map<K,V>接口的常用成员方法：
27 * 1、添加功能
28 * V put(K key, V value) ：将指定的值与此映射中的指定键关联（可选操作）。
29 * 返回：以前与 key 关联的值，如果没有针对 key 的映射关系，则返回 null。（如果该实现支持 null 值，则返回 null 也可能表示此映射以前将 null 与 key 关联）。
30 *
31 * 2、删除功能
32 * void clear() ：从此映射中移除所有映射关系（可选操作）。
33 * V remove(Object key) ：如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
34 *
35 * 3、判断功能
36 * boolean containsKey(Object key) ：如果此映射包含指定键的映射关系，则返回 true。
37 * boolean containsValue(Object value) ：如果此映射将一个或多个键映射到指定值，则返回 true。
38 *
39 * boolean isEmpty() ：如果此映射未包含键-值映射关系，则返回 true。
40 *
41 * 4、长度功能
42 * int size() ：返回此映射中的键-值映射关系数。
43 *
44 */
45 Map<String, String> map = new HashMap<>();
46
47 System.out.println("map:" + map); // map:{}
48
49 // 1、添加功能
50 // 如果把Map的键值对理解为夫妻的话，那么其put方法可以认为是返回伴侣的前任
51 // System.out.println("map`s put:" + map.put("高祖", "杨开慧")); // map`s put:null
52 // System.out.println("map`s put:" + map.put("高祖", "贺子珍")); // map`s put:杨开慧
53 // System.out.println("map`s put:" + map.put("高祖", "江青")); // map`s put:贺子珍
54
55 map.put("秦皇", "嬴政");
56 map.put("汉武", "刘彻");
57 map.put("唐宗", "李世民");
58 map.put("宋祖", "赵匡胤");
59 map.put("一代天骄", "成吉思汗");
60 // 键值对映射关系中，键相同的，通过put添加后显示的是最后的那个键值对或者说是最新的那个键值对
61 map.put("一代天骄", "蒋中正");
62
63 System.out.println("map:" + map); // map:{汉武=刘彻, 宋祖=赵匡胤, 一代天骄=蒋中正, 唐宗=李世民, 秦皇=嬴政}
64
65 System.out.println("----------------------------------------------------");
66
67 // 2、删除功能
68 // map.clear();
69 // System.out.println("map:" + map); // map:{}
70
71 map.remove("唐宗");
72 System.out.println("map:" + map); // map:{汉武=刘彻, 宋祖=赵匡胤, 一代天骄=蒋中正, 秦皇=嬴政}
73
74 System.out.println("map`s remove:" + map.remove("宋祖")); // map`s remove:赵匡胤
75 System.out.println("map:" + map); // map:{汉武=刘彻, 一代天骄=蒋中正, 秦皇=嬴政}
76
77 System.out.println("map`s remove:" + map.remove("西楚霸王")); // map`s remove:null
78
79 System.out.println("----------------------------------------------------");
80
81 // 3、判断功能
82 System.out.println("map`s containsKey:" + map.containsKey("秦皇")); // map`s containsKey:true
83 System.out.println("map`s containsKey:" + map.containsKey("西楚霸王")); // map`s containsKey:false
84
85 System.out.println("map`s containsValue:" + map.containsValue("刘彻")); // map`s containsValue:true
86 System.out.println("map`s containsValue:" + map.containsValue("刘秀")); // map`s containsValue:false
87
88 map.clear();
89 System.out.println("map`s isEmpty:" + map.isEmpty()); // map`s isEmpty:true
90
91 // 4、长度功能
92 System.out.println("map`s size:" + map.size()); // map`s size:0
93 }
94 }
1 package cn.temptation;
2
3 import java.util.Collection;
4 import java.util.HashMap;
5 import java.util.Map;
6 import java.util.Set;
7
8 public class Sample02 {
9 public static void main(String[] args) {
10 /*
11 * Map<K, V>接口的常用成员方法：
12 * 1、获取功能
13 * V get(Object key) ：返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
14 * Set<K> keySet() ：返回此映射中包含的键的 Set 视图。
15 * Collection<V> values() ：返回此映射中包含的值的 Collection 视图。
16 */
17 Map<String, String> map = new HashMap<>();
18
19 map.put("休斯敦", "火箭");
20 map.put("金州", "勇士");
21 map.put("洛杉矶", "湖人");
22
23 System.out.println(map.get("休斯敦")); // 火箭
24 System.out.println(map.get("金州")); // 勇士
25 System.out.println(map.get("洛杉矶")); // 湖人
26
27 System.out.println("-------------------------------");
28
29 // key不能重复
30 // 键值对映射关系中，键相同的，通过put添加后显示的是最后的那个键值对或者说是最新的那个键值对
31 map.put("西雅图", "超音速");
32 map.put("西雅图", "不眠夜");
33
34 Set<String> set = map.keySet();
35
36 for (String item : set) {
37 System.out.println(item);
38 }
39
40 System.out.println("-------------------------------");
41
42 // value可以重复
43 map.put("夏洛特", "黄蜂");
44 map.put("新奥尔良", "黄蜂");
45
46 Collection<String> collection = map.values();
47
48 for (String item : collection) {
49 System.out.println(item);
50 }
51
52 // 注意：取出的值的顺序 和 放入映射的顺序是不一致的，但是取出的值的顺序 和 取出的键的顺序一致
53 }
54 }
1 package cn.temptation;
2
3 import java.util.HashMap;
4 import java.util.Map;
5 import java.util.Map.Entry;
6 import java.util.Set;
7
8 public class Sample03 {
9 public static void main(String[] args) {
10 /*
11 * Map<K, V>接口的常用成员方法：
12 * Set<Map.Entry<K,V>> entrySet() ：返回此映射中包含的映射关系的 Set 视图。
13 *
14 * 接口 Map.Entry<K,V>：映射项（键-值对）。
15 *
16 * Map.Entry<K,V>接口的常用成员方法：
17 * 1、K getKey() ：返回与此项对应的键。
18 * 2、V getValue() ：返回与此项对应的值。
19 */
20 Map<String, String> map = new HashMap<>();
21
22 map.put("德玛西亚之力", "盖伦");
23 map.put("德邦总管", "赵信");
24 map.put("无极剑圣", "易大师");
25
26 // 遍历Map
27
28 // 方法1、通过Map接口的keySet方法、get方法
29 Set<String> keySet = map.keySet();
30 for (String key : keySet) {
31 String value = map.get(key);
32 System.out.println("key:" + key + " <-----> " + "value:" + value);
33 }
34
35 System.out.println("-------------------------------------");
36
37 // 方法2、通过Map接口的entrySet方法、Entry接口的getKey方法、getValue方法（常用写法）
38 Set<Entry<String,String>> set = map.entrySet();
39 for (Entry<String, String> entry : set) {
40 String key = entry.getKey();
41 String value = entry.getValue();
42 System.out.println("key:" + key + " <-----> " + "value:" + value);
43 }
44 }
45 }
1 package cn.temptation;
2
3 import java.util.HashMap;
4 import java.util.Map;
5 import java.util.Map.Entry;
6
7 public class Sample04 {
8 public static void main(String[] args) {
9 /*
10 * 类 HashMap<K,V>：基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。
11 */
12 Map<String, String> map = new HashMap<>();
13
14 map.put("中国", "北京");
15 map.put("美国", "华盛顿");
16 map.put(null, null);
17
18 // 遍历
19 for (Entry<String, String> entry : map.entrySet()) {
20 String key = entry.getKey();
21 String value = entry.getValue();
22 System.out.println("key:" + key + " <-----> " + "value:" + value);
23 }
24 }
25 }
1 package cn.temptation;
2
3 import java.util.HashMap;
4 import java.util.Map;
5 import java.util.Map.Entry;
6
7 public class Sample05 {
8 public static void main(String[] args) {
9 // 需求：在map中存储学生信息（姓名和年龄）及学号，并进行遍历（以学号为key，以学生信息为value）
10 Map<String, Student> map = new HashMap<>();
11
12 // Map中key这个字符串类型设为学号，通过学号确定唯一性，学生信息作为值
13 map.put("9526", new Student("张三", 20));
14 map.put("9527", new Student("李四", 18));
15 map.put("9528", new Student("王五", 22));
16 // 因为key相同，所以覆盖了前面添加进去的Student对象
17 map.put("9526", new Student("赵六", 16));
18
19 System.out.println("map:" + map);
20
21 // 遍历映射
22 for (Entry<String, Student> entry : map.entrySet()) {
23 String id = entry.getKey();
24 Student temp = entry.getValue();
25 System.out.println("学号为：" + id + "，" + temp.toString());
26 }
27 }
28 }
1 package cn.temptation;
2
3 import java.util.Collection;
4 import java.util.HashMap;
5 import java.util.Map;
6 import java.util.Set;
7 import java.util.Map.Entry;
8
9 public class Sample06 {
10 // 成员变量
11 private static Map<Student, String> map = new HashMap<>();
12
13 public static void main(String[] args) {
14 // 需求：在map中存储学生信息（姓名和年龄）及学号，并进行遍历（以学生信息为key，以学号为value）
15 // 问题1：如果我们知道这两个学生对象其实指的是同一个人，该如何处理？
16 // 答：这样学号就不是判断学生的唯一性的标准，而是学生信息是判定学生唯一的依据
17
18 // 问题2：添加学生信息不同的对象，但是学号相同，也加入到map对象中，想避免学号的重复，该如何处理？
19 // 答：考虑制作自动学号的生成方法，并且制作学生信息判断去重的方法
20
21 // 因为map中的数据不同的成员方法都要使用，所以考虑提取出去作为成员变量
22 // Map<Student, String> map = new HashMap<>();
23
24 // Map中key这个字符串类型设为学号，通过学号确定唯一性，学生信息作为值
25 // map.put(new Student("张三", 20), "9526");
26 // map.put(new Student("李四", 18), "9527");
27 // map.put(new Student("王五", 22), "9528");
28 // map.put(new Student("张三", 20), "9520"); // 重写Studengt对象的hashCode方法和equals后，就不会出现两个张三 20岁的学生对象了
29 // map.put(new Student("赵六", 16), "9527");
30
31 Student student1 = new Student("张三", 20);
32 if (checkStudent(student1)) {
33 map.put(student1, getCurrentID());
34 }
35
36 Student student2 = new Student("李四", 18);
37 if (checkStudent(student2)) {
38 map.put(student2, getCurrentID());
39 }
40
41 Student student3 = new Student("王五", 2);
42 if (checkStudent(student3)) {
43 map.put(student3, getCurrentID());
44 }
45
46 Student student4 = new Student("赵六", 16);
47 if (checkStudent(student4)) {
48 map.put(student4, getCurrentID());
49 }
50
51 Student student5 = new Student("张三", 20);
52 if (checkStudent(student5)) {
53 map.put(student5, getCurrentID());
54 }
55
56 System.out.println("map:" + map);
57
58 // 遍历映射
59 for (Entry<Student, String> entry : map.entrySet()) {
60 Student temp = entry.getKey();
61 String id = entry.getValue();
62 System.out.println("学号为：" + id + "，" + temp.toString());
63 }
64 }
65
66 // 获取当前可以使用的学号
67 public static String getCurrentID() {
68 String result = "1";
69
70 if (map.size() > 0) {
71
72 // 获取所有的学号，存入Collection对象
73 Collection<String> collection = map.values();
74
75 int max = 0;
76
77 for (String item : collection) {
78 if (Integer.parseInt(item) > max) {
79 max = Integer.parseInt(item);
80 }
81 }
82
83 result = max + 1 + "";
84 }
85
86 return result;
87 }
88
89 // 判断学生信息是否有重复
90 public static boolean checkStudent(Student student) {
91 boolean flag = true;
92
93 // 获取所有的学生信息，存入Set对象
94 Set<Student> keySet = map.keySet();
95
96 for (Student item : keySet) {
97 if (item.equals(student)) {
98 flag = false;
99 break;
100 }
101 }
102
103 return flag;
104 }
105 }
1 package cn.temptation;
2
3 // 学生类
4 public class Student {
5 // 成员变量
6 private String name;
7 private int age;
8
9 // 构造函数
10 public Student() {
11 super();
12 }
13
14 public Student(String name, int age) {
15 super();
16 this.name = name;
17 this.age = age;
18 }
19
20 // 成员方法
21 public String getName() {
22 return name;
23 }
24
25 public void setName(String name) {
26 this.name = name;
27 }
28
29 public int getAge() {
30 return age;
31 }
32
33 public void setAge(int age) {
34 this.age = age;
35 }
36
37 // 为了唯一判断对象，重写hashCode方法和equals方法
38 @Override
39 public int hashCode() {
40 final int prime = 31;
41 int result = 1;
42 result = prime * result + age;
43 result = prime * result + ((name == null) ? 0 : name.hashCode());
44 return result;
45 }
46
47 @Override
48 public boolean equals(Object obj) {
49 if (this == obj)
50 return true;
51 if (obj == null)
52 return false;
53 if (getClass() != obj.getClass())
54 return false;
55 Student other = (Student) obj;
56 if (age != other.age)
57 return false;
58 if (name == null) {
59 if (other.name != null)
60 return false;
61 } else if (!name.equals(other.name))
62 return false;
63 return true;
64 }
65
66 @Override
67 public String toString() {
68 return "学生 [姓名为：" + name + ", 年龄为：" + age + "]";
69 }
70 }
1 package cn.temptation;
2
3 import java.util.LinkedHashMap;
4 import java.util.Map;
5 import java.util.Map.Entry;
6
7 public class Sample07 {
8 public static void main(String[] args) {
9 /*
10 * 类 LinkedHashMap<K,V>：Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序。
11 *
12 * 特点：
13 * 1、由HashMap保证唯一性
14 * 2、由链表保证有序性
15 */
16 Map<String, String> map = new LinkedHashMap<>();
17
18 map.put("无冕之王", "荷兰");
19 map.put("桑巴军团", "巴西");
20 map.put("亚洲三流", "中国");
21
22 for (Entry<String, String> entry : map.entrySet()) {
23 System.out.println("美称：" + entry.getKey() + " <-----> 国家名称：" + entry.getValue());
24 }
25 }
26 }
1 package cn.temptation;
2
3 import java.util.Map;
4 import java.util.Map.Entry;
5 import java.util.Set;
6 import java.util.TreeMap;
7
8 public class Sample08 {
9 public static void main(String[] args) {
10 /*
11 * 类 TreeMap<K,V>：
12 * 基于红黑树（Red-Black tree）的 NavigableMap 实现。
13 * 该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。
14 *
15 * 用法：类比TreeSet
16 */
17 Map<String, String> map = new TreeMap<>();
18
19 map.put("Q", "嬴政");
20 map.put("H", "刘彻");
21 map.put("T", "李世民");
22 map.put("S", "赵匡胤");
23
24 for (Entry<String, String> entry : map.entrySet()) {
25 String key = entry.getKey();
26 String value = entry.getValue();
27 System.out.println(key + " <-----> " + value);
28 }
29
30 System.out.println("------------------------------");
31
32 Set<String> keySet = map.keySet();
33 System.out.println("keyset:" + keySet);
34
35 for (String key : keySet) {
36 String value = map.get(key);
37 System.out.println(key + " <-----> " + value);
38 }
39 }
40 }
1 package cn.temptation;
2
3 import java.util.Comparator;
4 import java.util.Map;
5 import java.util.Map.Entry;
6 import java.util.TreeMap;
7
8 public class Sample09 {
9 public static void main(String[] args) {
10 // 需求：使用TreeMap存储学生信息，姓名和年龄相同的学生只能存储一个，排序规则：先按年龄排序，年龄相同按姓名自然排序
11
12 // 思路：姓名和年龄相同的学生只能存储一个，也就是把学生信息作为键；和TreeSet一样，自定义排序规则：通过实现Comparable接口 或 Comparator接口
13
14 Map<Student, String> map = new TreeMap<>(new Comparator<Student>() {
15 @Override
16 public int compare(Student student1, Student student2) {
17 // 先比较年龄
18 int resultAge = student1.getAge() - student2.getAge();
19
20 // 年龄相同比较姓名
21 int result = (resultAge == 0) ? student1.getName().compareTo(student2.getName()) : resultAge;
22
23 return result;
24 }
25 });
26
27 map.put(new Student("张三", 20), "9526");
28 map.put(new Student("李四", 18), "9527");
29 map.put(new Student("王五", 20), "9528");
30 map.put(new Student("张三", 20), "9529");
31
32 for (Entry<Student, String> entry : map.entrySet()) {
33 Student temp = entry.getKey();
34 String id = entry.getValue();
35 System.out.println("学号为：" + id + "，" + temp.toString());
36 }
37 }
38 }
1 package cn.temptation;
2
3 import java.util.ArrayList;
4 import java.util.LinkedHashMap;
5 import java.util.Map;
6 import java.util.Map.Entry;
7
8 public class Sample10 {
9 public static void main(String[] args) {
10 // 需求：选择合适的容器结构，存储并显示数据
11 // 类别：篮球明星前三名：乔丹、邓肯、科比
12 // 类别：足球明星前五名：梅西、C罗、卡卡、伊布、哈维
13
14 // 思路：容器中可以再放入容器
15
16 // 写法1、使用数组存储（注意：不同数组的索引同步）
17 // 声明类别数组
18 String[] arrCategory = { "篮球", "足球" };
19 // 声明球星数组
20 String[][] arrStar = { { "乔丹", "邓肯", "科比" }, { "梅西", "C罗", "卡卡", "伊布", "哈维" } };
21
22 // 遍历数组
23 for (int i = 0; i < arrCategory.length; i++) {
24 StringBuffer sb = new StringBuffer();
25 sb.append("类别：").append(arrCategory[i]).append("中前").append(arrStar[i].length).append("名：");
26
27 for (int j = 0; j < arrStar[i].length; j++) {
28 sb.append(arrStar[i][j]).append("、");
29 }
30
31 System.out.println(sb.substring(0, sb.length() - 1));
32 }
33
34 System.out.println("--------------------------------------------------------");
35
36 // 写法2、使用集合存储（整体使用Map映射，key存为类别，value存为存放了多个球星名字的ArrayList）
37 Map<String, ArrayList<String>> map = new LinkedHashMap<>();
38
39 ArrayList<String> basketBallList = new ArrayList<>();
40 basketBallList.add("乔丹");
41 basketBallList.add("邓肯");
42 basketBallList.add("科比");
43
44 map.put("篮球", basketBallList);
45
46 ArrayList<String> soccerList = new ArrayList<>();
47 soccerList.add("梅西");
48 soccerList.add("C罗");
49 soccerList.add("卡卡");
50 soccerList.add("伊布");
51 soccerList.add("哈维");
52
53 map.put("足球", soccerList);
54
55 for (Entry<String, ArrayList<String>> entry : map.entrySet()) {
56 StringBuffer sb = new StringBuffer();
57
58 String category = entry.getKey();
59 ArrayList<String> list = entry.getValue();
60
61 sb.append("类别：").append(category).append("中前").append(list.size()).append("名：");
62
63 for (String item : list) {
64 sb.append(item).append("、");
65 }
66
67 System.out.println(sb.substring(0, sb.length() - 1));
68 }
69 }
70 }
1 package cn.temptation;
2
3 import java.util.ArrayList;
4 import java.util.Collection;
5 import java.util.LinkedHashMap;
6 import java.util.Map;
7 import java.util.Map.Entry;
8
9 public class Sample11 {
10 public static void main(String[] args) {
11 // 需求：
12 // 存储并显示2016年NBA东西部决赛
13 // 东部：克利夫兰<----->骑士、明尼苏达<----->森林狼
14 // 西部：休斯敦<----->火箭、金州<----->勇士
15 // 存储并显示2015年NBA东西部决赛
16 // 东部：克利夫兰<----->骑士、亚特兰大<----->老鹰
17 // 西部：洛杉矶<----->湖人、金州<----->勇士
18
19 // 思路：复杂问题分解为若干个简单问题
20
21 Map<String, String> map1 = new LinkedHashMap<>();
22 map1.put("克利夫兰", "骑士");
23 map1.put("明尼苏达", "森林狼");
24
25 Map<String, String> map2 = new LinkedHashMap<>();
26 map2.put("休斯敦", "火箭");
27 map2.put("金州", "勇士");
28
29 Map<String, Map<String, String>> mapArea2016 = new LinkedHashMap<>();
30 mapArea2016.put("东部", map1);
31 mapArea2016.put("西部", map2);
32
33 // 把2016年的数据封装在对象中
34 Record record2016 = new Record();
35 record2016.setYear(2016);
36 record2016.setMapArea(mapArea2016);
37
38 Map<String, String> map3 = new LinkedHashMap<>();
39 map3.put("克利夫兰", "骑士");
40 map3.put("亚特兰大", "老鹰");
41
42 Map<String, String> map4 = new LinkedHashMap<>();
43 map4.put("洛杉矶", "湖人");
44 map4.put("金州", "勇士");
45
46 Map<String, Map<String, String>> mapArea2015 = new LinkedHashMap<>();
47 mapArea2015.put("东部", map3);
48 mapArea2015.put("西部", map4);
49
50 // 把2015年的数据封装在对象中
51 Record record2015 = new Record();
52 record2015.setYear(2015);
53 record2015.setMapArea(mapArea2015);
54
55 // 创建存储数据记录的集合
56 Collection<Record> collectionNBA = new ArrayList<>();
57 collectionNBA.add(record2016);
58 collectionNBA.add(record2015);
59
60 StringBuffer sb = new StringBuffer();
61
62 // 遍历
63 for (Record record : collectionNBA) {
64 sb.append(record.getYear()).append("年NBA东西部决赛：").append("
");
65
66 for (Entry<String, Map<String, String>> entryArea : record.getMapArea().entrySet()) {
67 sb.append(entryArea.getKey()).append("：");
68
69 Map<String, String> mapCity = entryArea.getValue();
70
71 StringBuffer sbTemp = new StringBuffer();
72
73 for (Entry<String, String> entry : mapCity.entrySet()) {
74 sbTemp.append(entry.getKey()).append("<------>").append(entry.getValue()).append("，");
75 }
76
77 sb.append(sbTemp.substring(0, sbTemp.length() - 1));
78 sb.append("
");
79 }
80
81 sb.append("
");
82 }
83
84 System.out.println(sb);
85 }
86 }
1 package cn.temptation;
2
3 import java.util.LinkedHashMap;
4 import java.util.Map;
5
6 /**
7 * 数据记录类
8 */
9 public class Record {
10 // 成员变量
11 // 数据记录年份
12 private int year;
13 // 数据记录内容
14 private Map<String, Map<String, String>> mapArea = new LinkedHashMap<>();
15
16 // 构造函数
17 public Record() {
18 super();
19 }
20
21 public Record(int year, Map<String, Map<String, String>> mapArea) {
22 super();
23 this.year = year;
24 this.mapArea = mapArea;
25 }
26
27 // 成员方法
28 public int getYear() {
29 return year;
30 }
31
32 public void setYear(int year) {
33 this.year = year;
34 }
35
36 public Map<String, Map<String, String>> getMapArea() {
37 return mapArea;
38 }
39
40 public void setMapArea(Map<String, Map<String, String>> mapArea) {
41 this.mapArea = mapArea;
42 }
43
44 @Override
45 public String toString() {
46 return "数据 [年份为：" + year + ", 内容为：" + mapArea + "]";
47 }
48 }
1 package cn.temptation;
2
3 import java.util.LinkedHashMap;
4 import java.util.Map;
5 import java.util.Map.Entry;
6
7 public class Sample12 {
8 public static void main(String[] args) {
9 // 需求：使用集合相关知识统计"javaisgoodisbetterisbestisamazing"中各个字符出现的次数
10 // 显示：字符j：1次、字符a：4次、...
11
12 // 思路：
13 // 1、既然统计的是字符出现的次数，所以把字符串转换为字符数组
14 // 2、创建一个map集合用来存储字符及其出现次数的关系映射，设置key为字符，value为出现次数
15 // 3、遍历字符数组，将得到的字符（key）传递map映射的get方法找到对应出现的次数（value）
16 // A：如果返回值为null，说明map映射中没有该字符及其出现次数的映射关系，那么map中存储下来这个映射关系
17 // B：如果返回值不为null，说明map映射中存在该字符及其出现次数的映射关系，那么将value值+1，再存储下来
18
19 String str = "javaisgoodisbetterisbestisamazing";
20 char[] arr = str.toCharArray();
21 Map<Character, Integer> map = new LinkedHashMap<>();
22
23 // 遍历字符数组
24 for (char item : arr) {
25 // 根据各个字符传入map集合中查找
26 Integer count = map.get(item);
27
28 if (count == null) {
29 // 如果返回值为null，说明map映射中没有该字符及其出现次数的映射关系，那么map中存储下来这个映射关系
30 map.put(item, 1);
31 } else {
32 // 如果返回值不为null，说明map映射中存在该字符及其出现次数的映射关系，那么将value值+1，再存储下来
33 count++;
34 // 注意：具有相同key的键值对，最新的键值对会覆盖之前的键值对
35 map.put(item, count);
36 }
37 }
38
39 // 遍历map集合
40 for (Entry<Character, Integer> entry : map.entrySet()) {
41 Character key = entry.getKey();
42 Integer value = entry.getValue();
43 System.out.println("字符" + key + "：" + value + "次");
44 }
45 }
46 }
1 package cn.temptation;
2
3 import java.util.ArrayList;
4 import java.util.Collection;
5 import java.util.Collections;
6 import java.util.List;
7
8 public class Sample13 {
9 public static void main(String[] args) {
10 /*
11 * 类 Collections：
12 * 此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。
13 * 它包含在 collection 上操作的多态算法，即“包装器”，包装器返回由指定 collection 支持的新 collection，以及少数其他内容。
14 *
15 * Collections类的常用成员方法：
16 * 1、static <T extends Comparable<? super T>> void sort(List<T> list) ：根据元素的自然顺序 对指定列表按升序进行排序。
17 *
18 * 2、static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key) ：使用二分搜索法搜索指定列表，以获得指定对象。
19 * 返回：如果搜索键包含在列表中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。
20 * 插入点 被定义为将键插入列表的那一点：即第一个大于此键的元素索引；如果列表中的所有元素都小于指定的键，则为 list.size()。
21 * 注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。
22 *
23 * 3、static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll) ：根据元素的自然顺序，返回给定 collection 的最大元素。
24 *
25 * 4、static void reverse(List<?> list) ：反转指定列表中元素的顺序。
26 *
27 * 5、static void shuffle(List<?> list) ：使用默认随机源对指定列表进行置换。
28 *
29 */
30
31 Collection<Integer> collection = new ArrayList<>();
32
33 collection.add(2);
34 collection.add(3);
35 collection.add(5);
36 collection.add(4);
37 collection.add(1);
38
39 System.out.println("初始集合：" + collection); // 初始集合：[2, 3, 5, 4, 1]
40
41 Collections.sort((List<Integer>)collection);
42 System.out.println("使用排序：" + collection); // 使用排序：[1, 2, 3, 4, 5]
43
44 System.out.println("二分查找：" + Collections.binarySearch((List<Integer>)collection, 2)); // 1
45 System.out.println("二分查找：" + Collections.binarySearch((List<Integer>)collection, 0)); // -1
46 System.out.println("二分查找：" + Collections.binarySearch((List<Integer>)collection, 5)); // 4
47
48 System.out.println("最大值：" + Collections.max(collection)); // 5
49
50 Collections.reverse((List<Integer>)collection);
51 System.out.println("使用反转：" + collection); // 使用反转：[5, 4, 3, 2, 1]
52
53 Collections.shuffle((List<Integer>)collection);
54 System.out.println("随机置换：" + collection);
55 }
56 }
1 package cn.temptation;
2
3 import java.util.ArrayList;
4 import java.util.Collection;
5 import java.util.Collections;
6 import java.util.Comparator;
7 import java.util.List;
8
9 public class Sample14 {
10 public static void main(String[] args) {
11 /*
12 * Collections类的常用成员方法：
13 * 1、static <T> void sort(List<T> list, Comparator<? super T> c) ：根据指定比较器产生的顺序对指定列表进行排序。
14 */
15 Collection<Student> collection = new ArrayList<>();
16
17 collection.add(new Student("张三", 20));
18 collection.add(new Student("李四", 18));
19 collection.add(new Student("王五", 22));
20 collection.add(new Student("张飞", 20));
21
22 // 语法错误：The method sort(List<T>) in the type Collections is not applicable for the arguments (List<Student>)
23 // Collections.sort((List<Student>)collection);
24
25 Collections.sort((List<Student>)collection, new Comparator<Student>() {
26 @Override
27 public int compare(Student student1, Student student2) {
28 // 先比较年龄
29 int resultAge = student1.getAge() - student2.getAge();
30
31 // 年龄相同再比较姓名
32 int result = (resultAge == 0) ? student1.getName().compareTo(student2.getName()) : resultAge;
33
34 return result;
35 }
36 });
37
38 // 遍历
39 for (Student item : collection) {
40 System.out.println(item);
41 }
42 }
43 }
1 package cn.temptation;
2
3 import java.util.ArrayList;
4 import java.util.Collection;
5 import java.util.Collections;
6 import java.util.List;
7
8 public class Sample15 {
9 public static void main(String[] args) {
10 // 需求：使用所学集合知识，模拟一副牌（54张）的洗牌、发牌（按照规则制作即可，规则选用一副牌斗地主）和看牌（无序）
11 // 牌：A、2、3、4、5、6、7、8、9、10、J、Q、K、BlackJoker、RedJoker
12 // 花色：♥ ◆ ♠ ♣
13
14 // 思路：
15 // 1、创建出一副牌54张（4种花色每种13张，还有大王小王）
16 // 2、把牌放入一个容器中
17 // 3、洗牌（考虑使用集合工具类Collections的shuffle方法）
18 // 4、发牌
19 // 5、看牌
20
21 // 1、创建出一副牌54张（4种花色每种13张，还有大王小王）
22 // 创建花色集合
23 Collection<String> colors = new ArrayList<>();
24 colors.add("♥");
25 colors.add("◆");
26 colors.add("♠");
27 colors.add("♣");
28
29 // 创建数字集合
30 Collection<String> numbers = new ArrayList<>();
31 numbers.add("A");
32 for (int i = 2; i <= 10; i++) {
33 numbers.add(String.valueOf(i));
34 }
35 numbers.add("J");
36 numbers.add("Q");
37 numbers.add("K");
38
39 // 2、把牌放入一个容器中
40 Collection<String> poker = new ArrayList<>();
41
42 for (String color : colors) {
43 for (String number : numbers) {
44 poker.add(color.concat(number));
45 }
46 }
47
48 poker.add("BlackJoker");
49 poker.add("RedJoker");
50
51 // System.out.println("一副牌：" + poker);
52
53 // 3、洗牌（考虑使用集合工具类Collections的shuffle方法）
54 Collections.shuffle((List<String>)poker);
55
56 // System.out.println("洗一副牌：" + poker);
57
58 // 4、发牌
59 // 声明剩余底牌数量
60 int remain = 3;
61 // 声明三个玩家对象和一个底牌对象
62 Collection<String> player1 = new ArrayList<>();
63 Collection<String> player2 = new ArrayList<>();
64 Collection<String> player3 = new ArrayList<>();
65 Collection<String> last = new ArrayList<>();
66
67 for (int i = 0; i < poker.size(); i++) {
68 if (i >= poker.size() - remain) { // 留下底牌
69 last.add(((List<String>)poker).get(i));
70 } else if (i % 3 == 0) { // 给第一个玩家发牌
71 player1.add(((List<String>)poker).get(i));
72 } else if (i % 3 == 1) { // 给第二个玩家发牌
73 player2.add(((List<String>)poker).get(i));
74 } else if (i % 3 == 2) { // 给第三个玩家发牌
75 player3.add(((List<String>)poker).get(i));
76 }
77 }
78
79 // 5、看牌
80 lookPoker("玩家1", player1);
81 lookPoker("玩家2", player2);
82 lookPoker("玩家3", player3);
83 lookPoker("底牌", last);
84 }
85
86 /**
87 * 看牌方法
88 * @param name 玩家名
89 * @param collection 手牌集合
90 */
91 public static void lookPoker(String name, Collection<String> collection) {
92 System.out.println(name + "的手牌是：");
93 for (String item : collection) {
94 System.out.print(item + " ");
95 }
96 // 换行
97 System.out.println();
98 }
99 }
1 package cn.temptation;
2
3 import java.util.ArrayList;
4 import java.util.Collection;
5 import java.util.Collections;
6 import java.util.Comparator;
7 import java.util.List;
8 import java.util.Set;
9 import java.util.TreeSet;
10
11 public class Sample16 {
12 public static void main(String[] args) {
13 // 需求：使用所学集合知识，模拟一副牌（54张）的洗牌、发牌（按照规则制作即可，规则选用一副牌斗地主）和看牌（有序）
14 // 牌：A、2、3、4、5、6、7、8、9、10、J、Q、K、BlackJoker、RedJoker
15 // 花色：♥ ◆ ♠ ♣
16 // 顺序规则：牌的规则：3 < 4 < 5 < ... < 10 < J < Q < K < A < 2 < BlackJoker < RedJoker
17 // 花色的规则（牌相同时）♥ ♠ ♣ ◆
18
19 // 思路1：
20 // 在发牌时，通过比较器的使用，直接按规则排列玩家手中牌和底牌
21
22 // 1、创建出一副牌54张（4种花色每种13张，还有大王小王）
23 // 创建花色集合
24 Collection<String> colors = new ArrayList<>();
25 colors.add("♥");
26 colors.add("◆");
27 colors.add("♠");
28 colors.add("♣");
29
30 // 创建数字集合
31 Collection<String> numbers = new ArrayList<>();
32 numbers.add("A");
33 for (int i = 2; i <= 10; i++) {
34 numbers.add(String.valueOf(i));
35 }
36 numbers.add("J");
37 numbers.add("Q");
38 numbers.add("K");
39
40 // 2、把牌放入一个容器中
41 Collection<Card> poker = new ArrayList<>();
42
43 for (String color : colors) {
44 for (String number : numbers) {
45 Card temp = new Card();
46 temp.setColor(color);
47 temp.setNumber(number);
48
49 poker.add(temp);
50 }
51 }
52
53 poker.add(new Card("", "BlackJoker"));
54 poker.add(new Card("", "RedJoker"));
55
56 // System.out.println("一副牌：" + poker);
57
58 // 3、洗牌（考虑使用集合工具类Collections的shuffle方法）
59 Collections.shuffle((List<Card>)poker);
60
61 // System.out.println("洗一副牌：" + poker);
62
63 // 4、发牌
64 // 声明剩余底牌数量
65 int remain = 3;
66
67 // 声明三个玩家对象和一个底牌对象
68 Comparator<Card> comparator = new CardComparator();
69
70 Set<Card> player1 = new TreeSet<>(comparator);
71 Set<Card> player2 = new TreeSet<>(comparator);
72 Set<Card> player3 = new TreeSet<>(comparator);
73 Set<Card> last = new TreeSet<>(comparator);
74
75 for (int i = 0; i < poker.size(); i++) {
76 if (i >= poker.size() - remain) { // 留下底牌
77 last.add(((List<Card>)poker).get(i));
78 } else if (i % 3 == 0) { // 给第一个玩家发牌
79 player1.add(((List<Card>)poker).get(i));
80 } else if (i % 3 == 1) { // 给第二个玩家发牌
81 player2.add(((List<Card>)poker).get(i));
82 } else if (i % 3 == 2) { // 给第三个玩家发牌
83 player3.add(((List<Card>)poker).get(i));
84 }
85 }
86
87 // 5、看牌
88 lookPoker("玩家1", player1);
89 lookPoker("玩家2", player2);
90 lookPoker("玩家3", player3);
91 lookPoker("底牌", last);
92 }
93
94 /**
95 * 看牌方法
96 * @param name 玩家名
97 * @param collection 手牌集合
98 */
99 public static void lookPoker(String name, Set<Card> collection) {
100 System.out.println(name + "的手牌是：");
101 for (Card item : collection) {
102 System.out.print(item + " ");
103 }
104 // 换行
105 System.out.println();
106 }
107 }
1 package cn.temptation;
2
3 /**
4 * 牌类
5 */
6 public class Card {
7 // 成员变量
8 // 花色
9 private String color;
10 // 数字
11 private String number;
12
13 // 构造函数
14 public Card() {
15 super();
16 }
17
18 public Card(String color, String number) {
19 super();
20 this.color = color;
21 this.number = number;
22 }
23
24 // 成员方法
25 public String getColor() {
26 return color;
27 }
28
29 public void setColor(String color) {
30 this.color = color;
31 }
32
33 public String getNumber() {
34 return number;
35 }
36
37 public void setNumber(String number) {
38 this.number = number;
39 }
40
41 @Override
42 public String toString() {
43 return color + number;
44 }
45 }
1 package cn.temptation;
2
3 import java.util.Comparator;
4
5 /**
6 * 牌的比较器
7 */
8 public class CardComparator implements Comparator<Card> {
9 @Override
10 public int compare(Card card1, Card card2) {
11 // 首先比较数字
12 int resultNumber = numberChange(card1.getNumber()) - numberChange(card2.getNumber());
13
14 // 数字相同时，比较花色
15 int result = (resultNumber == 0) ? colorChange(card1.getColor()) - colorChange(card2.getColor()) : resultNumber;
16
17 return result;
18 }
19
20 /**
21 * 手牌数字转换方法
22 * @param number 手牌数字
23 * @return 对应数字
24 */
25 public static int numberChange(String number) {
26 int result = 0;
27
28 switch (number) {
29 case "J":
30 result = 11;
31 break;
32 case "Q":
33 result = 12;
34 break;
35 case "K":
36 result = 13;
37 break;
38 case "A":
39 result = 14;
40 break;
41 case "2":
42 result = 15;
43 break;
44 case "BlackJoker":
45 result = 16;
46 break;
47 case "RedJoker":
48 result = 17;
49 break;
50 default:
51 result = Integer.parseInt(number);
52 break;
53 }
54
55 return result;
56 }
57
58 /**
59 * 手牌花色转换方法
60 * @param color 手牌花色
61 * @return 对应数字
62 */
63 public static int colorChange(String color) {
64 int result = 0;
65
66 switch (color) {
67 case "♥":
68 result = 1;
69 break;
70 case "♠":
71 result = 2;
72 break;
73 case "♣":
74 result = 3;
75 break;
76 case "◆":
77 result = 4;
78 break;
79 default:
80 break;
81 }
82
83 return result;
84 }
85 }
1 package cn.temptation;
2
3 import java.util.ArrayList;
4 import java.util.Collection;
5 import java.util.Collections;
6 import java.util.HashMap;
7 import java.util.List;
8 import java.util.Map;
9 import java.util.Set;
10 import java.util.TreeSet;
11
12 public class Sample17 {
13 public static void main(String[] args) {
14 // 需求：使用所学集合知识，模拟一副牌（54张）的洗牌、发牌（按照规则制作即可，规则选用一副牌斗地主）和看牌（有序）
15 // 牌：A、2、3、4、5、6、7、8、9、10、J、Q、K、BlackJoker、RedJoker
16 // 花色：♥ ◆ ♠ ♣
17 // 顺序规则：牌的规则：3 < 4 < 5 < ... < 10 < J < Q < K < A < 2 < BlackJoker < RedJoker
18 // 花色的规则（牌相同时）♥ ♠ ♣ ◆
19
20 // 思路2：
21 // 在发牌阶段进行排序比较麻烦，可以考虑在创建牌的时候，就把顺序订好，54张牌按照大小和花色有一个数字排序（索引）
22 // 后续操作时，洗牌洗的就是这个数字顺序，看牌时每个人的手牌和底牌都按数字顺序排列就好
23
24 // 1、创建出一副牌54张（4种花色每种13张，还有大王小王），花色顺序和数字顺序都定好
25 // 2、牌不但有纸面内容（花色和数字），还有其索引，所以考虑使用Map存储
26 // 3、洗牌（考虑使用集合工具类Collections的shuffle方法）
27 // 4、发牌（发的也是牌的索引）
28 // 5、看牌
29
30 // 1、创建出一副牌54张（4种花色每种13张，还有大王小王），花色顺序和数字顺序都定好
31 // 创建花色集合
32 Collection<String> colors = new ArrayList<>();
33 colors.add("♥");
34 colors.add("♠");
35 colors.add("♣");
36 colors.add("◆");
37
38 // 创建数字集合
39 Collection<String> numbers = new ArrayList<>();
40 for (int i = 3; i <= 10; i++) {
41 numbers.add(String.valueOf(i));
42 }
43 numbers.add("J");
44 numbers.add("Q");
45 numbers.add("K");
46 numbers.add("A");
47 numbers.add("2");
48
49 // 2、牌不但有纸面内容（花色和数字），还有其索引，所以考虑使用Map存储
50 // 创建存放牌的容器
51 Map<Integer, String> poker = new HashMap<>();
52 // 创建存放牌的索引的容器（伴随着把牌放入Map对象中，索引放入Collection对象中）
53 Collection<Integer> collection = new ArrayList<>();
54 // 声明牌的索引变量
55 int index = 0;
56
57 // 注意：放牌进入map中顺序，先数字再花色
58 for (String number : numbers) {
59 for (String color : colors) {
60 // 把牌放入Map对象中
61 poker.put(index, color.concat(number));
62 // 把牌的索引放入Collection对象中
63 collection.add(index);
64 // 创建一张牌，索引自增
65 index++;
66 }
67 }
68
69 // 创建小王
70 poker.put(index, "BlackJoker");
71 collection.add(index);
72 index++;
73
74 // 创建大王
75 poker.put(index, "RedJoker");
76 collection.add(index);
77 index++;
78
79 // 遍历map
80 // for (Entry<Integer, String> entry : poker.entrySet()) {
81 // System.out.println(entry.getKey() + "<----->" + entry.getValue());
82 // }
83
84 // 3、洗牌（考虑使用集合工具类Collections的shuffle方法，洗的是牌的索引集合）
85 Collections.shuffle((List<Integer>)collection);
86
87 // System.out.println("洗一副牌：" + collection);
88
89 // 4、发牌（发的是牌的索引）
90 // 声明剩余底牌数量
91 int remain = 3;
92
93 Set<Integer> player1 = new TreeSet<>();
94 Set<Integer> player2 = new TreeSet<>();
95 Set<Integer> player3 = new TreeSet<>();
96 Set<Integer> last = new TreeSet<>();
97
98 for (int i = 0; i < poker.size(); i++) {
99 if (i >= poker.size() - remain) { // 留下底牌
100 last.add(((List<Integer>)collection).get(i));
101 } else if (i % 3 == 0) { // 给第一个玩家发牌
102 player1.add(((List<Integer>)collection).get(i));
103 } else if (i % 3 == 1) { // 给第二个玩家发牌
104 player2.add(((List<Integer>)collection).get(i));
105 } else if (i % 3 == 2) { // 给第三个玩家发牌
106 player3.add(((List<Integer>)collection).get(i));
107 }
108 }
109
110 // 5、看牌（根据键值对中的键去map中找值）
111 lookPoker("玩家1", player1, poker);
112 lookPoker("玩家2", player2, poker);
113 lookPoker("玩家3", player3, poker);
114 lookPoker("底牌", last, poker);
115 }
116
117 /**
118 * 看牌方法
119 * @param name 玩家名
120 * @param collection 手牌集合
121 */
122 public static void lookPoker(String name, Set<Integer> collection, Map<Integer, String> map) {
123 System.out.println(name + "的手牌是：");
124
125 for (Integer item : collection) {
126 System.out.print(map.get(item) + " ");
127 }
128
129 // 换行
130 System.out.println();
131 }
132 }
1 package cn.temptation;
2
3 public class Sample18 {
4 public static void main(String[] args) {
5 /*
6 * 集合总结：
7 * Collection接口（单列集合）：
8 * 1、List接口（有序、可重复）：
9 * A、ArrayList：底层实现是数组，查找快速、增删比较慢
10 * B、Vector：向量类，ArrayList是其升级版，底层实现是数组，查找快速、增删比较慢，遍历向量对象可以使用枚举器（Enumeration）
11 * C、LinkedList：底层实现是链表，查找比较慢、增删快速
12 *
13 * 2、Set接口（无序、唯一）：
14 * A、HashSet：底层实现是哈希表、依赖于hashCode()和equals()
15 * B、LinkedHashSet：底层实现是哈希表和链表组成，由哈希表保证元素唯一、由链表保证元素有序
16 * C、TreeSet：支持自然排序和自定义规则排序（实现Comparable接口 或 Comparator接口）
17 *
18 * Map接口（双列集合）：
19 * A、HashMap：底层实现是哈希表、依赖于hashCode()和equals()
20 * B、LinkedHashMap：底层实现是哈希表和链表组成，由哈希表保证元素唯一、由链表保证元素有序
21 * C、TreeMap：支持自然排序和自定义规则排序（实现Comparable接口 或 Comparator接口）
22 *
23 *
24 * 是否需要键值对：
25 * 是：选择Map，键是否需要排序
26 * 是：选择TreeMap
27 * 否：选择HashMap
28 * 否：选择Collection，元素是否需要唯一
29 * 是：选择Set，元素是否需要排序
30 * 是：TreeSet
31 * 否：HashSet
32 * 否：选择List，需要查找快速还是需要增删快速
33 * 查找快速：ArrayList
34 * 增删快速：LinkedList
35 *
36 * 遍历元素：
37 * 1、一般for循环
38 * 2、迭代器（Iterator）或枚举器（Enumeration）
39 * 3、增强型for循环
40 *
41 */
42 }
43 }
