JAVA3-CSDN博客

本文链接：https://blog.csdn.net/Miracle5220/article/details/109661065

Java常用工具_API

API简介

(浏览器搜 java api 11)
Application Programming Interface，应用程序编程接口，这里指的是API文档，通常叫“Java文档”，是Java中提供
的类的使用说明书。Java中的类和方法几乎全部都添加了文档注释（/* 文档注释内容 */），这些文档注释就被Java
的命令（javadoc.exe，在JDK安装的bin目录下）编译成了Java文档，即API。
发挥面向对象思想，找到Java提供的对象来实现功能，学习API文档就是学习Java中的类的使用方法。开发Java程序的
过程中，想要使用Java提供的类的功能，就需要通过API文档来查找并使用。API是程序员和Java语言之间沟通的桥
梁。

使用步骤

搜索类
在搜索框里按类名模糊查询，或者通过文档顶部提供的层级结构查找。
查看类的包名
很多类在使用之前需要导包，所以要知道该类所属的包。每一个类都默认导入 java.lang 包，所以如果你使用的是该包下的类，则无须手动导包。
查看类的注释
使用一个类前，要知道该类的大致功能和它的定位，要知道一个类的能力边界，以便快速确定该类是不是你真正需要的。
查看构造方法（如有）
使用类之前要创建类的对象。如果是静态类或者一些工具类如 java.lang.Math 类，则不需要这么做。
查找需要的方法并使用
根据标识符的命名规则，可以快速定位方法的位置。仔细阅读方法的注释，注意区分重载方法的使用有何不同。如果找不到想要的方法，可能该方法在父类，或者更高的父类中。

moudle–>package–>class

Object类

类层次结构最顶层的基类，所有类都直接或间接的继承自Object类，所以，所有的类都是一个Object（对象）。
Java是严格的面向对象的语言，所以，所有的函数和数据都封装到类中（并非所有的编程语言都这样），通过类的对象来调用这些功能或实现某个算法。
在这里插入图片描述

构造方法
Object()：
构造一个对象。所有子类对象初始化时都会优先调用该方法

public Object()

成员方法
int hashCode()
返回对象的哈希码值，该方法通过对象的地址值进行计算，不同对象的返回值一般不同
Class<?> getClass()
返回调用此方法对象的运行时类对象（调用者的字节码文件对象）
String toString()
返回该对象的字符串表示
boolean equals()
返回其它某个对象是否与此对象“相等”。默认情况下比较两个对象的引用（地址值），建议重写

public class Test {
    public static void main(String[] args) {
        Object obj1 = new Object();
        Object obj2 = new Object();
        int code1=obj1.hashCode();
        System.out.println(code1);  //189568618
        Class cl1=obj1.getClass();
        System.out.println(cl1);  //class java.lang.Object
        String s1=obj1.toString();
        System.out.println(s1);   //java.lang.Object@b4c966a
        boolean b1=obj1.equals(obj2);
        System.out.println(b1);  //false
    }
}

重写Object类的方法： alt+insert快捷生成（一般都会重写 toString() 和 equals(））

Scanner类

扫描器。能够解析字符串（String）和基本数据类型的数据
在这里插入图片描述
构造方法
Scanner(InputStream)：构造一个扫描器对象，从指定输入流中获取数据参数System.in，对应键盘录入

成员方法
hasNextXxx()
判断是否还有下一个输入项，其中Xxx可能是任意基本数据类型，返回结果为布尔类型
nextXxx()
获取下一个输入项，其中Xxx可能是任意基本数据类型，返回对应类型的数据
String nextLine()
获取下一行数据。以换行符作为分隔符。
String next()
获取下一个输入项，以空白字符作为分隔符空白字符：空格、tab、回车等
开发最常用：sc.nextInt()，sc.nextLine()

public class Test2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        //接收整数
//        System.out.println("输入整数");
//        if(sc.hasNextInt()){   //判断录入的是否是整数
//            int num = sc.nextInt();
//            System.out.println("num:" + num);

        //接收字符串类型数据
        System.out.println("输入字符串");
//        String str1 = sc.nextLine(); //(结束标记：换行符)  //abc  bcd e
//        System.out.println("str1:" + str1);   //abc  bcd e

        String str2 = sc.next();   // （结束标记：空白字符(空格，tab,换行符)） //abc  bcd e
        System.out.println("str2:" + str2);  //abc 
    }
}

