文章目录

• • 一、Map
  • • 1. 概述
    • 2. 基本功能
    • 3. 遍历
    • 4. 遍历学生对象
    • 5. 集合嵌套
    • 6. 统计字符出现次数
  • 二、Collections
  • • 1. 常用方法
    • 2. 学生对象排序
  • 三、模拟斗地主

一、Map

1. 概述

Interface Map：K 是键的类型，V 是值的类型。
将键映射到值的对象，不能包含重复的键，每个键可以映射到最多一个值。
举例：学生的学号和姓名，学号是键，姓名是值。
tyut001 刘德华
tyut002 张学友
tyut003 成吉思汗

创建 Map 集合的对象：
采用多态的方式，具体的实现类是 HashMap。

//Test.javapackage com.zxe;import java.util.HashMap;
import java.util.Map;public class Test {public static void main(String[] args) {Map map = new HashMap<>();map.put("tyut001", "刘德华");map.put("tyut002", "张学友");map.put("tyut003", "成吉思汗");map.put("tyut003", "程咬金");System.out.println(map);}
}

利用 HashMap 保证了元素的唯一性，键是唯一的，当出现重复的键时，后者会把前者的值替换掉！

2. 基本功能

//打印输出键值对中所有的值package com.zxe;import java.util.Collection;
import java.util.HashMap;
import java.util.Map;public class Test {public static void main(String[] args) {Map map = new HashMap<>();map.put("tyut001", "刘德华");map.put("tyut002", "张学友");map.put("tyut003", "成吉思汗");Collection values = map.values();for (String s : values) {System.out.println(s);}}
}

3. 遍历

（1）方式一

遍历思路：
① 先获取所有键的集合，用 keySet() 方法实现；
② 然后遍历键的集合，获取到每一个键，用增强 for 实现；
③ 根据键全找值，用 get(Object key) 方法实现。

package com.zxe;import java.util.HashMap;
import java.util.Map;
import java.util.Set;public class Test {public static void main(String[] args) {Map map = new HashMap<>();map.put("tyut001", "刘德华");map.put("tyut002", "张学友");map.put("tyut003", "成吉思汗");Set key = map.keySet();for (String k : key) {String value = map.get(k);System.out.println(k + ", " + value);}}
}

（2）方式二

遍历思路：
① 直接获取所有键值对对象的集合，用 entrySet() 方法实现，集合为 Set 型，每一个键值对对象用 Map.Entry 接收；
② 遍历键值对对象的集合，得到每一个键值对对象，用增强 for 实现，得到每一个 Map.Entry；
③ 根据键值对对象获取键和值，用 getKey() 得到键，用 getValue() 得到值。

package com.zxe;import java.util.HashMap;
import java.util.Map;
import java.util.Set;public class Test {public static void main(String[] args) {Map map = new HashMap<>();map.put("tyut001", "刘德华");map.put("tyut002", "张学友");map.put("tyut003", "成吉思汗");Set> entries = map.entrySet();for (Map.Entry entry : entries) {String key = entry.getKey();String value = entry.getValue();System.out.println(key + ", " + value);}}
}

4. 遍历学生对象

需求：创建一个 HashMap 集合，键是学号（String），值是学生对象（Student），存储三个键值对元素，并遍历。

思路：
① 定义学生类；
② 创建 HashMap 集合对象；
③ 创建学生对象；
④ 把学生添加到集合；
⑤ 遍历集合。

//Student.javapackage com.zxe;public class Student {private String name;private int age;private String sex;@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +", sex='" + sex + '\'' +'}';}public Student() {}public Student(String name, int age, String sex) {this.name = name;this.age = age;this.sex = sex;}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 String getSex() {return sex;}public void setSex(String sex) {this.sex = sex;}
}

