day09【Map、斗地主排序、冒泡排序】

第一章 Map集合

1.1Map概述

Map<K,V>集合的特点: K用来限制键的类型,V用来限制值的类型
         1.Map集合存储元素是以键值对的形式存储,每一个键值对都有键和值
         2.Map集合的键是唯一,值可以重复,如果键重复了,那么值就会被覆盖
         3.根据键取值

Map集合子类:
    - HashMap<K,V>：存储数据采用的哈希表结构，元素的存取顺序不能保证一致。
                    由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

    - LinkedHashMap<K,V>：HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。
               通过链表结构可以保证元素的存取顺序一致；
               通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

    - TreeMap<K,V>：TreeMap集合和Map相比没有特有的功能，底层的数据结构是红黑树；
                可以对元素的键进行排序，排序方式有两种:自然排序和比较器排序

1.2Map的常用方法

Map接口中定义了很多方法，常用的如下：

• public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
• public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
• public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
• public boolean containsKey(Object key):判断该集合中是否有此键
• public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。
• public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。

Map接口的方法演示

public class Test {
    public static void main(String[] args) {
        /*
            Map<K,V>的常用方法:
                - public V put(K key, V value):  把指定的键与指定的值添加到Map集合中。
                - public  int size()  获取集合中键值对的个数(Map集合的大小)
                - public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
                - public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
                - public boolean containsKey(Object key):判断该集合中是否有此键
                - public  boolean containsValue(Object value)  判断该集合中是否有此值

                - public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。
                - public Collection<V> values() 获取Map集合中所有的值，存储到Collection集合中。

                - public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中 所有的 键值对对象 的集合(Set集合)。
                Entry<K, V>: 一种数据类型,表示键值对对象类型
                由于 Entry<K, V> 是Map接口的成员内部接口,所以表示的时候这么写Map.Entry<K,V>
                Entry接口中的方法:
                    K getKey();  获取键值对对象的键
                    V getValue(); 获取键值对对象的值

                键值对:    两个对象
                键值对对象: 一个对象(包装了键值对后的一个对象)
         */
        Map<String, String> map = new HashMap<>();
        // 往集合中添加键值对
        map.put("黄晓明", "杨颖");
        map.put("文章", "马伊琍");
        map.put("谢霆锋", "王菲");
        map.put("李亚鹏", "王菲");

        // public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中 所有的 键值对对象 的集合(Set集合)。
        Set<Map.Entry<String, String>> entrySet = map.entrySet();

        System.out.println(entrySet);
        System.out.println(entrySet.size());
    }

    /*
      - public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。
      - public Collection<V> values() 获取Map集合中所有的值，存储到Collection集合中。
     */
    private static void method02() {
        // 创建Map集合,限制键的类型为String,限制值的类型为String
        Map<String, String> map = new HashMap<>();
        // 往集合中添加键值对
        map.put("黄晓明", "杨颖");
        map.put("文章", "马伊琍");
        map.put("谢霆锋", "王菲");
        map.put("李亚鹏", "王菲");

        //  public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。
        Set<String> keys = map.keySet();
        System.out.println(keys);// [文章, 谢霆锋, 李亚鹏, 黄晓明]

        // public Collection<V> values() 获取Map集合中所有的值，存储到Collection集合中。
        Collection<String> values = map.values();
        System.out.println(values);// [马伊琍, 王菲, 王菲, 杨颖]
    }

    /*
        - public V put(K key, V value):  把指定的键与指定的值添加到Map集合中。
        - public  int size()  获取集合中键值对的个数(Map集合的大小)
        - public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
        - public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
        - public boolean containsKey(Object key):判断该集合中是否有此键
        - public  boolean containsValue(Object value)  判断该集合中是否有此值
     */
    private static void method01() {
        // 创建Map集合,限制键的类型为String,限制值的类型为String
        Map<String, String> map = new HashMap<>();

        // public V put(K key, V value) 把指定的键与指定的值添加到Map集合中。
        map.put("黄晓明","杨颖");
        String value1 = map.put("文章", "马伊琍");// null
        String value2 = map.put("文章", "姚笛");// 马伊琍
        map.put("谢霆锋", "王菲");
        System.out.println("value1:"+value1);
        System.out.println("value2:"+value2);
        System.out.println(map);// {文章=姚笛, 谢霆锋=王菲, 黄晓明=杨颖}

        //  public  int size()  获取集合中键值对的个数(Map集合的大小)
        System.out.println(map.size());// 3

        System.out.println("=================================");
        // public V remove(Object key); 根据指定的键,删除集合中对应的键值对
        String value3 = map.remove("文章");
        System.out.println("value3:"+value3);// 姚笛
        System.out.println(map);// {谢霆锋=王菲, 黄晓明=杨颖}


        // public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
        String value4 = map.get("谢霆锋");
        System.out.println("value4:"+value4);// 王菲

        System.out.println("======================");
        // public boolean containKey(Object key):判断该集合中是否有此键
        System.out.println(map.containsKey("谢霆锋"));// true
        System.out.println(map.containsKey("李亚鹏"));// false

        //  public  boolean containsValue(Object value)  判断该集合中是否有此值
        System.out.println(map.containsValue("王菲"));// true
        System.out.println(map.containsValue("张柏芝"));// false
    }
}