String类

字符串。每一个字符串对象都是常量。
在这里插入图片描述
构造方法
String(byte[])：
构造一个String对象，将指定字节数组中的数据转化成字符串
String(char[])：
构造一个String对象，将指定字符数组中的数据转化成字符串

成员方法
判断方法
boolean equals(String)
判断当前字符串与给定字符串是否相同，区分大小写
boolean equalsIgnoreCase(String)
判断当前字符串与给定字符串是否相同，不区分大小写
boolean startWith(String)
判断是否以给定字符串开头

public class Test3 {
    public static void main(String[] args) {
        byte[] bys = {97, 98};
        String s1 = new String(bys);
        System.out.println(s1);  //ab

        char[] cha = {'h', 'e'};
        String s2 = new String(cha);
        System.out.println(s2);  //he
        
        //免new操作
        String s3 = new String("abc");
        String s4 = "abc";

        String str1 = "abc";
        String str2 = "ABC";
        boolean b1 = str1.equals(str2);
        System.out.println("equals():" + b1);  //equals()false
        boolean b2 = str1.equalsIgnoreCase(str2);
        System.out.println("equalsIgnoreCase():" + b2);//equalsIgnoreCase()true
        System.out.println(s1.startsWith("a"));//true
        System.out.println(s1.isEmpty());  //false
    }
}

在这里插入图片描述
获取方法
int length()：
获取当前字符串的长度
char charAt(int index)：
获取指定索引位置的字符
int indexOf(String)：
获取指定字符（串）第一次出现的索引
int lastIndexOf(String)：
获取指定字符（串）最后一次次出现的索引
String substring(int)：
获取指定索引位置（含）之后的字符串
String substring(int, int)：
获取从索引start位置（含）起至索引end位置（不含）的字符串

public class Test4 {
    public static void main(String[] args) {
        String str="我 aa今年b 18岁b了";
        System.out.println(str.length());
        System.out.println(str.charAt(5));
        System.out.println(str.indexOf("a"));
        System.out.println(str.lastIndexOf("b"));
        System.out.println(str.substring(5,11)); //[ , )
    }
}
13
年
2
11
年b 18岁

在这里插入图片描述
转换方法
byte[] getBytes()：
将字符串转换成字节数组
char[] toCharArray()：
将字符串转换成字符数组
static String valueOf(…) ：
将指定类型数据转换成字符串
String replace(old, new)：
将指定字符（串）替换成新的字符（串）
String[] split(String)：
切割字符串，返回切割后的字符串数据，原字符串不变
String trim()：
去掉字符串两端的空白字符

public class Test5 {
    public static void main(String[] args) {
        String s1 = "abc";
        byte[] bys = s1.getBytes();
        for (int i = 0; i < bys.length; i++) {
            System.out.println(bys[i]);
        }
        char[] ch = s1.toCharArray();
        for (int i = 0; i < ch.length; i++) {
            System.out.println(ch[i]);
        }
        String s2 = String.valueOf(123);
        System.out.println(s2 + 4);
        String s3 = "" + 123;
        System.out.println(s3 + 4);

        String s4="abc abc";
        String s5=s4.replace('b','d');
        System.out.println(s5);

        String[] arr=s4.split(" ");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        String s6="  a  b  c  ";
        System.out.println(s6.trim());  //两端空格
    }
}
97
98
99
a
b
c
1234
1234
adc adc
abc
abc
a  b  c

