18.集合框架（Map集合，HashMap和Hashtable的区别，Collections(集合工具类)，集合练习，模拟斗地主(洗牌,发牌,看牌)）

1.Map集合概述和特点

1.需求:    根据学号获取学生姓名

2.Map接口概述
    查看API可以知道：
    将键映射到值的对象
    一个映射不能包含重复的键
    每个键最多只能映射到一个值
3.Map接口和Collection接口的不同
    Map是双列的,Collection是单列的
    Map的键唯一,Collection的子体系Set是唯一的
    Map集合的数据结构针对键有效，跟值无关;Collection集合的数据结构是针对元素有效

public class MyTest {
    public static void main(String[] args) {
        //A: 需求:	根据学号获取学生姓名
        /*
        键----------值
        s001--------张三
        s002--------李四
        s003---------王五
        s004----------赵六

        对于这种键值映射关系的数据，为了方便操作，Java给我们提供了Map集合来进行存储。
        键值映射关系的数据，一个键只能映射一个值，键相同，值覆盖。
         */

        ArrayList<String> list= new ArrayList<String>();
        list.add("s001--------张三");
        list.add("s002--------李四");
        list.add("s003---------王五");
        list.add("s004----------赵六");

        String s = list.get(0);
        String[] strings = s.split("[-]+");
        System.out.println(strings[0]);
        System.out.println(strings[1]);
        
    }
}

2.Map集合的功能概述

Map集合的功能概述
    a:添加功能 
        V put(K key,V value):添加元素。这个其实还有另一个功能?替换
            如果键是第一次存储，就直接存储元素，返回null
            如果键不是第一次存在，就用值把以前的值替换掉，返回以前的值
    b:删除功能
        void clear():移除所有的键值对元素
        V remove(Object key)：根据键删除键值对元素，并把值返回
    c:判断功能
        boolean containsKey(Object key)：判断集合是否包含指定的键
        boolean containsValue(Object value):判断集合是否包含指定的值
        boolean isEmpty()：判断集合是否为空
    d:获取功能
        Set<Map.Entry<K,V>> entrySet(): 返回一个键值对的Set集合
        V get(Object key):根据键获取值
        Set<K> keySet():获取集合中所有键的集合
        Collection<V> values():获取集合中所有值的集合
    e:长度功能
        int size()：返回集合中的键值对的对数

3.Map集合的基本功能测试

案例演示
    Map集合的基本功能
    
    V put(K key,V value)//键相同 值覆盖  
    V remove(Object key)
    void clear()
    boolean containsKey(Object key)
    boolean containsValue(Object value)
    boolean isEmpty()
    int size()

4.Map集合的获取功能测试

V get(Object key)
    Set<K> keySet()
    Collection<V> values()

put():

public class MyTest2 {
    public static void main(String[] args) {
        // HashMap  基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。
        //   此类不保证映射的顺序，特别是它不保证该顺序恒久不变。线程不安全，效率高
        //一个键，只能映射一个值，键相同，值覆盖
        // HashMap()
        // 构造一个具有默认初始容量(16) 和默认加载因子(0.75) 的空 HashMap。

        HashMap<String, String> hm = new HashMap<>();
        //当第一次存储该键时，返回的是null,当第二次，存储相同的键时，返回的是上一次该键对应的旧值
        String s = hm.put("文章", "马伊琍");
        String s1 = hm.put("文章", "姚笛");

        hm.put("贾乃亮", "李小璐");
        hm.put("王宝强", "马蓉");
        hm.put("大朗", "金莲");

        System.out.println(hm);

        System.out.println(s);
        System.out.println(s1);


    }
}

---

remove():

public class MyTest {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        map.put(100,"张三");
        map.put(200, "王五");
        map.put(200, "赵六");
        map.put(300, "田七");
        map.put(400, "李九");

        System.out.println(map);

        //删除,返回的是你删除的键对应的值
        String remove = map.remove(100);
        System.out.println(remove);
        System.out.println(map);
        //清空集合
        map.clear();
        System.out.println(map);
    }
}

---

判断功能：