tips:

使用put方法时，若指定的键(key)在集合中没有，则没有这个键对应的值，返回null，并把指定的键值添加到集合中；

若指定的键(key)在集合中存在，则返回值为集合中键对应的值（该值为替换前的值），并把指定键所对应的值，替换成指定的新值。

1.3Map的遍历

方式1:键找值方式

通过元素中的键，获取键所对应的值

分析步骤：

1. 获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键。方法提示:keyset()
2. 遍历键的Set集合，得到每一个键。
3. 根据键，获取键所对应的值。方法提示:get(K key)

public class Demo {
    public static void main(String[] args) {
        // 创建Map集合对象,限制键的类型为String,值的类型为String
        Map<String, String> map = new HashMap<>();
        // 往map集合中添加键值对
        map.put("黄晓明", "杨颖");
        map.put("文章", "马伊琍");
        map.put("谢霆锋", "王菲");

        // 遍历map集合
        // 获取集合中所有的键  Set<K> keySet()方法
        Set<String> keys = map.keySet();
        // 遍历所有的键的集合
        for (String key : keys) {
            // 在循环中,根据键找值 V get(K key)方法
            String value = map.get(key);
            System.out.println("键:"+key+",值:"+value);
        }
    }
}

方式2:键值对方式

Entry<K,V>接口:简称Entry项,表示键值对对象,用来封装Map集合中的键值对
Entry<K,V>接口:是Map接口中的内部接口,在外部使用的时候是这样表示: Map.Entry<K,V>

Map集合中提供了一个方法来获取所有键值对对象:
            public Set<Map.Entry<K,V>> entrySet()

根据键值对对对象获取键和值:
            - public K getKey()：获取Entry对象中的键。
            - public V getValue()：获取Entry对象中的值。

Map遍历方式二:根据键值对对象的方式
            1.获取集合中所有键值对对象，以Set集合形式返回。  Set<Map.Entry<K,V>> entrySet()
            2.遍历所有键值对对象的集合，得到每一个键值对(Entry)对象。
            3.在循环中,可以使用键值对对对象获取键和值   getKey()和getValue()

public class Demo {
    public static void main(String[] args) {
        // 创建Map集合对象,限制键的类型为String,值的类型为String
        Map<String, String> map = new HashMap<>();
        // 往map集合中添加键值对
        map.put("黄晓明", "杨颖");
        map.put("文章", "马伊琍");
        map.put("谢霆锋", "王菲");

        // 获取集合中所有键值对对象  Set<Map.Entry<K,V>> entrySet()
        Set<Map.Entry<String, String>> entrySet = map.entrySet();

        // 遍历所有键值对对象的集合
        for (Map.Entry<String, String> entry : entrySet) {
            // 在循环中,可以使用键值对对对象获取键和值   getKey()和getValue()
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println("键:"+key+",值:"+value);
        }
    }
}

1.4 HashMap存储自定义类型

练习：每位学生（姓名，年龄）都有自己的家庭住址。那么，既然有对应关系，则将学生对象和家庭住址存储到map集合中。学生作为键, 家庭住址作为值。

注意，学生姓名相同并且年龄相同视为同一名学生。

编写学生类：

