day06-排序查找算法,Map集合,集合嵌套,斗地主案例

今日目标 :

  • TreeSet集合(重点)
  • 排序算法(理解)
  • 查找算法(理解)
  • Map集合(重点)
  • 集合嵌套(理解)
  • 斗地主案例(理解)

1 TreeSet集合

1.1 集合体系

  • Collection

    • List接口

      • ArrayList类
      • LinkedList类

    • Set接口

      • HashSet集合

      • TreeSet集合

1.2 TreeSet特点

  • 不包含重复元素的集合[元素唯一]
  • 没有带索引的方法[无索引]
  • 可以按照指定的规则进行排序[可以排序]

1.3 TreeSet集合的练习

  1. package com.itheima.treeset_demo;
  3. import java.util.Iterator;
  4. import java.util.TreeSet;
  6. /*
  7.       1 TreeSet集合练习
  8.             存储Integer类型的整数，并遍历
  9.  */
  10. public class TreeSetDemo {
  11.     public static void main(String[] args) {
  12.         TreeSet<Integer> ts = new TreeSet<>();
  13.         ts.add(10);
  14.         ts.add(10);
  15.         ts.add(20);
  16.         ts.add(10);
  17.         ts.add(30);
  19.         // 迭代器
  20.         Iterator<Integer> it = ts.iterator();
  21.         while(it.hasNext()){
  22.             Integer s = it.next();
  23.             System.out.println(s);
  24.         }
  26.         System.out.println("================");
  28.         // 增强for
  29.         for (Integer t : ts) {
  30.             System.out.println(t);
  31.         }
  32.     }
  33. }
  • 如果TreeSet存储自定义对象 , 需要对自定义类进行指定排序规则
    下列代码没有指定排序规则 , 所以运行会报出错误
  1. package com.itheima.treeset_demo;
  3. public class Student {
  4.     private String name;
  5.     private int age;
  7.     public Student() {
  8.     }
  10.     public Student(String name, int age) {
  11.         this.name = name;
  12.         this.age = age;
  13.     }
  15.     public String getName() {
  16.         return name;
  17.     }
  19.     public void setName(String name) {
  20.         this.name = name;
  21.     }
  23.     public int getAge() {
  24.         return age;
  25.     }
  27.     public void setAge(int age) {
  28.         this.age = age;
  29.     }
  31.     @Override
  32.     public String toString() {
  33.         return "Student{" +
  34.                 "name='" + name + '\'' +
  35.                 ", age=" + age +
  36.                 '}';
  37.     }
  38. }
  39. =============================================================
  42. package com.itheima.treeset_demo;
  44. import java.util.Iterator;
  45. import java.util.TreeSet;
  47. /*
  48.       TreeSet集合练习
  49.          存储学生对象，并遍历
  51.  */
  52. public class TreeSetDemo2 {
  53.     public static void main(String[] args) {
  54.         TreeSet<Student> ts = new TreeSet<>();
  56.         Student s1 = new Student("dilireba", 19);
  57.         Student s2 = new Student("gulinazha", 20);
  58.         Student s3 = new Student("maerzhaha", 18);
  60.         ts.add(s1);
  61.         ts.add(s2);
  62.         ts.add(s3);
  64.         System.out.println(ts);
  65.     }
  66. }

1.4 排序规则

1.4.1 自然排序

  • 使用步骤
  • 使用空参构造创建TreeSet集合对象
  • 存储元素所在的类需要实现Comparable接口
  • 重写Comparable接口中的抽象方法 compareTo方法,指定排序规则
    • compareTo方法如何指定排序规则 :
  • 此方法如果返回的是小于0 , 代表的是当前元素较小 , 需要存放在左边
  • 此方法如果返回的是大于0 , 代表的是当前元素较大, 需要存放在右边
  • 此方法如果返回的是0 , 代表的是当前元素在集合中已经存在 , 不存储
    • 练习 : 存储学生对象, 按照年龄的升序排序，并遍历
  1. package com.itheima.treeset_demo;
  3. public class Student implements Comparable<Student>{
  4.     private String name;
  5.     private int age;
  7.     public Student() {
  8.     }
  10.     public Student(String name, int age) {
  11.         this.name = name;
  12.         this.age = age;
  13.     }
  15.     public String getName() {
  16.         return name;
  17.     }
  19.     public void setName(String name) {
  20.         this.name = name;
  21.     }
  23.     public int getAge() {
  24.         return age;
  25.     }
  27.     public void setAge(int age) {
  28.         this.age = age;
  29.     }
  31.     @Override
  32.     public String toString() {
  33.         return "Student{" +
  34.                 "name='" + name + '\'' +
  35.                 ", age=" + age +
  36.                 '}';
  37.     }
  39.     /*
  41.      */
  42.     @Override
  43.     public int compareTo(Student o) {
  44.         /*
  45.             this : 当前要添加的元素
  46.             o    : 集合中已经存在的元素
  48.             如果方法返回值为负数 : 当前元素放左边
  49.             如果方法的返回值为正数  : 当前元素放右边
  50.             如果方法的返回值为0  : 说明当前元素在集合中存在,不存储
  51.          */
  52.         int result = this.age - o.age;
  53.         return result;
  54.     }
  55. }
  56. =====================================================
  58. package com.itheima.treeset_demo;
  59. import java.util.Iterator;
  60. import java.util.TreeSet;
  62. /*
  63.       TreeSet集合练习
  64.          存储学生对象，并遍历
  66.  */
  67. public class TreeSetDemo2 {
  68.     public static void main(String[] args) {
  69.         TreeSet<Student> ts = new TreeSet<>();
  71.         Student s1 = new Student("dilireba", 19);
  72.         Student s2 = new Student("gulinazha", 20);
  73.         Student s3 = new Student("maerzhaha", 18);
  75.         ts.add(s1);
  76.         ts.add(s2);
  77.         ts.add(s3);
  79.         System.out.println(ts);
  80.     }
  81. }
  • 对刚才的案例进行改进 , 如果年龄相等 , 那么对学生的名字在字典的顺序排序
  1. package com.itheima.treeset_demo;
  3. public class Student implements Comparable<Student> {
  4.     private String name;
  5.     private int age;
  7.     public Student() {
  8.     }
  10.     public Student(String name, int age) {
  11.         this.name = name;
  12.         this.age = age;
  13.     }
  15.     public String getName() {
  16.         return name;
  17.     }
  19.     public void setName(String name) {
  20.         this.name = name;
  21.     }
  23.     public int getAge() {
  24.         return age;
  25.     }
  27.     public void setAge(int age) {
  28.         this.age = age;
  29.     }
  31.     @Override
  32.     public String toString() {
  33.         return "Student{" +
  34.                 "name='" + name + '\'' +
  35.                 ", age=" + age +
  36.                 '}';
  37.     }
  39.     /*
  41.      */
  42.     @Override
  43.     public int compareTo(Student o) {
  44.         /*
  45.             this : 当前要添加的元素
  46.             o    : 集合中已经存在的元素
  48.             如果方法返回值为负数 : 当前元素放左边
  49.             如果方法的返回值为正数  : 当前元素放右边
  50.             如果方法的返回值为0  : 说明当前元素在集合中存在,不存储
  51.          */
  52.         int result = this.age - o.age;
  53.         // 如果年龄相等 , 那么按照名字进行排序
  54.         return result == 0 ? this.name.compareTo(o.name) : age;
  55.     }
  56. }
  58. =============================================================
  61. package com.itheima.treeset_demo;
  63. import java.util.Iterator;
  64. import java.util.TreeSet;
  66. /*
  67.       TreeSet集合练习
  68.          存储学生对象, 按照年龄的升序排序，并遍历
  70.  */
  71. public class TreeSetDemo2 {
  72.     public static void main(String[] args) {
  73.         TreeSet<Student> ts = new TreeSet<>();
  75.         Student s1 = new Student("dilireba", 19);
  76.         Student s2 = new Student("gulinazha", 20);
  77.         Student s3 = new Student("maerzhaha", 18);
  78.         Student s4 = new Student("ouyangnanan", 18);
  80.         ts.add(s1);
  81.         ts.add(s2);
  82.         ts.add(s3);
  83.         ts.add(s4);
  85.         System.out.println(ts);
  86.     }
  87. }