StringBuilder和StringBuffer类

可变字符序列，用于构造字符串对象。内部使用自动扩容的数组操作字符串数据。StringBuilder和StringBuffer使用
相同的API
在这里插入图片描述
构造方法
StringBuilder()
构造一个空的StringBuilder容器
StringBuilder(String)
构造一个StringBuilder容器，并添加指定字符串

成员方法
StringBuilder append(…)
将任意数据添加到StringBuilder容器中
String toString()
将当前StringBuilder容器转成字符串

public class Test6 {
    public static void main(String[] args) {
        //测试构造方法
        StringBuilder sb = new StringBuilder();
        sb.append("abc");   //返回自身
//        StringBuilder sb2= sb.append("abc");
        System.out.println("sb:" + sb);
//        System.out.println("sb2:"+ sb2);
        StringBuilder sb3 = new StringBuilder("abc");
        System.out.println("sb3:" + sb3);
        //测试成员方法
        StringBuilder sb4 = new StringBuilder();
        sb4.append("a");
        sb4.append("b");
        System.out.println("sb4:" + sb4);
        String s = sb4.toString();
        System.out.println("s:" + s);
    }
}
sb:abc
sb3:abc
sb4:ab
s:ab

Date和Calendar类

日期和日历类，用于操作日期相关信息。
在这里插入图片描述
构造方法
Date()：
构造一个日期对象，当前系统时间，精确到毫秒
Date(long)：
构造一个日期对象，时间为自“1970年1月1日00:00:00 GMT”起，至指定参数的毫秒数

成员方法
long getTime()：
将日期对象转换成对应时间的毫秒值
static Calendar getInstance()：
根据当前系统时区和语言环境获取日历对象
int get(int field)：
返回给定日历字段的值
void set(int field, int value)
将给定的日历字段设置为指定的值

public class Test7 {
    public static void main(String[] args) {
        Date date1 = new Date();
        System.out.println(date1);  //Fri Nov 13 16:50:11 CST 2020
        long time = date1.getTime();
        System.out.println(time);  //1605257411315

        Calendar c = Calendar.getInstance();
        System.out.println(c);
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH);
        int day = c.get(Calendar.DATE);
        System.out.println(year+"年"+month +"月"+ day);  //2020年10月13
        c.set(2020, 4, 4);
        int year2 = c.get(Calendar.YEAR);
        int month2 = c.get(Calendar.MONTH);
        int day2 = c.get(Calendar.DATE);
        System.out.println(year2+"年"+month2 +"月"+ day2); //2020年4月4
    }
}

基本类型的包装类

基本数据类型不是对象，所以Java针对基本类型提供了对应的包装类，以对象的形式来使用。
在这里插入图片描述
装箱
基本类型转包装类型（对象类型）
拆箱
包装类型（对象类型）转基本类型
成员方法
基本类型 parseXxx(String)：
将字符串类型的数据转换成对应的基本类型

public class Test8 {
    public static void main(String[] args) {
        //a属于基本类型。不能通过 对象名. 的形式调用
        int a = 10;
        //基本类型转引用类型(装箱) (已过时)
        Integer i1 = new Integer(20);
        //拆箱 (已过时)
        int b = i1.intValue();
        System.out.println(i1);  //20
        System.out.println(b);   //20

        //基本类型转引用类型(装箱)
        Integer i2 = 30;
        //拆箱
        int c = i2;
        //字符串类型10 转int 10
        String s = "10";
        int num = Integer.parseInt(s);
        System.out.println(num);  //10
       //除了Character类以外，剩下的7种包装类都有型 parseXxx方法
       //字符串转char类型，可通过String类中的方法 toCharArray(),charAt()
    }
}

Java常用工具_集合

集合简介

