文章目录
- 一、Map
- 1. 概述
- 2. 基本功能
- 3. 遍历
- 4. 遍历学生对象
- 5. 集合嵌套
- 6. 统计字符出现次数
- 二、Collections
- 1. 常用方法
- 2. 学生对象排序
- 三、模拟斗地主
一、Map
1. 概述
Interface Map<K, V>：K 是键的类型，V 是值的类型。
将键映射到值的对象，不能包含重复的键，每个键可以映射到最多一个值。
举例：学生的学号和姓名，学号是键，姓名是值。
tyut001 刘德华
tyut002 张学友
tyut003 成吉思汗
创建 Map 集合的对象：
采用多态的方式，具体的实现类是 HashMap。
//Test.java
package com.zxe;
import java.util.HashMap;
import java.util.Map;
public class Test {
public static void main(String[] args) {
Map<String, String> 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<String, String> map = new HashMap<>();
map.put("tyut001", "刘德华");
map.put("tyut002", "张学友");
map.put("tyut003", "成吉思汗");
Collection<String> 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<String, String> map = new HashMap<>();
map.put("tyut001", "刘德华");
map.put("tyut002", "张学友");
map.put("tyut003", "成吉思汗");
Set<String> key = map.keySet();
for (String k : key) {
String value = map.get(k);
System.out.println(k + ", " + value);
}
}
}
（2）方式二
遍历思路：
① 直接获取所有键值对对象的集合，用 entrySet() 方法实现，集合为 Set 型，每一个键值对对象用 Map.Entry<String, String> 接收；
② 遍历键值对对象的集合，得到每一个键值对对象，用增强 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<String, String> map = new HashMap<>();
map.put("tyut001", "刘德华");
map.put("tyut002", "张学友");
map.put("tyut003", "成吉思汗");
Set<Map.Entry<String, String>> entries = map.entrySet();
for (Map.Entry<String, String> entry : entries) {
String key = entry.getKey();
String value = entry.getValue();
System.out.println(key + ", " + value);
}
}
}
4. 遍历学生对象
需求：创建一个 HashMap 集合，键是学号（String），值是学生对象（Student），存储三个键值对元素，并遍历。
思路：
① 定义学生类；
② 创建 HashMap 集合对象；
③ 创建学生对象；
④ 把学生添加到集合；
⑤ 遍历集合。
//Student.java
package com.zxe;
public class Student {
private String name;
private int age;
private String sex;
@Override
public 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.java
package 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<String, Student> allstudent = new HashMap<>();
allstudent.put(sno1, s1);
allstudent.put(sno2, s2);
allstudent.put(sno3, s3);
Set<Map.Entry<String, Student>> entries = allstudent.entrySet();
for (Map.Entry<String, Student> 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.java
package com.zxe;
import java.util.*;
public class Test {
public static void main(String[] args) {
HashMap<Integer, String> hm1 = new HashMap<>();
hm1.put(1, "孙策");
hm1.put(2, "大桥");
HashMap<Integer, String> hm2 = new HashMap<>();
hm2.put(3, "吕布");
hm2.put(4, "貂蝉");
ArrayList<HashMap<Integer, String>> a = new ArrayList<>();
a.add(hm1);
a.add(hm2);
System.out.println(a);
}
}
直接输出，或者也可以用遍历的方式输出：
//方法一
for (HashMap<Integer, String> hm : a) {
Set<Map.Entry<Integer, String>> entries = hm.entrySet();
for (Map.Entry<Integer, String> entry : entries) {
System.out.println(entry.getKey() + ", " + entry.getValue());
}
}
//方法二
for (HashMap<Integer, String> hm : a) {
Set<Integer> 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.java
package 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<Character, Integer> 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<Map.Entry<Character, Integer>> entries = hm.entrySet();
for (Map.Entry<Character, Integer> entry : entries) {
Character letter = entry.getKey();
Integer num = entry.getValue();
System.out.println(letter + "出现了" + num +"次！");
}
}
}
二、Collections
1. 常用方法
Collections 是针对集合操作的工具类。
常用方法：
① sort()，将指定的列表按升序排序；
② reverse()，反转指定列表中元素的顺序；
③ shuffle()，使用默认的随机源随机排列指定的列表。
//Test.java
package com.zxe;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Test {
public static void main(String[] args) {
List<Integer> 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.java
package 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<Student> stus = new ArrayList<>();
stus.add(s1);
stus.add(s2);
stus.add(s3);
stus.add(s4);
stus.add(s5);
Collections.sort(stus, new Comparator<Student>() {
@Override
public 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.java
package com.zxe;
import java.util.*;
public class Test {
public static void main(String[] args) {
HashMap<Integer, String> pokers = new HashMap<>();
ArrayList<Integer> 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<Integer> indexsOfPlayer1 = new TreeSet<>();
TreeSet<Integer> indexsOfPlayer2 = new TreeSet<>();
TreeSet<Integer> indexsOfPlayer3 = new TreeSet<>();
TreeSet<Integer> 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<Integer> indexsOfPlayer, HashMap<Integer, String> pokers) {
System.out.println("\n" + name + "的牌：");
for (Integer i : indexsOfPlayer) {
String poker = pokers.get(i);
System.out.print(poker + " ");
}
}
}