1.4.2 比较器排序

  • 使用步骤
  • TreeSet的带参构造方法使用的是 “比较器排序” 对元素进行排序的
  • 比较器排序，就是让TreeSet集合构造方法接收Comparator接口的实现类对象
  • 重写Comparator接口中的 compare(T o1,T o2)方法 , 指定排序规则
  • 注意 : o1代表的是当前往集合中添加的元素 , o2代表的是集合中已经存在的元素,排序原理与自然排序相同!
    • 排序规则
  • 排序原理与自然排序相同!
    • 练习
  1. package com.itheima.treeset_demo.comparator_demo;
  3. public class Teacher  {
  4.     private String name;
  5.     private int age;
  7.     public Teacher() {
  8.     }
  10.     public Teacher(String name, int age) {
  11.         this.name = name;
  12.         this.age = age;
  13.     }
  15.     public String getName() {
  16.         return name;
  17.     }
  19.     public void setName(String name) {
  20.         this.name = name;
  21.     }
  23.     public int getAge() {
  24.         return age;
  25.     }
  27.     public void setAge(int age) {
  28.         this.age = age;
  29.     }
  31.     @Override
  32.     public String toString() {
  33.         return "Student{" +
  34.                 "name='" + name + '\'' +
  35.                 ", age=" + age +
  36.                 '}';
  37.     }
  38. }
  39. ======================================
  41. package com.itheima.treeset_demo.comparator_demo;
  43. import java.util.Comparator;
  44. import java.util.TreeSet;
  46. /*
  47.       TreeSet集合练习
  48.          存储学生对象, 按照年龄的升序排序，并遍历
  50.  */
  51. public class TreeSetDemo2 {
  52.     public static void main(String[] args) {
  53.         TreeSet<Teacher> ts = new TreeSet<>(new ComparatorImpl());
  55.         Teacher s1 = new Teacher("dilireba", 19);
  56.         Teacher s2 = new Teacher("gulinazha", 20);
  57.         Teacher s3 = new Teacher("maerzhaha", 18);
  58.         Teacher s4 = new Teacher("ouyangnanan", 18);
  60.         ts.add(s1);
  61.         ts.add(s2);
  62.         ts.add(s3);
  63.         ts.add(s4);
  65.         System.out.println(ts);
  66.     }
  67. }
  69. // 比较器排序
  70. class ComparatorImpl implements Comparator<Teacher> {
  71.     @Override
  72.     public int compare(Teacher o1, Teacher o2) {
  73.         int result = o1.getAge() - o2.getAge();
  74.         return result == 0 ? o1.getName().compareTo(o2.getName()) : result;
  75.     }
  76. }

1.4.3 两种排序的区别

  • 自然排序：自定义类实现Comparable接口，重写compareTo方法，根据返回值进行排序。

  • 比较器排序：创建TreeSet对象的时候传递Comparator的实现类对象，重写compare方法，根据返回值进行排序。

  • 如果Java提供好的类已经定义了自然排序排序规则 , 那么我们可以使用比较器排序进行替换

  • 注意 : 如果自然排序和比较器排序都存在 , 那么会使用比较器排序

  • 两种方式中，关于返回值的规则：

    • 如果返回值为负数，表示当前存入的元素是较小值，存左边
    • 如果返回值为0，表示当前存入的元素跟集合中元素重复了，不存
    • 如果返回值为正数，表示当前存入的元素是较大值，存右边

2 Collections单列集合工具类

  • Collections工具类介绍

    • java.util.Collections 是集合的工具类，里面提供了静态方法来操作集合，乱序，排序….