什么是集合？
简称集，是用来存储多个元素的容器
集合和数组的区别
元素类型
集合：引用类型（存储基本类型时自动装箱）
数组：基本类型、引用类型
元素个数
集合：不固定，可任意扩容
数组：固定，不能改变容量
集合的好处
不受容器大小限制，可以随时添加、删除元素
提供了大量操作元素的方法（判断、获取等）
Java的集合体系
单列集合（Collection）
List
ArrayList
Set
HashSet
双列集合（Map： key，value ）
Map
HashMap
在这里插入图片描述

List集合的特点和应用

特点：
可重复、有序（存取顺序相同）
List是接口, 所以可以通过创建其子类ArrayList对象来完成该接口的实例化.

List list = new ArrayList();

List接口中的成员方法:

 public boolean add(E e);  //将数据添加到集合的末尾, 这里的E是泛型的意思, 目前可以先理解为Object类型.
 public E get(int index);  //根据索引, 索取其对应的元素.
  public int size();        //获取集合的长度.

   使用集合的步骤:
        1. 创建集合对象.
        2. 创建元素对象.
        3. 将元素对象添加到集合对象中.
        4. 遍历集合.

public class Test {
    public static void main(String[] args) {
        //需求: 往List集合中添加3个学生对象, 然后遍历.
        //1. 创建集合对象.
        List list = new ArrayList();
        //2. 创建元素对象.
        Student s1 = new Student("乔峰",41);
        Student s2 = new Student("乔峰",41);
        Student s3 = new Student("虚竹",38);
        Student s4 = new Student("段誉",26);
        //3. 将元素对象添加到集合对象中.
        /*boolean b1 = list.add(s1);  System.out.println(b1);
          boolean b2 = list.add(s1); System.out.println(b2);*/
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);
        //直接打印集合
        System.out.println(list);
        //获取索引为2的元素
        Object obj = list.get(2);
        System.out.println("索引为2的元素是: " + obj);
        //获取集合中的元素个数
        System.out.println("集合的长度为: " + list.size());
        //4. 遍历集合.
        for (int i = 0; i < list.size(); i++) {
            //i表示的就是集合中每个元素的索引
            //获取元素
            Object obj2 = list.get(i);
            System.out.println("索引为 " + i + "的元素是: " + obj2 );
        }
    }
}
[Student{name='乔峰', age=41}, Student{name='乔峰', age=41}, Student{name='虚竹', age=38}, Student{name='段誉', age=26}]
索引为2的元素是: Student{name='虚竹', age=38}
集合的长度为: 4
索引为 0的元素是: Student{name='乔峰', age=41}
索引为 1的元素是: Student{name='乔峰', age=41}
索引为 2的元素是: Student{name='虚竹', age=38}
索引为 3的元素是: Student{name='段誉', age=26}

增强for循环和迭代器

增强for循环：简化数组和集合的遍历
快捷键：iter

for(数据类型 变量名 : 数组或者集合对象) {
// 循环体，变量即元素
}
 for (Object obj : list) {
            System.out.println(obj);
 }

迭代器：对过程的重复，称为迭代。
迭代器是遍历 Collection 集合的通用方式，可以在对集合遍历的同时进行添加、删除等操作。
迭代器的常用方法
E next()：返回迭代的下一个元素对象
boolean hasNext()：如果仍有元素可以迭代，则返回true
注意:
列表迭代器是List体系独有的遍历方式, 可以在对集合遍历的同时进行添加、删除等操作。
但是必须通过调用列表迭代器的方法来实现.
使用步骤:
1. 根据集合对象获取其对象的迭代器对象.
2. 判断迭代器中是否有元素.
3. 如果有就获取元素.
总结:
普通的迭代器在遍历集合的同时不能添加或者删除元素, 否则会报: 并发修改异常.
列表迭代器在遍历集合的同时可以修改集合中的元素(添加, 删除等), 必须使用列表迭代器中的方法.