public class MyTest2 {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        map.put(100, "张三");
        map.put(200, "王五");
        map.put(200, "赵六");
        map.put(300, "田七");
        map.put(400, "李九");
       // map.clear();
        boolean empty = map.isEmpty();
        System.out.println(empty);
        //判断有没有该键
        boolean b = map.containsKey(100);
        System.out.println(b);
        //判断有没有该值
        boolean b1 = map.containsValue("李九");
        System.out.println(b1);
    }
}

---

获取功能和长度：

public class MyTest3 {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        map.put(100, "张三");
        map.put(200, "王五");
        map.put(200, "赵六");
        map.put(300, "田七");
        map.put(400, "李九");
        //根据键找值
        String s = map.get(100);
        System.out.println(s);

        //获取集合的长度

        int size = map.size();
        System.out.println(size);

        //获取所有的键的集合
        Set<Integer> keys = map.keySet();

        System.out.println(keys);

        //获取所有值的集合
        Collection<String> values = map.values();
        System.out.println(values);

    }
}

5.Map集合的遍历之键找值

1.键找值思路：
    获取所有键的集合
    遍历键的集合，获取到每一个键
    根据键找值
2.案例演示
    Map集合的遍历之键找值

6.Map集合的遍历之键值对对象找键和值

1.键值对对象找键和值思路：
    获取所有键值对对象的集合
    遍历键值对对象的集合，获取到每一个键值对对象
    根据键值对对象找键和值
2.案例演示
    Map集合的遍历之键值对对象找键和值

public class MyTest {
    public static void main(String[] args) {
        HashMap<String, String> hm = new HashMap<>();
        hm.put("文章", "姚笛");   //Node
        hm.put("贾乃亮", "李小璐");
        hm.put("王宝强", "马蓉");
        hm.put("大朗", "金莲");

        //遍历map集合，根据键找值来遍历
        Set<String> keySet = hm.keySet();
        for (String key : keySet) {
            String value = hm.get(key);
            System.out.println(key+"===="+value);
        }

        System.out.println("=================================");

        //遍历方式2：获取键值对，对象的集合
     /*   java.util
        接口 Map.Entry<K, V>
        K getKey ()
        返回与此项对应的键。
        V getValue ()
        返回与此项对应的值。*/

        Set<Map.Entry<String, String>> entries = hm.entrySet();
        for (Map.Entry<String, String> node : entries) {
            String key = node.getKey();
            String value = node.getValue();
            System.out.println(key+"===="+value);
        }

        System.out.println("==========================");
        //方式三
        hm.forEach(new BiConsumer<String, String>() {
            @Override
            public void accept(String key, String value) {
                System.out.println(key + "====" + value);
            }
        });

    }
}

7.HashMap集合键是String值是Student的案例

Student类：

public class Student {
    private String name;
    private int age;

    public Student() {
    }

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

    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;
    }

    @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);
    }

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

---

public class MyTest2 {
    public static void main(String[] args) {
        //所有的双列集合，他的数据结构，只跟键有关，跟值没有关系。
        //HashMap底层数据结构是哈希表。他就能够保证键的唯一性。
        HashMap<String, Student> map = new HashMap<>();
        map.put("s001", new Student("张三", 23));
        map.put("s001", new Student("李四", 24));
        map.put("s002", new Student("王五", 25));
        map.put("s003", new Student("赵六", 26));
        map.put("s004", new Student("田七", 27));
        map.put("s005", new Student("李八", 28));
        map.put("s005", new Student("老沈", 30));

        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            Student student = map.get(key);
            String name = student.getName();
            int age = student.getAge();
            System.out.println(key+"=="+name+":"+age);
        }

        System.out.println("=======================");
        Set<Map.Entry<String, Student>> entries = map.entrySet();
        for (Map.Entry<String, Student> entry : entries) {
            String key = entry.getKey();
            Student student = entry.getValue();
            String name = student.getName();
            int age = student.getAge();
            System.out.println(key + "==" + name + ":" + age);

        }

        System.out.println("===================================");