2.1 shuffle方法

  • public static void shuffle(List<?> list) 对集合中的元素进行打乱顺序。

  • 集合中元素类型可以任意类型 ```java package com.itheima.collections_demo;

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

/* Collections类 : 操作单列集合的工具类 public static void shuffle(List<?> list) 对集合中的元素进行打乱顺序 1 乱序只能对List集合进行乱序 2 集合中元素类型可以任意类型

  1.     需求 : 定义一个List集合，里面存储若干整数。对集合进行乱序

*/ public class ShuffleDemo { public static void main(String[] args) { ArrayList list = new ArrayList<>(); list.add(10); list.add(30); list.add(50); list.add(40); list.add(20);

  1.     Collections.shuffle(list);
  3.     System.out.println(list);// 打印集合中的元素
  4. }

}

  4. <a name="dc88bc94"></a>
  5. ### 2.2 sort方法
  7. - 
  8. public static  void sort (List list): 对集合中的元素自然排序
  10.    - 该方法只能对List集合进行排序
  11.    - 从方法中泛型分析可知，集合中元素类型必须是Comparable的子类型
  12. ```java
  13. package com.itheima.collections_demo;
  15. import java.util.ArrayList;
  16. import java.util.Collections;
  17. import java.util.Comparator;
  19. /*
  20.     Collections类 : 单列集合的工具类
  21.         sort方法是一个重载的方法，可以实现自然排序及比较器排序。
  22.         要特别注意的是sort方法只能对List集合进行排序，方法如下：
  24.         public static <T extends Comparable> void sort (List<T> list)
  26.         练习：定义List集合，存储若干整数，进行排序
  27.  */
  28. public class SortDemo1 {
  29.     public static void main(String[] args) {
  30.         ArrayList<Integer> list = new ArrayList<>();
  31.         list.add(3);
  32.         list.add(2);
  33.         list.add(4);
  34.         list.add(1);
  36.         // 使用此方法 , 需要集合中存储的元素实现Comparable接口
  37.         Collections.sort(list);
  39.         System.out.println(list);
  40.     }
  41. }

  • public static void sort (List list, Comparator<? super T> c)

    • 方法只能对List集合排序

    • 对元素的类型没有要求

    • 需要定义一个比较器Comparator （规则和之前TreeSet时一样）

    • 使用场景：

      • List集合中的元素类型不具备自然排序能力（元素类型没有实现结果 Comparable）
      • List集合中的元素类型具备自然排序能力，但是排序规则不是当前所需要的。 ```java package com.itheima.collections_demo;

import java.util.ArrayList; import java.util.Collections; import java.util.Comparator;

/* Collections类 : 单列集合的工具类 sort方法是一个重载的方法，可以实现自然排序及比较器排序。 要特别注意的是sort方法只能对List集合进行排序，方法如下：

  1.     public static <T extends Comparable> void sort (List<T> list) : 只能对集合中的元素自然排序
  3.     需求1：定义一个List集合，存储若干整数，要求对集合进行降序排序
  4.     分析：整数类型Integer具备自然排序能力，但是题目要求降序排序
  6.     需求2：定义一个学生类，属性有姓名，年龄。创建若干对象放到List集合中。要求对List集合中学生对象进行年龄的升序排序。
  7.     分析：自定义类型默认是没有自然排序能力的，我们使用自定义比较器方式排序。

*/ public class SortDemo2 { public static void main(String[] args) {

  1.     /*
  2.         需求2：定义一个学生类，属性有姓名，年龄。创建若干对象放到List集合中。要求对List集合中学生对象进行年龄的升序排序。
  3.         分析：自定义类型默认是没有自然排序能力的，我们使用自定义比较器方式排序
  4.     */
  5.     ArrayList<Student> list = new ArrayList<>();
  6.     list.add(new Student("lisi", 24));
  7.     list.add(new Student("zhangsan", 23));
  9.     Collections.sort(list, new Comparator<Student>() {
  10.         @Override
  11.         public int compare(Student o1, Student o2) {
  12.             return o1.getAge() - o2.getAge();
  13.         }
  14.     });
  15.     System.out.println(list);
  16. }
  18. /*
  19.     需求1：定义一个List集合，存储若干整数，要求对集合进行降序排序
  20.     分析：整数类型Integer具备自然排序能力，但是题目要求降序排序
  21.  */
  22. private static void method1() {
  23.     ArrayList<Integer> list = new ArrayList<>();
  24.     list.add(3);
  25.     list.add(2);
  26.     list.add(4);
  27.     list.add(1);
  29.     // 使用此方法 , 需要集合中存储的元素实现Comparable接口
  30.     Collections.sort(list, new Comparator<Integer>() {
  31.         @Override
  32.         public int compare(Integer o1, Integer o2) {
  33.             return o2 - o1;
  34.         }
  35.     });
  37.     System.out.println(list);
  38. }

}

  2. <a name="41cd90f7"></a>
  3. ## 3 可变参数
  5. <a name="30bf6357"></a>
  6. ### 3.1 可变参数介绍
  8. - 在 JDK5 中提供了可变参数，允许在调用方法时传入任意个参数。可变参数原理就是一个数组形式存在
  9. - 格式 : 修饰符 返回值类型 方法名(数据类型… 变量名) {  }
  10. - 举例 : public void show(int ... num) : 表达式该方法可以接收任意个整数值 , 原理 : 其实就是一个int类型的数组
  12. <a name="9e4e248f"></a>
  13. ### 3.2 可变参数注意
  15. - 可变参数只能作为方法的最后一个参数，但其前面可以有或没有任何其他参数。
  16. - 可变参数本质上是数组，不能作为方法的重载。如果同时出现相同类型的数组和可变参数方法，是不能编译通过的。
  18. <a name="d6572b8b"></a>
  19. ### 3.3 可变参数的使用
  21. - 调用可变参数方法，可以给出零到任意多个参数，编译器会将可变参数转化为一个数组，也可以直接传递一个数组。<br />
  22. 方法内部使用时直接当做数组使用即可
  24. ```java
  25. package com.itheima.changevariable_demo;
  27. /*
  28.     1 什么是可变参数
  29.         JDK5中,允许在调用方法时传入任意个参数。可变参数原理就是一个数组形式存在
  30.         格式 : 修饰符 返回值类型 方法名(数据类型… 变量名) {  }
  31.         举例 : public void show(int... num){}
  33.     2 可变参数注意 :
  34.         1) 可变参数只能作为方法的最后一个参数，但其前面可以有或没有任何其他参数。
  35.         2) 可变参数本质上是数组，不能作为方法的重载。如果同时出现相同类型的数组和可变参数方法，是不能编译通过的。
  37.     3 可变参数的使用 :
  38.         调用可变参数的方法 , 可以传入0个到任意个数据 , 编译器会将可变参数转换成一个数组 , 也可以直接传递一个数组
  39.         方法中把可变参数当做一个数组去使用即可
  42.     练习：定义方法可以求任意个整数的和
  44.  */
  45. public class VariableDemo1 {
  46.     public static void main(String[] args) {
  47.         sum();
  48.         sum(1, 2);
  49.         sum(1, 2, 3, 4);
  50.     }
  52.     public static void sum(int... num) {// 方法的参数是一个int类型的可变参数
  53.         int sum = 0;// 定义求和变量
  54.         for (int i : num) {
  55.             sum += i;
  56.         }
  57.         System.out.println(sum);
  58.     }
  59. }