public class Test {
    public static void main(String[] args) {
        //需求: 通过迭代器遍历List集合.
        //1. 创建集合对象.
        List list = new ArrayList();
        //2. 创建元素对象.
        //3. 将元素对象添加到集合对象中.
        list.add("a");
        list.add("b");
        list.add("c");
        //4. 遍历集合.
        //迭代器的用法
       //1. 根据集合对象获取其对象的迭代器对象.
        Iterator it = list.iterator();
        //2. 判断迭代器中是否有元素.
        while(it.hasNext()) { //如果迭代器中有元素, 就一直迭代.
            //3. 如果有就获取元素.
            String s = (String)it.next();
            System.out.println(s);
        }
        
        //需求: 判断集合中如果有字符串"b", 就在其后边添加一个新的字符串: java
        //1. 根据集合对象获取列表迭代器对象.
        ListIterator lit = list.listIterator();
        //2. 判断迭代器中是否有元素.
        while(lit.hasNext()) {//如果迭代器中有元素, 就一直迭代.
            //3. 有就获取元素即可.
            String s = (String)lit.next(); 
            if ("b".equals(s)) {   //这样写可以规避: 空指针异常
                //list.add("java");  //这样写不行, 必须调用列表迭代器的方法来实现.
                lit.add("java");
            }
            System.out.println(s);
        }
        //打印新的集合中的值
        System.out.println(list);
    }
}
a
b
c
[a, b, java, c]

泛型简介

泛指任意类型，又叫参数化类型（ParameterizedType），对具体类型的使用起到辅助作用，类似于方法的参数。
集合类泛型的解释：表示该集合中存放指定类型的元素
（给List集合加上泛型Student）

List<Student> list = new ArrayList<>();

泛型的好处：
类型安全
避免了类型转换
泛型一般只和集合类相结合使用.
泛型是JDK5的新特性, 但是从JDK7开始,后边的泛型可以不用写具体的数据类型了(菱形泛型.)

  List<String> list2 = new ArrayList<>();

public class Test3 {
    public static void main(String[] args) {
    //不使用泛型的集合
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        //list1.add(10);  会报类型转换异常(ClassCastException)
        for (Object obj : list) {
            String s = (String) obj;
            System.out.println(s);
        }
    //需求: 演示泛型
        List<String> list2 = new ArrayList<String>();
        list2.add("abc");
        list2.add("b");
        list2.add("c");
        // list2.add(14);  //直接会标红  //类型安全
        for (String s : list2) {  //避免了类型转换
            System.out.println(s);
        }
    }
}

Collections工具类

针对集合进行操作的工具类。
成员方法
根据比较器规则对列表进行排序

sort(List<T>,Comparator<T>)

返回集合的最大元素

max(Collection<T>)

反转List集合元素

reverse(List<T>)

根据自然顺序返回最大元素

shuffle(List<T>)

public class Test4 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(3);
        list.add(3);
        list.add(5);
        list.add(2);
        list.add(2);
        list.add(4);
        System.out.println("没有操作以前, 集合中的数据是: " + list);
        Integer max = Collections.max(list);
        System.out.println("集合中的最大元素为: " + max);
        Collections.sort(list);
        System.out.println("升序排列后的结果为: " + list);
        Collections.reverse(list);
        System.out.println("反转以后集合中的数据为: " + list);
        Collections.shuffle(list);
        System.out.println("随机置换后的结果为: " + list);
    }
}
没有操作以前, 集合中的数据是: [1, 3, 3, 5, 2, 2, 4]
集合中的最大元素为: 5
升序排列后的结果为: [1, 2, 2, 3, 3, 4, 5]
反转以后集合中的数据为: [5, 4, 3, 3, 2, 2, 1]
随机置换后的结果为: [5, 4, 2, 2, 1, 3, 3]

Set集合的特点

特点：不可重复、无序

Set<T> set = new HashSet<>();