        map.forEach(new BiConsumer<String, Student>() {
            @Override
            public void accept(String key, Student student) {

                String name = student.getName();
                int age = student.getAge();
                System.out.println(key + "==" + name + ":" + age);

            }
        });


    }
}

8.HashMap集合键是Student值是String的案例

Student类：

public class Student {
    private String name;
    private int age;

    public Student() {
    }

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

    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;
    }

    @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);
    }

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

---

public class MyTest3 {
    public static void main(String[] args) {
        //所有的双列集合，他的数据结构，只跟键有关，跟值没有关系。
        //HashMap底层数据结构是哈希表。他就能够保证键的唯一性,靠键重写hashCode()和equals()方法，如果不重写，则无法保证键的唯一性。
        HashMap<Student, String> map = new HashMap<>();
        map.put(new Student("张三", 23),"s001");
        map.put(new Student("张三", 23), "s001");
        map.put(new Student("李四", 24),"s001");
        map.put(new Student("李四", 24), "s001");
        map.put(new Student("王五", 25),"s002");
        map.put(new Student("赵六", 26),"s003");
        map.put(new Student("田七", 27),"s004");
        map.put(new Student("李八", 28),"s005");
        map.put(new Student("老沈", 30),"s005");

        for (Map.Entry<Student, String> entry : map.entrySet()) {
            Student key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key);
            System.out.println(value);
        }
    }
}

9.LinkedHashMap的概述和使用

1.LinkedHashMap的概述:    Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序
2.:LinkedHashMap的特点： 底层的数据结构是链表和哈希表 元素有序 并且唯一
            元素的有序性由链表数据结构保证 唯一性由 哈希表数据结构保证
            Map集合的数据结构只和键有关

public class MyTest2 {
    public static void main(String[] args) {
        // LinkedHashSet<String> set = new LinkedHashSet<>();
        //     set.add("abc");
        //键的数据结构，链表和哈希表，键唯一，且有序，哈希表保证唯一，链表保证有序
        LinkedHashMap<String, String> map = new LinkedHashMap<>();
        map.put("s001","张三1");
        map.put("s002", "张三3");
        map.put("s003", "张3三");
        map.put("s003", "张三");
        map.put("s004", "张三");

        map.forEach(new BiConsumer<String, String>() {
            @Override
            public void accept(String key, String value) {
                System.out.println(key+"==="+value);
            }
        });

    }
}

10.TreeMap集合键是Integer值是String的案例

1.TreeMap: 键的数据结构是红黑树,可保证键的排序和唯一性  
        排序分为自然排序和比较器排序 
        线程是不安全的效率比较高
2.案例演示:    TreeMap集合键是Integer值是String的案例

TreeMap 键不允许插入null

public class MyTest {
    public static void main(String[] args) {
       // TreeMap: 底层数据结构是二叉树，能够对键进行排序，分为自然排序和比较器排序
        //自然排序：采用空参构造，自然排序对键有要求，要求键要实现Comparable接口 重写 comparaTo方法，根据此方法返回值的正负0来确定键放置的位置
        //比较器排序：采用有参构造，传入 Comparator 重写 根据此方法返回值的正负0来确定键放置的位置

        TreeMap<Integer, String> treeMap = new TreeMap<>();
        treeMap.put(2,"aaa");
        treeMap.put(2, "ccc");
        treeMap.put(0, "bbb");
        treeMap.put(1, "eee");
        treeMap.put(20, "fff");
        treeMap.put(233, "hhhh");


        treeMap.forEach(new BiConsumer<Integer, String>() {
            @Override
            public void accept(Integer key, String value) {
                System.out.println(key+"==="+value);
            }
        });
        
    }
}

11.TreeMap集合键是String值是Student的案例

public class MyTest2 {
    public static void main(String[] args) {
        TreeMap<String, Student> treeMap = new TreeMap<>();
        treeMap.put("s001",new Student("张三",23));
        treeMap.put("s001", new Student("张三", 23));
        treeMap.put("s002", new Student("王五", 25));
        treeMap.put("s003", new Student("赵六", 26));
        treeMap.put("s004", new Student("小明", 2));


        for (Map.Entry<String, Student> entry : treeMap.entrySet()) {
            String key = entry.getKey();
            Student student = entry.getValue();
            System.out.println(key+"=="+student.getName()+":"+student.getAge());
        }
        
    }
}