3.4 addAll方法

  • static boolean addAll(Collection<? super T> c , T… elements) : 添加任意多个数据到集合中

    • 该方法就是一个含有可变参数的方法，使用时可以传入任意多个实参，实用方便！

    • 分析 : Collection<? super T> , ? 可以是 T 的类型或者父类型 , 反过来 , T是?类型或者子类型
      那么当你确定?的类型,也就是集合的类型 , 就可以往集合中添加此类型或者子类型

  1. package com.itheima.changevariable_demo;
  3. import java.util.ArrayList;
  4. import java.util.Collections;
  6. /*
  7.     Collections的addAll方法
  8.         static <T> boolean  addAll(Collection<? super T> c , T... elements) : 添加任意多个数据到集合中
  9.         分析： 该方法就是一个含有可变参数的方法，使用时可以传入任意多个实参，实用方便！
  11.         练习：创建一个List集合，使用addAll方法传入若干字符串
  13.  */
  14. public class VariableDemo2 {
  15.     public static void main(String[] args) {
  16.         ArrayList<Integer> list = new ArrayList<>();
  17.         Collections.addAll(list, 10, 20, 30, 40);
  18.         System.out.println(list);// [10, 20, 30, 40]
  19.     }
  20. }

4 排序,查找算法

4.1 冒泡排序

  • 冒泡排序 : 将一组数据按照从小到大的顺序进行排序
  • 冒泡排序原理 : 相邻元素两两作比较 , 大的元素往后放
  1. package com.itheima.arraysort_demo.bubblesort_demo;
  3. import java.util.Arrays;
  5. /*
  6.     冒泡排序 : 将一组数据按照从小到大的顺序进行排序
  7.     冒泡排序的原理 : 相邻元素两两作比较 , 大的元素往后放
  9.     需求 : 将数组中的元素 {3,5,2,1,4} 进行升序排序
  10.  */
  11. public class SortDemo {
  12.     public static void main(String[] args) {
  13.         int[] arr = {3, 5, 2, 1, 4};
  15. //        // 第一轮排序
  16. //        for (int i = 0; i < arr.length - 1; i++) {
  17. //            if (arr[i] > arr[i + 1]) {
  18. //                int temp = arr[i];
  19. //                arr[i] = arr[i + 1];
  20. //                arr[i + 1] = temp;
  21. //            }
  22. //        }
  23. //
  24. //        System.out.println("第一轮排序:" + Arrays.toString(arr));
  25. //
  26. //
  27. //        // 第二轮排序
  28. //        for (int i = 0; i < arr.length - 2; i++) {
  29. //            if (arr[i] > arr[i + 1]) {
  30. //                int temp = arr[i];
  31. //                arr[i] = arr[i + 1];
  32. //                arr[i + 1] = temp;
  33. //            }
  34. //        }
  35. //
  36. //        System.out.println("第二轮排序:" + Arrays.toString(arr));
  37. //
  38. //
  39. //        // 第三轮排序
  40. //        for (int i = 0; i < arr.length - 2; i++) {
  41. //            if (arr[i] > arr[i + 1]) {
  42. //                int temp = arr[i];
  43. //                arr[i] = arr[i + 1];
  44. //                arr[i + 1] = temp;
  45. //            }
  46. //        }
  47. //
  48. //        System.out.println("第三轮排序:" + Arrays.toString(arr));
  49. //
  50. //
  51. //        // 第四轮排序
  52. //        for (int i = 0; i < arr.length - 2; i++) {
  53. //            if (arr[i] > arr[i + 1]) {
  54. //                int temp = arr[i];
  55. //                arr[i] = arr[i + 1];
  56. //                arr[i + 1] = temp;
  57. //            }
  58. //        }
  59. //
  60. //        System.out.println("第四轮排序:" + Arrays.toString(arr));
  62.         // 优化代码
  63.         for (int j = 0; j < arr.length - 1; j++) {// 比较的轮次
  64.             // 每轮相邻元素比较的次数
  65.             for (int i = 0; i < arr.length - 1 - j; i++) {
  66.                 if (arr[i] > arr[i + 1]) {
  67.                     int temp = arr[i];
  68.                     arr[i] = arr[i + 1];
  69.                     arr[i + 1] = temp;
  70.                 }
  71.             }
  72.             System.out.println("第" + (j + 1) + "轮排序:" + Arrays.toString(arr));
  73.         }
  74.     }
  75. }

4.2 选择排序

  • 选择排序原理 : 它的工作原理是每一次从待排序的数据元素中选出最小的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据元素排完。

  • 注意事项 :

    • 有n个元素，那么就要比较n-1轮次。
    • 每一趟中都会选出一个最值元素，较前一趟少比较一次
  1. package com.itheima.arraysort_demo.selectionsort_demo;
  2. /*
  3.     选择排序工作原理 :
  4.         它的工作原理是每一次从待排序的数据元素中选出最小的一个元素，
  5.         存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小元素，然后放到已排序序列的末尾。
  6.         以此类推，直到全部待排序的数据元素排完。
  8.     注意 :
  9.         1 有n个元素，那么就要比较n-1趟。
  10.         2 每一趟中都会选出一个最值元素，较前一趟少比较一次
  11.  */
  13. import java.util.Arrays;
  15. public class SortDemo {
  16.     public static void main(String[] args) {
  17.         int[] arr = {4, 1, 5, 3, 2};
  19.         // 遍历数组
  20.         for (int i = 0; i < arr.length - 1; i++) {
  21.             // 记录当前元素和其之后所有元素的最小值索引
  22.             int minIndex = i;
  24.             int min = arr[i];
  25.             for (int j = i; j < arr.length; j++) {
  26.                 if (arr[j] < min) {
  27.                     minIndex = j; //  把当前最小值的索引赋值给minIndex
  28.                     min = arr[j];// 替换最小值
  29.                 }
  30.             }
  32.             if (i != minIndex) {
  33.                 int temp = arr[i];
  34.                 arr[i] = arr[minIndex];
  35.                 arr[minIndex] = temp;
  36.             }
  37.         }
  39.         System.out.println(Arrays.toString(arr));
  40.     }
  41. }