Set集合保证元素的唯一性,依赖 equals(), hashCode()两个方法.

public class Test5 {
    public static void main(String[] args) {
        Set<Student> set = new HashSet<>();
        Student s1 = new Student("乔峰", 41);
        Student s2 = new Student("虚竹", 38);
        Student s3 = new Student("段誉", 26);
        Student s4 = new Student("乔峰", 41);
        Student s5 = new Student("虚竹", 38);
        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);
        set.add(s5);
        System.out.println(set);
        //4. 遍历集合.
        /*
            为什么Set集合没有"去重"?
                因为Set集合保证元素的唯一性依赖: equals() 和 hashCode()两个方法.
                你没有在Student类中重写这两个方法, 默认调用的是Object类中的这两个方法.
                而Object类中的equals()方法默认比较的是地址值是否相同.
            解决方案:  在Student类中重写equals()和hashCode()方法.
         */
        //通过迭代器遍历Set集合
        //A. 通过集合对象获取其对应的迭代器对象.
        Iterator<Student> it= set.iterator();
        //B. 判断迭代器中是否有元素.
        while(it.hasNext()) {
            //C. 如果有, 就获取元素.
            Student s = it.next();
            System.out.println(s);
        }
        //通过增强for遍历Set集合
        for (Student student : set) {
            System.out.println(student);
        }
    }
}

public class Student {
    //成员变量
    private String name;
    private int age;
    //有参，无参构造
    //get(),set()
    //快捷键alt+insert 重写equals() 和 hashCode()
}

Map集合的特点和应用

双列集合，元素由键值对（Entry）构成： key – value key不可以重复，value可以重复

Map<T1, T2> map = new HashMap<>();  //  T1: 表示键的数据类型., T2: 表示值的数据类型

public class Test6 {
    public static void main(String[] args) {
        //需求: 往Map集合中添加3个学生对象, 然后打印.
        //1. 创建集合对象.
        Map<Integer, Student> map = new HashMap<>();
        //2. 创建元素对象.
        Student s1 = new Student("张三", 23);
        Student s2 = new Student("李四", 24);
        Student s3 = new Student("张三", 23);
 /*       Student stu1 = map.put(1, s1);
//        V put(K key,V value);  添加元素(键值对的形式),
//                元素第一次添加, 返回null,
//                重复添加, 会用新值覆盖旧值, 并返回旧值.
                System.out.println("stu1: " + stu1); //stu1: null
        Student stu2 = map.put(1, s2);
        System.out.println("stu2: " + stu2); //stu2: Student{name='张三', age=23}
        System.out.println(map);  //{1=Student{name='李四', age=24}}*/
        //3. 将元素对象添加到集合中.
        map.put(1, s1);
        map.put(2, s2);
        map.put(3, s3);
        System.out.println(map);//{1=Student{name='张三', age=23}, 2=Student{name='李四', age=24}, 3=Student{name='张三', age=23}}
//根据键,获取值
        Student stu3 = map.get(2);
        System.out.println("key" + 2 + ",value" + stu3);
        //4. 遍历集合.

       //4.1. 获取所有键的集合.    keySet()
        Set<Integer> keys = map.keySet();
        //  4.2. 遍历所有的键, 获取到每一个键.     迭代器/增强for.
        //获取迭代器对象
        Iterator<Integer> it = keys.iterator();
        while (it.hasNext()) {
            //如果迭代器中有数据, 就获取.
            Integer key = it.next();
            // 4.3. 根据键, 获取指定的值.       get()
            Student value = map.get(key);
            System.out.println("key" + key + "...value" + value);
        }

        //通过增强for实现
        Set<Integer> keys = map.keySet();
        for (Integer key : keys) {
            Student value = map.get(key);
            System.out.println(key + "..." + value);
        }
    }
}
1...Student{name='张三', age=23}
2...Student{name='李四', age=24}
3...Student{name='张三', age=23}