12.TreeMap集合键是Student值是String的案例

TreeMap集合键是Student值是String的案例
        按照年龄大小进行排序 
        注意键要实现Comparable 接口

自然排序，实现接口并重写方法：

Student类：

public class Student implements Comparable<Student> {
    private String name;
    private int age;

    public Student() {
    }

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

    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;
    }

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

    @Override
    public int compareTo(Student s) {
        int num = this.getAge() - s.getAge();
        int num2=num==0?this.name.compareTo(s.name) : num;

        return num2;
    }
}

---

public class MyTest {
    public static void main(String[] args) {
     //键是Student  值是String
        TreeSet<Student> students = new TreeSet<>();

        students.add(new Student("张三", 23));



        TreeMap<Student, String> treeMap = new TreeMap<>();
        treeMap.put(new Student("张三", 23), "s001");
        treeMap.put(new Student("张三", 23), "s001");
        treeMap.put(new Student("李四", 24), "s002");
        treeMap.put(new Student("王五", 25), "s001");
        treeMap.put(new Student("赵六", 26), "s001");
        treeMap.put(new Student("小明", 27), "s005");
        treeMap.put(new Student("小红", 28), "s001");
        treeMap.put(new Student("小军", 20), "s008");


        treeMap.forEach(new BiConsumer<Student, String>() {
            @Override
            public void accept(Student student, String s) {
                String name = student.getName();
                int age = student.getAge();
                System.out.println(name+":"+age+"=="+s);
            }
        });
    }
}

 比较器排序：

public class MyTest {
    public static void main(String[] args) {
        TreeMap<Student, String> treeMap = new TreeMap<>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num = s1.getAge() - s2.getAge();
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;

                return num2;

            }
        });
        treeMap.put(new Student("张三", 23), "s001");
        treeMap.put(new Student("张三", 23), "s001");
        treeMap.put(new Student("李四", 24), "s002");
        treeMap.put(new Student("王五", 25), "s001");
        treeMap.put(new Student("赵六", 26), "s001");
        treeMap.put(new Student("小明", 27), "s005");
        treeMap.put(new Student("小红", 28), "s001");
        treeMap.put(new Student("小军", 20), "s008");


        treeMap.forEach(new BiConsumer<Student, String>() {
            @Override
            public void accept(Student student, String s) {
                String name = student.getName();
                int age = student.getAge();
                System.out.println(name + ":" + age + "==" + s);
            }
        });
    }

}

13.统计字符串中每个字符出现的次数

需求：统计字符串中每个字符出现的次数
    "aababcabcdabcde",获取字符串中每一个字母出现的次数要求结果:a(5)b(4)c(3)d(2)e(1)

public class MyTest2 {
    public static void main(String[] args) {
        // A:
        // 案例演示:
        // 需求：统计字符串中每个字符出现的次数
        // "aababcabcdabcde", 获取字符串中每一个字母出现的次数要求结果:a(5) b(4) c(3) d(2) e(1)

        /*
        *   a------5
        *   b------4
        *   c-------3
        *   d------2
        *   e-------1
        *
        *   上面的数据是一种键值映射关系的数据，我会想到用Map集合来存储 键是 Character 值是Integer
        *
        *    把数据存储到集合中 变了集合拼串拼接成 a(5) b(4) c(3) d(2) e(1)
        *
        *    难点在于我怎么统计每个键出现的次数。
        *
        *
        *
        * */

        LinkedHashMap<Character, Integer> map = new LinkedHashMap<>();
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一段字符串");
        String str = sc.nextLine();
        //把字符串转换成字符数字
        //aababcabcdabcde
        char[] chars = str.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            char key = chars[i];
            if(!map.containsKey(key)){
                 map.put(key,1);
             }else{
                Integer value = map.get(key);
                value++;
                map.put(key, value); //键相同，值覆盖
            }
        }
        //遍历拼串 a(5) b(4) c(3) d(2) e(1)
        StringBuilder sb = new StringBuilder();
        map.forEach(new BiConsumer<Character, Integer>() {
            @Override
            public void accept(Character key, Integer value) {
                sb.append(key).append("(").append(value).append(")");
            }
        });
        String s = sb.toString();
        System.out.println(s);
    }
}