4.3 二分查找

  • 原理 : 每次去掉一般的查找范围
  • 前提 : 数组必须有序
  1. package com.itheima.arraysort_demo.binarysearch_demo;
  3. /*
  4.     二分查找 :
  5.         原理 : 每次去掉一般的查找范围
  6.         前提 : 数组必须有序
  7.         步骤 :
  8.             1，定义两个变量，表示要查找的范围。默认min = 0 ， max = 最大索引
  9.             2，循环查找，但是min <= max
  10.             3，计算出mid的值
  11.             4，判断mid位置的元素是否为要查找的元素，如果是直接返回对应索引
  12.             5，如果要查找的值在mid的左半边，那么min值不变，max = mid -1.继续下次循环查找
  13.             6，如果要查找的值在mid的右半边，那么max值不变，min = mid + 1.继续下次循环查找
  14.             7，当 min > max 时，表示要查找的元素在数组中不存在，返回-1.
  15.  */
  16. public class BinarySearchDemo {
  17.     public static void main(String[] args) {
  19.         int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
  21.         int i = binarySearch(arr, 8);
  22.         System.out.println(i);
  24.     }
  26.     public static int binarySearch(int[] arr, int num) {
  27.         // 定义两个变量，表示要查找的范围。默认min = 0 ， max = 最大索引
  28.         int max = arr.length - 1;
  29.         int min = 0;
  31.         // 2，循环查找，但是min <= max
  32.         while (min <= max) {
  33.             // 3，计算出mid的值
  34.             int mid = (min + max) / 2;
  36.             if (arr[mid] == num) {
  37.                 //  4，判断mid位置的元素是否为要查找的元素，如果是直接返回对应索引
  38.                 return mid;
  39.             } else if (arr[mid] > num) {
  40.                 // 5，如果要查找的值在mid的左半边，那么min值不变，max = mid -1.继续下次循环查找
  41.                 max = mid - 1;
  42.             } else if (arr[mid] < num) {
  43.                 // 6，如果要查找的值在mid的右半边，那么max值不变，min = mid + 1.继续下次循环查找
  44.                 min = mid + 1;
  45.             }
  46.         }
  48.         return -1;
  49.     }
  50. }

5 Map集合

5.1 Map集合的介绍

  • java.util.Map 集合，里面保存的数据是成对存在的，称之为双列集合。存储的数据，我们称为键值对。 之前所学的Collection集合中元素单个单个存在的，称为单列集合

5.2 特点

  • Map K：键的数据类型；V：值的数据类型

  • 特点 :

    • 键不能重复，值可以重复
    • 键和值是 一 一 对应的，通过键可以找到对应的值
    • （键 + 值） 一起是一个整体 我们称之为“键值对” 或者 “键值对对象”，在Java中叫做“Entry对象”

  • 使用场景

    • 凡是要表示一一对应的数据时就可以Map集合

      • 举例 : 学生的学号和姓名 —- (itheima001 小智)
      • 举例 : 夫妻的关系 —— (王宝强 马蓉 ) (谢霆锋 张柏芝)

5.3 常用实现类

  • HashMap：

    • 此前的HashSet底层实现就是HashMap完成的，HashSet保存的元素其实就是HashMap集合中保存的键，底层结构是哈希表结构，具有键唯一，无序，特点。

  • LinkedHashMap：

    • 底层结构是有链表和哈希表结构，去重，有序

  • TreeMap：

    • 底层是有红黑树，去重，通过键排序

5.4 常用的方法

  • public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
  • public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
  • public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
  • public Set keySet(): 获取Map集合中所有的键，存储到Set集合中。
  • public boolean containKey(Object key):判断该集合中是否有此键。
  1. package com.itheima.map_demo.mapmethod_demo;
  3. import java.util.HashMap;
  4. import java.util.Map;
  5. import java.util.Set;
  7. /*
  8.     Map中常用方法 :
  9.         public V put(K key, V value):  把指定的键与指定的值添加到Map集合中
  10.         public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值
  11.         public V get(Object key) 根据指定的键，在Map集合中获取对应的值
  12.         public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中
  13.         public boolean containKey(Object key): 判断该集合中是否有此键。
  15.      需求 : 将以下数据保存到Map集合中 , 进行测试以上方法
  16.         “文章“       "马伊琍
  17.         “谢霆锋”     “王菲”
  18.         “李亚鹏”     “王菲”
  20.  */
  21. public class MapDemo {
  22.     public static void main(String[] args) {
  23.         //  创建双列集合对象
  24.         Map<String, String> hm = new HashMap<>();
  26.         // 添加元素
  27.         // public V put(K key, V value):  把指定的键与指定的值添加到Map集合中
  28.         hm.put("文章", "马伊琍");
  29.         hm.put("谢霆锋", "王菲");
  30.         hm.put("李亚鹏", "王菲");
  32.         // public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值
  33.         // System.out.println(hm.remove("谢霆锋"));
  35.         // public V get(Object key) 根据指定的键，在Map集合中获取对应的值
  36.         // System.out.println(hm.get("李亚鹏"));
  38.         // public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中
  39. //        Set<String> set = hm.keySet();
  40. //        for (String key : set) {
  41. //            System.out.println(key);
  42. //        }
  44.         // public boolean containKey(Object key): 判断该集合中是否有此键。
  45.         // System.out.println(hm.containsKey("李亚鹏"));
  47.         System.out.println(hm);// 打印集合 , 打印的是集合中的元素
  48.     }
  49. }