public class Student {
    /**
     * 姓名
     */
    public String name;
    /**
     * 年龄
     */
    public int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

编写测试类：

public class Demo {
    public static void main(String[] args) {
        // 创建Map集合,指定键的类型为Student,值的类型为String
        HashMap<Student,String> map = new HashMap<>();

        // 创建多个学生对象
        Student stu1 = new Student("张三", 18);
        Student stu2 = new Student("李四", 38);
        Student stu3 = new Student("王五", 28);
        Student stu4 = new Student("张三", 18);

        // 把学生对象作为键,家庭地址作为值,存储到map集合中
        map.put(stu1,"北京");
        map.put(stu2,"上海");
        map.put(stu3,"深圳");
        map.put(stu4,"广州");

        // 打印map集合
        System.out.println(map);
        System.out.println(map.size());// 3
    }
}

• 当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须复写对象的hashCode和equals方法(如果忘记，请回顾HashSet存放自定义对象)。
• 如果要保证map中存放的key和取出的顺序一致，可以使用java.util.LinkedHashMap集合来存放。

1.5LinkedHashMap介绍

• 通过链表结构可以保证元素的存取顺序一致；
• 通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

public class Test {
    public static void main(String[] args) {
        /*
            LinkedHashMap介绍:
                 LinkedHashMap集合(类): 元素无索引,键唯一,键值对元素存取有序
                                 存储数据采用的是哈希表+链表结构
                                 由哈希表保证键唯一,由链表保证键值对元素存取有序
                                  如果键是自定义类型的类,为了保证键唯一,就得重写hashCode()和equals()方法
         */
        // 创建LinkedHashMap集合,限制键的类型为String类型,限制值的类型为String类型
        LinkedHashMap<String, String> map = new LinkedHashMap<>();
        //HashMap<String, String> map = new HashMap<>();

        // 往集合中添加键值对
        map.put("黄晓明", "杨颖");
        map.put("文章", "马伊琍");
        map.put("谢霆锋", "王菲");
        map.put("李亚鹏", "王菲");
        map.put("文章", "姚笛");

        // 打印集合
        System.out.println(map);
    }
}

1.6TreeMap集合

TreeMap介绍

TreeMap集合和Map相比没有特有的功能，底层的数据结构是红黑树；可以对元素的**键进行排序，排序方式有两种:自然排序和比较器排序；到时使用的是哪种排序，取决于我们在创建对象的时候所使用的构造方法；

构造方法

public TreeMap()									使用自然排序
public TreeMap(Comparator<? super K> comparator) 	   通过比较器指定规则排序

案例演示

public class Test {
    public static void main(String[] args) {
        /*
            TreeMap集合:
                TreeMap集合(类):元素无索引,键唯一,键值对元素根据键排序
                                   存储数据采用的是红黑树结构,由红黑树结构保证键唯一
                构造方法:
                    TreeMap(); 按照键的默认排序规则对键值对进行排序
                            要求: 集合中键所属的类要实现Comparable接口,重写compareTo方法,在该方法中写好默认的排序规则
                    TreeMap(Comparator<? super K> comparator):按照键的指定排序规则对键值对进行排序

               键为自定义类型的类,课后自己去玩玩
         */
        // 按照键的默认规则排序:
        // 创建TreeMap集合,限制键的类型为Integer,限制值的类型为String
        TreeMap<Integer, String> map = new TreeMap<>();

        // 往集合中添加键值对
        map.put(300, "黄晓明");
        map.put(100, "刘德华");
        map.put(200, "黎明");
        map.put(500, "张学友");
        map.put(400, "郭富城");
        // 打印集合
        System.out.println(map);// {100=刘德华, 200=黎明, 300=黄晓明, 400=郭富城, 500=张学友}

        System.out.println("+++++++++++++++++++++++++++++++++");
        // 按照键的指定规则排序:
        // 创建TreeMap集合,限制键的类型为Integer,限制值的类型为String
        TreeMap<Integer, String> map2 = new TreeMap<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                // 指定规则: 前减后 升序  后减前 降序
                return o2 - o1;
            }
        });

        // 往集合中添加键值对
        map2.put(300, "黄晓明");
        map2.put(100, "刘德华");
        map2.put(200, "黎明");
        map2.put(500, "张学友");
        map2.put(400, "郭富城");

        System.out.println(map2);// {500=张学友, 400=郭富城, 300=黄晓明, 200=黎明, 100=刘德华}
    }
}

1.7Map集合练习

• 需求

• 输入一个字符串中每个字符出现次数。

• 分析

• 获取一个字符串对象

• 创建一个Map集合，键代表字符，值代表次数。

• 遍历字符串得到每个字符。