14.集合嵌套之HashMap嵌套HashMap

集合嵌套之HashMap嵌套HashMap
    
            基础班
​                    张三        20
​                    李四        22
​            就业班
​                    王五        21
​                    赵六        23

public class MyTest {
    public static void main(String[] args) {

     /*
     *
     *
			基础班
​					张三		20
​					李四		22
​			就业班
​					王五		21
​					赵六		23
     *
     *
     * */

        HashMap<String, Integer> jcMap = new HashMap<>();
        jcMap.put("张三",20);
        jcMap.put("李四", 22);

        HashMap<String, Integer> jyMap = new HashMap<>();
        jyMap.put("王五", 21);
        jyMap.put("赵六", 23);

        HashMap<String, HashMap<String, Integer>> maxMap = new HashMap<>();
        maxMap.put("基础班",jcMap);
        maxMap.put("就业班",jyMap);

        //遍历
        Set<String> keySet = maxMap.keySet();
        for (String key : keySet) {
            System.out.println(key);
            HashMap<String, Integer> minMap = maxMap.get(key);
            for (String minKey : minMap.keySet()) {
                Integer minValue = minMap.get(minKey);
                System.out.println("\t"+minKey+"\t\t"+minValue);
            }
            System.out.println();

        }

        System.out.println("==============================");

        for (Map.Entry<String, HashMap<String, Integer>> entry : maxMap.entrySet()) {

            String key = entry.getKey();
            System.out.println(key);
            HashMap<String, Integer> minMap = entry.getValue();
            for (Map.Entry<String, Integer> minNode : minMap.entrySet()) {
                String minKey = minNode.getKey();
                Integer value = minNode.getValue();
                System.out.println("\t"+minKey+"\t\t"+value);
            }
            System.out.println();
        }


        System.out.println("===========================================");

        maxMap.forEach(new BiConsumer<String, HashMap<String, Integer>>() {
            @Override
            public void accept(String key, HashMap<String, Integer> minMap) {
                System.out.println(key);
                minMap.forEach(new BiConsumer<String, Integer>() {
                    @Override
                    public void accept(String key, Integer value) {
                        System.out.println("\t"+key+"\t\t"+value);
                    }
                });
            }
        });
    }
}

15.集合嵌套之HashMap嵌套ArrayList

集合嵌套之HashMap嵌套ArrayList
        
    假设HashMap集合的元素是ArrayList。有3个。
    每一个ArrayList集合的值是字符串。

    三国演义
         吕布
         周瑜
     笑傲江湖
         令狐冲
         林平之
     神雕侠侣
         郭靖
         杨过  

public class MyTest {
    public static void main(String[] args) {
        /*
        *
	三国演义
	 	吕布
	 	周瑜
	 笑傲江湖
	 	令狐冲
	 	林平之
	 神雕侠侣
	 	郭靖
	 	杨过
        *
        *
        * */

        ArrayList<String> sgList = new ArrayList<>();
        sgList.add("吕布");
        sgList.add("周瑜");

        ArrayList<String> xaList = new ArrayList<>();
        xaList.add("令狐冲");
        xaList.add("林平之");


        ArrayList<String> sdList = new ArrayList<>();
        sdList.add("郭靖");
        sdList.add("杨过");


        HashMap<String, ArrayList<String>> maxMap = new HashMap<>();
        maxMap.put("三国演义",sgList);
        maxMap.put("笑傲江湖", xaList);
        maxMap.put("神雕侠侣", sdList);

        //遍历
        maxMap.forEach(new BiConsumer<String, ArrayList<String>>() {
            @Override
            public void accept(String key, ArrayList<String> minList) {
                System.out.println(key);
                minList.forEach(new Consumer<String>() {
                    @Override
                    public void accept(String s) {
                        System.out.println("\t"+s);
                    }
                });
            }
        });
        
    }
}