//Test.javapackage com.zxe;import java.util.HashMap;
import java.util.Map;
import java.util.Set;public class Test {public static void main(String[] args) {Student s1 = new Student("刘德华", 60, "男");Student s2 = new Student("张学娥", 21, "女");Student s3 = new Student("李华", 14, "男");String sno1 = "001";String sno2 = "002";String sno3 = "003";HashMap allstudent = new HashMap<>();allstudent.put(sno1, s1);allstudent.put(sno2, s2);allstudent.put(sno3, s3);Set> entries = allstudent.entrySet();for (Map.Entry entry : entries) {String key = entry.getKey();Student value = entry.getValue();System.out.println(key + ", " + value);}}
}

思考一下，如果我们的键是用户定义的学生对象，值是居住地址，这时候如何保证学生对象成员变量的值不重复的呢？
在学生类中重写两个方法，hashCode() 和 equals()，这两个方法在之前的内容中有讲过，Alt + Insert 快捷键自动生成。

以学生对象 s1 和 s2 为例，HashMap 保证的唯一性是指，该集合中不允许添加两个或更多的 s1，但可以添加一个 s1 和一个 s2，即使 s1 和 s2 中的内容一模一样，但它并不在意二者内容如何；而重写 hashCode() 和 equals() 方法保证的唯一性是指，它不允许两个对象中出现完全相同的内容。所以要想保证真正意义上的唯一性，应同时使用 HashMap 和 hashCode()、equals() 方法！

5. 集合嵌套

//Test.javapackage com.zxe;import java.util.*;public class Test {public static void main(String[] args) {HashMap hm1 = new HashMap<>();hm1.put(1, "孙策");hm1.put(2, "大桥");HashMap hm2 = new HashMap<>();hm2.put(3, "吕布");hm2.put(4, "貂蝉");ArrayList> a = new ArrayList<>();a.add(hm1);a.add(hm2);System.out.println(a);}
}

直接输出，或者也可以用遍历的方式输出：

//方法一
for (HashMap hm : a) {Set> entries = hm.entrySet();for (Map.Entry entry : entries) {System.out.println(entry.getKey() + ", " + entry.getValue());}}//方法二
for (HashMap hm : a) {Set keys = hm.keySet();for (Integer key : keys) {String value = hm.get(key);System.out.println(key + ", " +value);}}

6. 统计字符出现次数

需求：键盘录入一个字符串，要求统计字符串中每个字符串出现的次数。

思路：
① 键盘录入一个字符串；
② 创建 HashMap 集合，键是 Character，值是 Integer；
③ 遍历字符串，得到每一个字符；
④ 拿得到的每一个字符作为键到 HashMap 集合中去找对应的值，看其返回值，返回值为 null 说明该字符在 HashMap 集合中不存在，就把该字符作为键，1 作为值存储，如果返回值不是 null 说明该字符在 HashMap 集合中存在，把该键所对应的值加 1，然后重新存储该键值对；
⑤ 遍历 HashMap 集合，得到键和值，按照要求进行拼接。

//Test.javapackage com.zxe;import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;public class Test {public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.println("请输入一个字符串：");String str = sc.nextLine();HashMap hm = new HashMap<>();for (int i = 0; i < str.length(); i++) {Character c = str.charAt(i);if (hm.containsKey(c)) {Integer newValue = hm.get(c) + 1;hm.put(c, newValue);} else {hm.put(c, 1);}}Set> entries = hm.entrySet();for (Map.Entry entry : entries) {Character letter = entry.getKey();Integer num = entry.getValue();System.out.println(letter + "出现了" + num +"次！");}}
}

二、Collections

1. 常用方法

Collections 是针对集合操作的工具类。

常用方法：
① sort()，将指定的列表按升序排序；
② reverse()，反转指定列表中元素的顺序；
③ shuffle()，使用默认的随机源随机排列指定的列表。

//Test.javapackage com.zxe;import java.util.ArrayList;
import java.util.Collections;
import java.util.List;public class Test {public static void main(String[] args) {List list = new ArrayList<>();list.add(1);list.add(6);list.add(7);list.add(2);list.add(4);list.add(9);Collections.reverse(list);System.out.println("反转：" + list);Collections.sort(list);System.out.println("升序排序：" + list);Collections.shuffle(list);System.out.println("随机排序：" + list);}
}