• 判断Map中是否有该键。

• 如果没有，第一次出现，存储次数为1；如果有，则说明已经出现过，获取到对应的值进行++，再次存储。

• 打印最终结果

实现

• 方法介绍

public boolean containKey(Object key):判断该集合中是否有此键。

代码：

public class Test {
    public static void main(String[] args) {
        /*
            Map集合练习:
                需求:输入一个字符串中每个字符出现次
         */
       // 分析:
       // 1.创建Map集合,限制键的类型为Character,值的类型为Integer
        Map<Character, Integer> map = new HashMap<>();

       // 2.创建Scanner对象
        Scanner sc = new Scanner(System.in);

       // 3.获取键盘录入的字符串
        System.out.println("请输入一个字符串:");
        String str = sc.nextLine();

        // 4.遍历字符串的每一个字符
        for (int i = 0; i < str.length(); i++) {
           // 5.在循环中,获取字符串的字符,该字符作为map集合的键
            char cKey = str.charAt(i);

            // 6.在循环中,判断遍历出来的字符在map集合中是否存在该键
            boolean flag = map.containsKey(cKey);

            // 7.在循环中,如果不存在,字符作为键,值为1,存储到map集合中
           // 8.在循环中,如果存在,获取该字符键对应的值,进行+1后作为新的值
           //         然后在重新存储到集合中
            if (flag == false){
                map.put(cKey,1);
            }else{
                Integer oldValue = map.get(cKey);// 获取该字符键对应的值
                Integer newValue = oldValue + 1;// +1
                map.put(cKey,newValue);
            }
        }
       // 9.最后打印map集合
        System.out.println(map);
    }
}

第二章 集合的嵌套

2.1集合的嵌套

List嵌套List

public class Test1 {
    public static void main(String[] args) {
        /*
            集合的嵌套:
                - List嵌套List
                - List嵌套Map
                - Map嵌套Map
            结论:任何集合内部都可以存储其它任何集合
         */
        //  List嵌套List
        // 创建一个List集合,限制元素类型为String
        List<String> list1 = new ArrayList<>();

        // 往集合中添加元素
        list1.add("王宝强");
        list1.add("贾乃亮");
        list1.add("陈羽凡");

        // 创建一个List集合,限制元素类型为String
        List<String> list2 = new ArrayList<>();

        // 往集合中添加元素
        list2.add("马蓉");
        list2.add("李小璐");
        list2.add("白百何");

        // 创建一个List集合,限制元素类型为List集合 (List集合中的元素是List集合)
        List<List<String>> list = new ArrayList<>();
        list.add(list1);
        list.add(list2);

        // 遍历
        for (List<String> e : list) {
            for (String name : e) {
                System.out.println(name);
            }
            System.out.println("=============");
        }

        System.out.println(list);
    }
}

List嵌套Map

public class Test2 {
    public static void main(String[] args) {
        /*
            List嵌套Map:

         */
        // 创建Map集合对象
        Map<String,String> map1 = new HashMap<>();
        map1.put("it001","迪丽热巴");
        map1.put("it002","古力娜扎");

        // 创建Map集合对象
        Map<String,String> map2 = new HashMap<>();
        map2.put("heima001","蔡徐坤");
        map2.put("heima002","李易峰");

        // 创建List集合,用来存储以上2个map集合
        List<Map<String,String>> list = new ArrayList<>();
        list.add(map1);
        list.add(map2);

        System.out.println(list.size()); // 2

        for (Map<String, String> map : list) {
            // 遍历获取出来的map集合对象
            Set<String> keys = map.keySet();// 获取map集合所有的键
            // 根据键找值
            for (String key : keys) {
                System.out.println(key + ","+ map.get(key));
            }
        }

    }
}

Map嵌套Map

public class Test3 {
    public static void main(String[] args) {
        /*
            Map嵌套Map:

         */
        // 创建Map集合对象
        Map<String,String> map1 = new HashMap<>();
        map1.put("it001","迪丽热巴");
        map1.put("it002","古力娜扎");

        // 创建Map集合对象
        Map<String,String> map2 = new HashMap<>();
        map2.put("heima001","蔡徐坤");
        map2.put("heima002","李易峰");

        // 创建Map集合,把以上2个Map集合作为值存储到这个map集合中
        Map<String, Map<String, String>> map = new HashMap<>();

        map.put("传智博客",map1);
        map.put("黑马程序员",map2);

        System.out.println(map.size());// 2

        // 获取map集合中的所有键
        Set<String> keys = map.keySet();
        // 遍历所有的键
        for (String key : keys) {
            // 根据键找值
            Map<String, String> value = map.get(key);
            // 遍历value这个Map集合
            Set<String> keySet = value.keySet();
            for (String k : keySet) {
                String v = value.get(k);
                System.out.println(k+","+v);
            }
        }
    }
}

