Java集合进阶（三）

一、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 + "  ");
        }
    }
}