16.集合嵌套之ArrayList嵌套HashMap

集合嵌套之ArrayList嵌套HashMap
    
    假设ArrayList集合的元素是HashMap。有3个。
    每一个HashMap集合的键和值都是字符串。

     周瑜---小乔
     吕布---貂蝉

     郭靖---黄蓉
     杨过---小龙女

     令狐冲---任盈盈
     林平之---岳灵珊

public class MyTest2 {
    public static void main(String[] args) {
        /*
        周瑜-- - 小乔
        吕布-- - 貂蝉

        郭靖-- - 黄蓉
        杨过-- - 小龙女

        令狐冲-- - 任盈盈
        林平之-- - 岳灵珊

         */

        HashMap<String, String> sgMap = new HashMap<>();
        sgMap.put("周瑜","小乔");
        sgMap.put("吕布", "貂蝉");


        HashMap<String, String> sdMap = new HashMap<>();
        sdMap.put("郭靖", "黄蓉");
        sdMap.put("杨过", "小龙女");


        HashMap<String, String> xaMap = new HashMap<>();
        xaMap.put("令狐冲", "任盈盈");
        xaMap.put("林平之", "岳灵珊");

        ArrayList<HashMap<String, String>> maxList = new ArrayList<>();
        maxList.add(sgMap);
        maxList.add(sdMap);
        maxList.add(xaMap);

        //遍历

        for (HashMap<String, String> minMap : maxList) {
            minMap.forEach(new BiConsumer<String, String>() {
                @Override
                public void accept(String key, String value) {
                    System.out.println(key+"-------"+value);
                }
            });
            System.out.println();
        }
    }
}

17.HashMap和Hashtable的区别

HashMap和Hashtable的区别:    查看API可以知道
    HashMap: 线程不安全,效率高.允许null值和null键
    Hashtable: 线程安全 , 效率低.不允许null值和null键

public class MyTest {
    public static void main(String[] args) {
        HashMap<String,String> hashMap = new HashMap<String,String>();
        Hashtable<String,String> hashtable = new Hashtable<>();

        //HashMap和Hashtable的区别
        //HashMap 底层数据结构是哈希表，线程不安全效率高，允许存储null值null键
        //Hashtable 底层数据结构是哈希表,线程安全效率低，不允许存储null值null键

       // hashMap.put(null,null);

       // hashtable.put(null,null);
    }
}

18.Collections工具类的概述和常见方法讲解

1.Collections类概述:    针对集合操作 的工具类
2.Collections成员方法
    public static <T> void sort(List<T> list):                    排序,默认按照自然顺序
    public static <T> int binarySearch(List<?> list,T key):        二分查找
    public static <T> T max(Collection<?> coll):                获取最大值
    public static void reverse(List<?> list):                    反转
    public static void shuffle(List<?> list):                        随机置换
3.Collections工具类的常见方法讲解

public class MyTest {
    public static void main(String[] args) {
        //Java 针对单列集合提供了一个工具类
       // Collections
        ArrayList<Integer> list = new ArrayList<>();
       // list.sort();
        list.add(2);
        list.add(20);
        list.add(1);
        list.add(200);
        Collections.sort(list);
        System.out.println(list);
        int index = Collections.binarySearch(list, 2);

        System.out.println(index);
        Collections.reverse(list);
        System.out.println(list);
        Collections.shuffle(list);
        System.out.println(list);
        Integer max = Collections.max(list);
        Integer min = Collections.min(list);
        System.out.println(max);
        System.out.println(min);
    }
}

19.模拟斗地主洗牌和发牌