第三章 模拟斗地主洗牌发牌

需求

按照斗地主的规则，完成洗牌发牌的动作。

具体规则：

1. 组装54张扑克牌
2. 54张牌顺序打乱
3. 三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。
4. 查看三人各自手中的牌（按照牌的大小排序）、底牌

规则：手中扑克牌从大到小的摆放顺序：大王,小王,2,A,K,Q,J,10,9,8,7,6,5,4,3

分析

1.准备牌：

完成数字与纸牌的映射关系：

使用双列Map(HashMap)集合，完成一个数字与字符串纸牌的对应关系(相当于一个字典)。

2.洗牌：

通过数字完成洗牌发牌

3.发牌：

将每个人以及底牌设计为ArrayList,将最后3张牌直接存放于底牌，剩余牌通过对3取模依次发牌。

存放的过程中要求数字大小与斗地主规则的大小对应。

将代表不同纸牌的数字分配给不同的玩家与底牌。

4.看牌：

通过Map集合找到对应字符展示。

通过查询纸牌与数字的对应关系，由数字转成纸牌字符串再进行展示。

实现

package com.itheima04;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;

public class Test {
    public static void main(String[] args) {
        /*
            模拟斗地主洗牌发牌:
            需求
                按照斗地主的规则，完成洗牌发牌的动作。
                具体规则：
                    1. 组装54张扑克牌
                    2. 54张牌顺序打乱
                    3. 三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。
                    4. 查看三人各自手中的牌（按照牌的大小排序）、底牌
                    规则：手中扑克牌从大到小的摆放顺序：大王,小王,2,A,K,Q,J,10,9,8,7,6,5,4,3
         */
        // 造牌
        // 1.创建Map集合对象,限制键的类型为Integer,值的类型为String
        HashMap<Integer, String> pokeBox = new HashMap<>();
        // 2.创建一个List集合,表示花色集合,
        ArrayList<String> colors = new ArrayList<>();
        // 3.创建一个List集合,表示牌面值集合
        ArrayList<String> numbers = new ArrayList<>();

        // 4.往花色集合中存储4个花色
        Collections.addAll(colors, "♥", "♦", "♠", "♣");
        // 5.往牌面值集合中存储13个牌面值
        Collections.addAll(numbers, "2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3");

        // 6.定义一个int类型的变量,表示牌的编号,初始值为0
        int id = 0;
        // 7.往map集合中添加大王,编号为0,添加完后编号自增1
        pokeBox.put(id++, "大王");

        // 8.往map集合中添加小王,编号为1,添加完后编号自增1
        pokeBox.put(id++, "小王");

        // 9.牌面值的集合和花色集合循环嵌套遍历,注意牌面值集合作为外层循环,花色集合作为内层循环
        for (String number : numbers) {
            for (String color : colors) {
                // 10.在循环中,遍历出来的牌面值和花色组成一张扑克牌
                String pai = color + number;
                // 11.在循环中,编号作为键,扑克牌作为值存储到map集合中,每存储一张牌后,编号自增1
                pokeBox.put(id++,pai);
            }
        }

        System.out.println(pokeBox.size());
        System.out.println(pokeBox);

        //2.洗牌 :--->洗牌的编号
        //2.1 获取所有牌的编号,返回的是所有编号的Set集合
        Set<Integer> keySet = pokeBox.keySet();

        //2.2 创建ArrayList集合,用来存储所有的牌编号
        ArrayList<Integer> idList = new ArrayList<>();

        //2.3 把keySet集合中存储的所有牌编号,存储到这个新的ArrayList集合中
        idList.addAll(keySet);

        //2.4 使用Collections.shuffle方法对新的ArrayList集合中的元素打乱顺序
        Collections.shuffle(idList);
        System.out.println("打乱顺序后的牌编号:"+idList.size());// 54
        System.out.println("打乱顺序后的牌编号:"+idList);


        // 3.发牌-->发牌的编号--->对牌的编号进行从小到大排序---->再根据排好序的编号去map集合中获取牌
        // 3.1 创建4个List集合,分别用来存储玩家一,玩家二,玩家三,底牌得到的牌编号
        ArrayList<Integer> play1Id = new ArrayList<>();
        ArrayList<Integer> play2Id = new ArrayList<>();
        ArrayList<Integer> play3Id = new ArrayList<>();
        ArrayList<Integer> diPaiId = new ArrayList<>();

        // 3.2 循环把打乱顺序的牌编号,按照规律依次发给玩家一,玩家二,玩家三,底牌
        for (int i = 0; i < idList.size(); i++) {
            // 获取牌编号
            Integer paiId = idList.get(i);
            // 三人交替摸牌
            if (i >= 51){
                diPaiId.add(paiId);
            }else if (i%3==0){
                play1Id.add(paiId);
            }else if (i%3==1){
                play2Id.add(paiId);
            }else if (i%3==2){
                play3Id.add(paiId);
            }
        }

        // 3.3 对获取到的牌编号进行从小到大排序
        Collections.sort(play1Id);
        Collections.sort(play2Id);
        Collections.sort(play3Id);
        Collections.sort(diPaiId);

        // 3.4 根据排好序的牌编号去map集合中获取牌
        // 遍历玩家一的牌编号
        System.out.print("玩家一的牌:");
        for (Integer paiId : play1Id) {// 1,2,3,4,5
            String pai = pokeBox.get(paiId);
            System.out.print(pai+" ");
        }

        System.out.println();

        // 遍历玩家二的牌编号
        System.out.print("玩家二的牌:");
        for (Integer paiId : play2Id) {
            String pai = pokeBox.get(paiId);
            System.out.print(pai+" ");
        }

        System.out.println();

        // 遍历玩家三的牌编号
        System.out.print("玩家三的牌:");
        for (Integer paiId : play3Id) {
            String pai = pokeBox.get(paiId);
            System.out.print(pai+" ");
        }

        System.out.println();

        // 遍历底牌的牌编号
        System.out.print("底牌的牌:");
        for (Integer paiId : diPaiId) {
            String pai = pokeBox.get(paiId);
            System.out.print(pai+" ");
        }
    }
}