案例：模拟斗地主发牌

public class SendPockerTest {
    public static void main(String[] args) {
        //1. 买牌.
        //1.1 定义一个双列集合, 键: 表示牌的编号, 值: 表示具体的牌.  规则: 编号越小, 牌越小.
        Map<Integer, String> pokers = new HashMap<>();
        //1.2 定义一个单列集合, 用来存储所有牌的编号
        List<Integer> list = new ArrayList<>();
        //1.3 具体的买牌动作.
        //普通牌, 52.
        String[] colors = {"♠", "♥", "♣", "♦"};
        String[] numbers = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
        int num = 0;    //表示牌的编号
        for (String number : numbers) {  //外循环, 获取所有的点数
            for (String color : colors) {//内循环, 获取所有的花色
                String poker = color + number;
                //将牌的编号, 具体的牌放到双列集合中.
                pokers.put(num, poker);
                //将牌的编号放到单列集合中.
                list.add(num);
                //每添加一张牌, 编号要自增1.
                num++;
            }
        }
        //大小王.
        //添加小王
        pokers.put(num, "小王");
        list.add(num++);
        //添加大王
        pokers.put(num, "大王");
        list.add(num);
        //打印牌就可以了.
        System.out.println("所有的牌: " + pokers);
        System.out.println("牌的编号:" + list);

        //2. 洗牌
        Collections.shuffle(list);
        System.out.println("洗好牌后, 编号为: " + list);

        //3. 发牌
        //3.1 定义4个集合, 分别表示3个玩家, 底牌.
        List<Integer> liuyifei = new ArrayList<>();
        List<Integer> zhaoliying = new ArrayList<>();
        List<Integer> xiaohei = new ArrayList<>();
        List<Integer> dipai = new ArrayList<>();
        //3.2 具体的发牌动作, 将索引和3取模, 决定发给谁.
        for (int i = 0; i < list.size(); i++) {
            //获取编号
            Integer pokerNum = list.get(i);  //i索引
            if (i >= list.size() - 3) {
                //底牌
                dipai.add(pokerNum);
            } else if (i % 3 == 0) {
                liuyifei.add(pokerNum);
            } else if (i % 3 == 1) {
                zhaoliying.add(pokerNum);
            } else if (i % 3 == 2) {
                xiaohei.add(pokerNum);
            }
        }
             /*//3.3 查看玩家, 底牌的编号.
        System.out.println("liuyifei: " + liuyifei);
        System.out.println("zhaoliying: " + zhaoliying);
        System.out.println("xiaohei: " + xiaohei);
        System.out.println("dipai: " + dipai);*/

        //4. 查看具体的牌
        /*String str = printPoker(liuyifei, pokers);
        System.out.println("liuyifei: " + str);*/

        System.out.println("liuyifei: " + printPoker(liuyifei, pokers));
        System.out.println("zhaoliying: " + printPoker(zhaoliying, pokers));
        System.out.println("xiaohei: " + printPoker(xiaohei, pokers));
        System.out.println("dipai: " + printPoker(dipai, pokers));

    }

    /*
        4. 定义一个方法, 用来看牌
            方法名:   printPoker
            参数列表: List<Integer>, Map<Integer, String>
            返回值:  String
     */
    public static String printPoker(List<Integer> nums, Map<Integer, String> pokers) {
        //1. 对牌的编号进行升序排列.
        Collections.sort(nums);
        //2. 遍历牌的编号集合, 获取到每一个编号.
        StringBuilder sb = new StringBuilder();
        for (Integer num : nums) {
            //num就是要查找的具体牌的 编号.
            //3. 根据编号去双列集合中查找该编号对应的具体牌.
            String poker = pokers.get(num);
            //4. 将获取到的牌进行拼接.
            sb.append(poker + " ");
        }
        //5. 将最后拼接结果返回即可.
        String str = sb.toString();
        return str.trim();
    }
}