这是升序排序的方法，如果想要降序排序，完全可以先对集合进行升序排序，然后再反转，就得到了降序集合。

2. 学生对象排序

需求：ArrayList 存储学生对象，使用 Collections 对 ArrayList 进行排序，要求按照年龄从大到小排序，年龄相同时，按照姓名的字母顺序排序。

//Test.javapackage com.zxe;import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;public class Test {public static void main(String[] args) {Student s1 = new Student("zhangliang", 17);Student s2 = new Student("lvbu", 23);Student s3 = new Student("jiangziya", 31);Student s4 = new Student("kuangtie", 23);Student s5 = new Student("sunce", 27);ArrayList stus = new ArrayList<>();stus.add(s1);stus.add(s2);stus.add(s3);stus.add(s4);stus.add(s5);Collections.sort(stus, new Comparator() {@Overridepublic int compare(Student o1, Student o2) {int num = o1.getAge() - o2.getAge();int num2 = num == 0 ? o1.getName().compareTo(o2.getName()) : num;return num2;}});for (Student s : stus) {System.out.println(s.getName() + ", " + s.getAge());}}
}

这里排序的时候 sort() 方法是需要传入两个参数的，第一个就是要排序的集合，第二个需要指定一个比较器，之前我们学过的两种排序方法，自然排序和比较器排序，自然排序需要在学生类里面实现一个接口，这边我们通过比较器的方式来实现排序。

三、模拟斗地主

需求：通过程序实现斗地主过程中的洗牌、发牌和看牌，要求对牌进行排序。

思路：
① 创建 HashMap，键是编号，值是牌；
② 创建 ArrayList，存储编号；
③ 创建花色数组和点数数组；
④ 从 0 开始往 HashMap 里面存储编号，并存储对应的牌，同时往 ArrayList 里面存储编号；
⑤ 洗牌（洗的是编号），用 Collections 的 shuffle() 方法实现；
⑥ 发牌（发的也是编号），为了保证编号是排序的，创建 TreeSet 集合接收；
⑦ 定义方法看牌，遍历 TreeSet 集合，获取编号，到 HashMap 集合去到对应的牌；
⑧ 调用看牌方法。

//Test.javapackage com.zxe;import java.util.*;public class Test {public static void main(String[] args) {HashMap pokers = new HashMap<>();ArrayList indexs = new ArrayList<>();String[] colors = {"♥", "♠", "♦", "♣"};String[] numbers = {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"};String[] kings = {"大王", "小王"};Integer index = 0;for (String number : numbers) {for (String color : colors) {pokers.put(index, color + number);indexs.add(index);index++;}}for (String king : kings) {pokers.put(index, king);indexs.add(index);index++;}Collections.shuffle(indexs);TreeSet indexsOfPlayer1 = new TreeSet<>();TreeSet indexsOfPlayer2 = new TreeSet<>();TreeSet indexsOfPlayer3 = new TreeSet<>();TreeSet indexsRetains = new TreeSet<>();for (int i = 0; i < indexs.size(); i++) {Integer in = indexs.get(i);if (i >= indexs.size() - 3) {indexsRetains.add(in);} else {switch (i % 3) {case 0:indexsOfPlayer1.add(in);break;case 1:indexsOfPlayer2.add(in);break;default:indexsOfPlayer3.add(in);break;}}}showPokers("刘德华", indexsOfPlayer1, pokers);showPokers("张学友", indexsOfPlayer2, pokers);showPokers("程咬金", indexsOfPlayer3, pokers);System.out.println("\n底牌是：");for (Integer i : indexsRetains) {String retain = pokers.get(i);System.out.print(retain + " ");}}public static void showPokers(String name, TreeSet indexsOfPlayer, HashMap pokers) {System.out.println("\n" + name + "的牌：");for (Integer i : indexsOfPlayer) {String poker = pokers.get(i);System.out.print(poker + "  ");}}
}