5.5 Map集合的遍历

  • 第一种方式 : 键找值
  1. package com.itheima.map_demo.map_test;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/*
创建Map集合对象 , 往集合中添加以下四对元素 , 使用键找值遍历集合

  1. 周瑜 -- 小乔
  2. 孙策 -- 大乔
  3. 刘备 -- 孙尚香
  4. 诸葛亮 -- 黄月英

*/
public class MapTest1 {
public static void main(String[] args) {
// 创建集合对象
Map hm = new HashMap<>();

  1.     // 添加元素
  2.     hm.put("周瑜", "小乔");
  3.     hm.put("孙策", "大乔");
  4.     hm.put("刘备", "孙尚香");
  5.     hm.put("诸葛亮", "黄月英");
  7.     // 获取健集合
  8.     Set<String> set = hm.keySet();
  10.     // 遍历健集合 , 通过键找值
  11.     for (String key : set) {
  12.         String value = hm.get(key);
  13.         System.out.println(key + "---" + value);
  14.     }
  15. }

}

  2. - 第二种方式  : 获取键值对对象 , 在找到键和值
  4. ```java
  5. package com.itheima.map_demo.map_test;
  7. import java.util.HashMap;
  8. import java.util.Map;
  9. import java.util.Set;
  11. /*
  12.   需求 :  创建Map集合对象 , 往集合中添加以下三对元素
  13.           使用获取Entry对象集合,在找到键和值 遍历集合
  15.       张无忌 -- 赵敏
  16.       张翠山 -- 殷素素
  17.       张三丰 -- 郭芙
  19. */
  20. public class MapTest2 {
  21.   public static void main(String[] args) {
  22.       // 创建集合对象
  23.       Map<String, String> hm = new HashMap<>();
  25.       // 添加元素
  26.       hm.put("张无忌", "赵敏");
  27.       hm.put("张翠山", "殷素素");
  28.       hm.put("张三丰", "郭芙");
  30.       // 获取键值对对象集合
  31.       Set<Map.Entry<String, String>> set = hm.entrySet();
  33.       // 遍历键值对对象集合 , 获取每一个键值对对象
  34.       for (Map.Entry<String, String> entry : set) {
  35.           // 通过entry对象获取键
  36.           String key = entry.getKey();
  37.           // 通过entry对象获取值
  38.           String value = entry.getValue();
  39.           System.out.println(key + "--" + value);
  40.       }
  41.   }
  42. }

5.6 HashMap集合

  • 注意 : HashMap集合 , 要想保证键唯一 , 那么键所在的类必须重写hashCode和equals方法
  1. package com.itheima.map_demo.map_test;
  3. public class Student {
  4.     private String name;
  5.     private int age;
  7.     public Student() {
  8.     }
  10.     public Student(String name, int age) {
  11.         this.name = name;
  12.         this.age = age;
  13.     }
  15.     public String getName() {
  16.         return name;
  17.     }
  19.     public void setName(String name) {
  20.         this.name = name;
  21.     }
  23.     public int getAge() {
  24.         return age;
  25.     }
  27.     public void setAge(int age) {
  28.         this.age = age;
  29.     }
  31.     @Override
  32.     public boolean equals(Object o) {
  33.         if (this == o) return true;
  34.         if (o == null || getClass() != o.getClass()) return false;
  36.         Student student = (Student) o;
  38.         if (age != student.age) return false;
  39.         return name != null ? name.equals(student.name) : student.name == null;
  40.     }
  42.     @Override
  43.     public int hashCode() {
  44.         int result = name != null ? name.hashCode() : 0;
  45.         result = 31 * result + age;
  46.         return result;
  47.     }
  49.     @Override
  50.     public String toString() {
  51.         return "Student{" +
  52.                 "name='" + name + '\'' +
  53.                 ", age=" + age +
  54.                 '}';
  55.     }
  56. }
  1. package com.itheima.map_demo.map_test;
  2. import java.util.HashMap;
  3. import java.util.Set;
  5. /*
  6.     HashMap类 :
  7.         存储数据，每位学生（姓名，年龄）都有自己的家庭住址。
  8.         学生和地址有对应关系，将学生对象和家庭住址存储到map集合中。学生作为键, 家庭住址作为值。
  9.         要求：学生姓名相同并且年龄相同视为同一名学生，不能重复存储
  10.  */
  11. public class HashMapTest {
  12.     public static void main(String[] args) {
  13.         // 学生作为键, 家庭住址作为值。
  14.         HashMap<Student, String> hm = new HashMap<>();
  16.         hm.put(new Student("迪丽热巴", 18) , "新疆");
  17.         hm.put(new Student("迪丽热巴", 18) , "中国");
  19.         Set<Student> set = hm.keySet();
  20.         for (Student key : set) {
  21.             String value = hm.get(key);
  22.             System.out.println(key + "--" + value);
  23.         }
  24.     }
  25. }

5.7 LinkedHashMap集合

  • LinkedHashMap类 , 在最底层采用的数据结构 : 是链表+哈希表。

  • 特点 :

    • 元素唯一
    • 元素有序
  1. package com.itheima.map_demo.map_test;
  3. import java.util.LinkedHashMap;
  4. import java.util.Set;
  6. /*
  7.     LinkedHashMap类 , 在最底层采用的数据结构 : 是链表+哈希表。
  8.     特点 :
  9.         1 元素唯一
  10.         2 有序
  12.     需求 : 创建LinkedHashMap对象 , 添加元素进行验证 元素唯一 , 有序的特点
  13.  */
  14. public class LinkedHashMapTest {
  15.     public static void main(String[] args) {
  16.         // 创建集合对象
  17.         LinkedHashMap<Integer, String> linkedHashMap = new LinkedHashMap<>();
  19.         linkedHashMap.put(1, "张三");
  20.         linkedHashMap.put(1, "李四");
  21.         linkedHashMap.put(2, "王五");
  22.         linkedHashMap.put(3, "赵六");
  24.         System.out.println(linkedHashMap);
  25.     }
  26. }

5.8 TreeMap集合

  • TreeMap的底层是红黑树实现的，有排序的能力，键去重。

  • 可以自然排序（键所在的类要实现Comparable）

  • 若自定义类没有自然排序功能，或自然排序功能不满足要求时。可以自定义比较器排序（Comparator）

  1. package com.itheima.map_demo.map_test;
  2. import java.util.TreeMap;
  4. /*
  5.     需求 :
  6.         定义TreeMap集合存储键值对，键使用Integer，值使用String，存储若干键值对，遍历集合观察结果是否有排序。
  7.  */
  8. public class TreeMapTest1 {
  9.     public static void main(String[] args) {
  10.         //  定义TreeMap集合存储键值对，键使用Integer，值使用String
  11.         // 创建集合对象
  12.         TreeMap<Integer, String> treeMap = new TreeMap<>();
  14.         treeMap.put(1, "张三");
  15.         treeMap.put(3, "赵六");
  16.         treeMap.put(2, "王五");
  18.         System.out.println(treeMap);
  19.     }
  20. }
  1. package com.itheima.map_demo.map_test;
  3. import java.util.Comparator;
  4. import java.util.TreeMap;
  6. /*
  7.     需求：创建一个TreeMap集合，键是学生对象(Student)，值是籍贯(String)。
  8.     学生属性姓名和年龄, 要求按照年龄进行升序排序并遍历
  9.  */
  10. public class TreeMapTest2 {
  11.     public static void main(String[] args) {
  12.         // 学生作为键, 家庭住址作为值。
  13.         TreeMap<Student, String> tm = new TreeMap<>(new Comparator<Student>() {
  14.             @Override
  15.             public int compare(Student o1, Student o2) {
  16.                 return o1.getAge() - o2.getAge();
  17.             }
  18.         });
  20.         tm.put(new Student("迪丽热巴", 18), "新疆");
  21.         tm.put(new Student("迪丽热巴", 16), "中国");
  23.         System.out.println(tm);
  24.     }
  25. }

6 集合嵌套

6.1 List嵌套List

  1. package com.itheima.Collection_nested_demo;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. /*
  7.     使用场景举例：一年级有多个班级，每个班级有多名学生。要求保存每个班级的学生姓名，保存一个年级所有的班级信息
  9.     思路：
  10.     可以使用List集合保存一个班级的学生
  11.     可以使用List集合保存所有班级
  13.     因此我们可以定义集合如下：
  14.     班级：List<String>
  15.         举例 :
  16.             List<String> 三年一班 = {迪丽热巴 , 古力娜扎 ,马尔扎哈 ,欧阳娜娜}
  17.             List<String> 三年二班 = {李小璐 , 白百何 , 马蓉}
  18.             List<String> 三年三班 = {林丹 ,文章, 陈赫}
  20.     年级：List<List<String>>
  21.         举例 :
  22.             List<List<String>> 年级 = {三年一班 , 三年二班 , 三年三班}
  23.  */
  24. public class Test3 {
  25.     public static void main(String[] args) {
  26.         List<String> 三年一班 = new ArrayList<>();
  27.         三年一班.add("迪丽热巴");
  28.         三年一班.add("古力娜扎");
  29.         三年一班.add("马尔扎哈");
  30.         三年一班.add("欧阳娜娜");
  32.         List<String> 三年二班 = new ArrayList<>();
  33.         三年二班.add("李小璐");
  34.         三年二班.add("白百何");
  35.         三年二班.add("马蓉");
  37.         List<String> 三年三班 = new ArrayList<>();
  38.         三年三班.add("林丹");
  39.         三年三班.add("文章");
  40.         三年三班.add("陈赫");
  42.         List<List<String>> 年级 = new ArrayList<>();
  43.         年级.add(三年一班);
  44.         年级.add(三年二班);
  45.         年级.add(三年三班);
  47.         for (List<String> 班级 : 年级) {
  48.             for (String name : 班级) {
  49.                 System.out.println(name);
  50.             }
  51.             System.out.println("-----------------");
  52.         }
  53.     }
  54. }

6.2 List嵌套Map

  1. package com.itheima.Collection_nested_demo;
  3. import java.util.*;
  5. /*
  6.     List嵌套Map :
  8.     使用场景举例：一年级有多个班级，每个班级有多名学生。要求保存每个班级的学生姓名，姓名有与之对应的学号，保存一年级所有的班级信息。
  10.     思路：
  11.         1 可以使用Map集合保存一个班级的学生（键是学号，值是名字）
  12.         2 可以使用List集合保存所有班级
  14.     因此我们可以定义集合如下：
  16.     班级：Map<String,String> 键是学号，值是姓名
  17.         举例 :
  18.             Map<String,String> 三年一班 = {it001 = 迪丽热巴 , it002 = 古力娜扎 ,it003 = 马尔扎哈 ,it004 = 欧阳娜娜}
  19.             Map<String,String> 三年二班 = {it001 = 李小璐 , it002 = 白百何 , it003 = 马蓉}
  20.             Map<String,String> 三年三班 = {it001 = 林丹 ,it002 = 文章, it003 = 陈赫}
  22.     年级：List<Map<String,String>>保存每个班级的信息
  23.         举例 :
  24.               List<Map<String,String>> 年级 = {三年一班 , 三年二班 , 三年三班}
  25.  */
  26. public class Test2 {
  27.     public static void main(String[] args) {
  28.         Map<String, String> 三年一班 = new HashMap<>();
  29.         三年一班.put("it001", "迪丽热巴");
  30.         三年一班.put("it002", "古力娜扎");
  31.         三年一班.put("it003", "马尔扎哈");
  32.         三年一班.put("it004", "欧阳娜娜");
  35.         Map<String, String> 三年二班 = new HashMap<>();
  36.         三年二班.put("it001", "李小璐");
  37.         三年二班.put("it002", "白百何");
  38.         三年二班.put("it003", "马蓉");
  40.         Map<String, String> 三年三班 = new HashMap<>();
  41.         三年三班.put("it001", "林丹");
  42.         三年三班.put("it002", "文章");
  43.         三年三班.put("it003", "陈赫");
  46.         List<Map<String, String>> 年级 = new ArrayList<>();
  47.         年级.add(三年一班);
  48.         年级.add(三年二班);
  49.         年级.add(三年三班);
  51.         for (Map<String, String> 班级 : 年级) {
  52.             Set<String> studentId = 班级.keySet();
  53.             for (String id : studentId) {
  54.                 String name = 班级.get(id);
  55.                 System.out.println(id + "---" + name);
  56.             }
  57.             System.out.println("=================");
  58.         }
  59.     }
  60. }

6.3 Map嵌套Map

  1. package com.itheima.Collection_nested_demo;
  3. import java.util.*;
  5. /*
  6.     Map嵌套Map
  8.     使用场景举例：一个年级有多个班级，每个班级有多名学生。要求保存每个班级的学生姓名，姓名有与之对应的学号，保存一年级所有的班级信息，班级有与之对应的班级名称。
  10.     思路：
  11.     可以使用Map集合保存一个班级的学生（键是学号，值是名字）
  13.     可以使用Map集合保存所有班级（键是班级名称，值是班级集合信息）
  15.     因此我们可以定义集合如下：
  16.     班级： Map<String,String> 键：学号，值：姓名
  17.         举例 :
  18.             Map<String,String> 三年一班 = {it001 = 迪丽热巴 , it002 = 古力娜扎 ,it003 = 马尔扎哈 ,it004 = 欧阳娜娜}
  19.             Map<String,String> 三年二班 = {it001 = 李小璐 , it002 = 白百何 , it003 = 马蓉}
  20.             Map<String,String> 三年三班 = {it001 = 林丹 ,it002 = 文章, it003 = 陈赫}
  22.     年级： Map<String , Map<String,String>> 键：班级名称，值：具体班级信息
  23.         举例:
  24.             Map<String, Map<String,String>> 年级 = {"三年一班" = 三年一班 , "三年二班" = 三年二班 , "三年三班" = 三年三班 }
  26.  */
  27. public class Test3 {
  28.     public static void main(String[] args) {
  30.         Map<String, String> 三年一班 = new HashMap<>();
  31.         三年一班.put("it001", "迪丽热巴");
  32.         三年一班.put("it002", "古力娜扎");
  33.         三年一班.put("it003", "马尔扎哈");
  34.         三年一班.put("it004", "欧阳娜娜");
  37.         Map<String, String> 三年二班 = new HashMap<>();
  38.         三年二班.put("it001", "李小璐");
  39.         三年二班.put("it002", "白百何");
  40.         三年二班.put("it003", "马蓉");
  42.         Map<String, String> 三年三班 = new HashMap<>();
  43.         三年三班.put("it001", "林丹");
  44.         三年三班.put("it002", "文章");
  45.         三年三班.put("it003", "陈赫");
  48.         Map<String, Map<String, String>> 年级 = new HashMap<>();
  49.         年级.put("三年一班", 三年一班);
  50.         年级.put("三年二班", 三年二班);
  51.         年级.put("三年三班", 三年三班);
  53.         Set<String> 班级名字集合 = 年级.keySet();
  55.         for (String 班级名字 : 班级名字集合) {
  56.             Map<String, String> 班级信息 = 年级.get(班级名字);
  57.             Set<String> 学生学号 = 班级信息.keySet();
  58.             for (String 学号 : 学生学号) {
  59.                 String 姓名 = 班级信息.get(学号);
  60.                 System.out.println("班级名字:" + 班级名字 + " ,学号:" + 学号 + " , 名字:" + 姓名);
  61.             }
  62.             System.out.println("============");
  63.         }
  65.     }
  66. }

7 斗地主案例

  1. package com.itheima.doudizhu;
  3. import java.util.*;
  5. /*
  6.     按照斗地主的规则，完成洗牌发牌的动作。
  7.     要求完成以下功能：
  8.     准备牌：组装54张扑克牌
  9.     洗牌：54张牌顺序打乱
  10.     发牌：三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。
  11.     看牌：查看三人各自手中的牌（按照牌的大小排序）、底牌
  13.     规则：手中扑克牌从大到小的摆放顺序：大王,小王,2,A,K,Q,J,10,9,8,7,6,5,4,3
  15.  */
  16. public class DouDiZhu {
  17.     public static void main(String[] args) {
  18.         // 准备牌
  19.         // 键我牌的序号 , 值为牌面
  20.         HashMap<Integer, String> pokers = new HashMap<>();
  22.         // 牌的颜色
  23.         String[] colors = {"♠", "♥", "♣", "♦"};
  24.         String[] numbers = {"2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3"};
  25.         int count = 2;
  26.         for (String number : numbers) {// 3
  27.             for (String color : colors) {
  28.                 // System.out.println(count + " = " + color + number);
  29.                 pokers.put(count, color + number);
  30.                 count++;
  31.             }
  32.         }
  33.         pokers.put(0, "大王");
  34.         pokers.put(1, "小王");
  36.         System.out.println(pokers);
  38.         // 洗牌
  39.         Set<Integer> set = pokers.keySet();
  40.         // 创建存储编号的list集合
  41.         List<Integer> list = new ArrayList<>();// {10 , 6 , 8 , 20 , 22 , 11 ... }
  42.         // 把set集合中的元素存储到list集合中
  43.         list.addAll(set);
  44.         // 打乱集合中编号
  45.         Collections.shuffle(list);
  46.         System.out.println(list);
  48.         // 发牌
  49.         TreeSet<Integer> 赌神 = new TreeSet<>();
  50.         TreeSet<Integer> 赌圣 = new TreeSet<>();
  51.         TreeSet<Integer> 赌侠 = new TreeSet<>();
  52.         TreeSet<Integer> 底牌 = new TreeSet<>();
  53.         // 遍历牌的编号
  54.         for (int i = 0; i < list.size() - 3; i++) {
  55.             if (i % 3 == 0) {
  56.                 赌神.add(list.get(i));
  57.             } else if (i % 3 == 1) {
  58.                 赌圣.add(list.get(i));
  59.             } else {
  60.                 赌侠.add(list.get(i));
  61.             }
  62.         }
  64.         底牌.add(list.get(51));
  65.         底牌.add(list.get(52));
  66.         底牌.add(list.get(53));
  67.         System.out.println("赌神:" + 赌神);
  68.         System.out.println("赌圣:" + 赌圣);
  69.         System.out.println("赌侠:" + 赌侠);
  70.         System.out.println("底牌:" + 底牌);
  73.         // 看牌
  74.         // 赌神
  75.         lookPoker(pokers, 赌神, "赌神:  ");
  77.         // 赌圣
  78.         lookPoker(pokers, 赌圣, "赌圣:  ");
  80.         // 赌侠
  81.         lookPoker(pokers, 赌侠, "赌侠:  ");
  83.         // 底牌
  84.         System.out.print("底牌:  ");
  85.         for (Integer integer : 底牌) {
  86.             String poker = pokers.get(integer);
  87.             System.out.print(poker + "\t");
  88.         }
  90.     }
  92.     private static void lookPoker(HashMap<Integer, String> pokers, TreeSet<Integer> 赌神, String s) {
  93.         System.out.print(s);
  94.         for (Integer integer : 赌神) {
  95.             String poker = pokers.get(integer);
  96.             System.out.print(poker + "\t");
  97.         }
  98.         System.out.println();
  99.     }
  100. }