第四章 冒泡排序

冒泡排序概述

• 一种排序的方式，对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，依次对所有的数据进行操作，直至所有数据按要求完成排序
• 如果有n个数据进行排序，总共需要比较n-1次
• 每一次比较完毕，下一次的比较就会少一个数据参与

冒泡排序图解

冒泡排序代码实现

/*
    冒泡排序：
        一种排序的方式，对要进行排序的数据中相邻的数据进行两两比较，将较大的数据放在后面，
        依次对所有的数据进行操作，直至所有数据按要求完成排序
 */
public class ArrayDemo {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {7, 6, 5, 4, 3};
        System.out.println("排序前：" + Arrays.toString(arr));

        // 这里减1，是控制每轮比较的次数
        for (int x = 0; x < arr.length - 1; x++) {
            // -1是为了避免索引越界，-x是为了调高比较效率
            for (int i = 0; i < arr.length - 1 - x; i++) {
                if (arr[i] > arr[i + 1]) {
                    int temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
            }
        }
        System.out.println("排序后：" + Arrays.toString(arr));
    }
}

总结

• 能够说出Map集合特点
  以键值对的形式存储数据
  键唯一,值可以重复,如果键重复了就会覆盖
  根据键找值
• 使用Map集合添加方法保存数据
  put(K k,V v);
  常用方法=====>掌握
• 使用”键找值”的方式遍历Map集合
  获取所有的键
  遍历所有的键
  根据键找值
• 使用”键值对”的方式遍历Map集合
  获取所有键值对对象
  遍历所有键值对对象
  使用键值对对象获取键和获取值
• 能够使用HashMap存储自定义键值对的数据
  要求键所属的类重写hashCode和equals方法来保证键唯一
• 能够完成斗地主洗牌发牌案例
  造牌,洗牌,发牌
• 能够完成冒泡排序
  for(int i=0;i<长度-1;i++){
  for(int j=0;j<长度-1-i;j++){
  // 比较 交换
  }
  }

重点练习:
Map集合特点和常用方法,以及子类的使用
集合嵌套–冒泡排序 ---->为了提高大家的编码能力