public class MyTest {
    public static void main(String[] args) {
        // A:
        // 案例演示:
        // 模拟斗地主洗牌和发牌，牌没有排序

        //1.创建一个牌盒子
        ArrayList<String> pokerBox = new ArrayList<>();
        //2.生成54张牌放进牌盒子
        String[] colors={"♣","♠","♦","♥"};
        String[] nums={"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
        for (String color : colors) {
            for (String num : nums) {
                String poker = color.concat(num);
                pokerBox.add(poker);
            }
        }
        //手动添加大小王
        pokerBox.add("🎅");
        pokerBox.add("🤶");

        //洗牌
        Collections.shuffle(pokerBox);
        Collections.shuffle(pokerBox);
        Collections.shuffle(pokerBox);

      // System.out.println(pokerBox);

        //发牌：
        //三个人有一副底牌 对应4个集合

        ArrayList<String> 高进 = new ArrayList<>();
        ArrayList<String> 星仔 = new ArrayList<>();
        ArrayList<String> 刀仔 = new ArrayList<>();
        ArrayList<String> 底牌 = new ArrayList<>();

       // List<String> 高进2 = pokerBox.subList(0, 17);

        //一人一张的发
        /*
        *
        *   高进  0  3  6  9  12 %3=0
            星仔  1  4  7  10 13 %3=1
            刀仔  2   5  8 11 14 %3=2
        *
        *
        * */

        for (int i = 0; i < pokerBox.size(); i++) {
             if(i>=pokerBox.size()-3){
                 底牌.add(pokerBox.get(i));
             }else if(i%3==0){
                 高进.add(pokerBox.get(i));
             }else if(i%3==1){
                 星仔.add(pokerBox.get(i));
             }else{
                 刀仔.add(pokerBox.get(i));
             }
        }

      //看牌
        lookPoker("高进",高进);
        lookPoker("星仔",星仔);
        lookPoker("刀仔",刀仔);
        lookPoker("底牌",底牌);

    }

    private static void lookPoker(String name, ArrayList<String> pokers) {
        System.out.println(name);
        for (String poker : pokers) {
            System.out.print(poker+"\t");
        }
        System.out.println();
    }
}

 

20.模拟斗地主洗牌和发牌并对牌进行排序的原理图解

21.模拟斗地主洗牌和发牌并对牌进行排序的代码实现

public class MyTest {
    public static void main(String[] args) {
        //创建一个牌盒子,生成54张牌放进牌盒子
        String[] num = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
        String[] color = {"♣","♠","♦","♥"};
        HashMap<Integer, String> hm = new HashMap<>();  //存储索引和扑克牌
        ArrayList<Integer> list = new ArrayList<>();    //存储索引
        int index = 0;
        //拼接扑克牌并索引和扑克牌存储在hm中
        for (String s1 : num) {         //获取数字
            for(String s2 : color){     //获取颜色
                hm.put(index, s2.concat(s1));
                list.add(index);        //将索引0到51添加到list集合中
                index++;
            }
        }
        //将小王添加到双列集合中
        hm.put(index, "🎅");
        list.add(index);                //将52索引添加到集合中
        index++;
        hm.put(index, "🤶");            //将53索引添加到集合中
        list.add(index);
        //洗牌
        Collections.shuffle(list);
        Collections.shuffle(list);
        Collections.shuffle(list);
        //发牌
        TreeSet<Integer>高进= new TreeSet<>();
        TreeSet<Integer>星仔= new TreeSet<>();
        TreeSet<Integer>刀仔= new TreeSet<>();
        TreeSet<Integer>底牌= new TreeSet<>();

        for (int i = 0; i < list.size(); i++) {
            if(i >= list.size() - 3){
                底牌.add(list.get(i));         //将三张底牌存储在底牌集合中
            }else if(i % 3 == 0){
                高进.add(list.get(i));
            }else if(i % 3 == 1){
                星仔.add(list.get(i));
            }else{
                刀仔.add(list.get(i));
            }
        }
        //看牌
        lookPoker(hm,高进,"高进");
        lookPoker(hm,星仔,"星仔");
        lookPoker(hm,刀仔,"刀仔");
        lookPoker(hm,底牌,"底牌");
    }
    /*
     * 看牌
     * ①返回值类型 void ②参数列表HashMap,TreeSet,String name
     */
    public static void lookPoker(HashMap<Integer,String> hm, TreeSet<Integer> ts, String name){
        System.out.println(name);
        for(Integer i : ts){            //i代表双列集合中的每一个键
            System.out.print(hm.get(i) + " ");
        }
        System.out.println();
    }
}