Ming-Log's Blog

记录生活中的点点滴滴

0%

Java(20)Collection和泛型

发表于 更新于 分类于
本文字数： 16k 阅读时长 ≈ 14 分钟

Collection

Collection接口

java.util.Collection接口

image-20211220110825264

所有单列集合的最顶层的接口，里面定义了所有单列集合共性的方法

任意的单列集合都可以使用Collection接口中的方法

共性的方法：

  • public boolean add(E e)： 把给定的对象添加到当前集合中 。
  • public void clear():清空集合中所有的元素。
  • public boolean remove(E e): 把给定的对象在当前集合中删除。
  • public boolean contains(E e): 判断当前集合中是否包含给定的对象。
  • public boolean isEmpty(): 判断当前集合是否为空。
  • public int size(): 返回集合中元素的个数。
  • public Object[] toArray(): 把集合中的元素，存储到数组中。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
package com.tipdm.Demo01;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

public class demo1 {
    public static void main(String[] args) {
        // 创建集合对象，可以使用多态
        Collection<String> coll = new ArrayList<>();
        System.out.println(coll);  // []  重写了toString()方法

        /**
         * public boolean add(E e)：  把给定的对象添加到当前集合中 。
         * 返回值是一个boolean值，一般都返回true，所有可以不用接收
         */
        boolean b1 = coll.add("张三");  // 如果存入成功返回true
        System.out.println("bi1:" + b1);  // bi:true
        System.out.println(coll);  // [张三]
        coll.add("李四");
        coll.add("王五");
        coll.add("赵六");
        coll.add("田七");
        System.out.println(coll);  // [张三, 李四, 王五, 赵六, 田七]
        System.out.println("==================");
        /**
         * public boolean remove(E e): 把给定的对象在当前集合中删除。
         * 返回值是boolean值
         *      集合中存在元素，删除元素，返回true
         *      集合中不存在元素，删除失败，返回false
         */
        boolean b2 = coll.remove("赵六");
        boolean b3 = coll.remove("赵四");
        System.out.println("b2:" + b2);  // b2:true
        System.out.println("b3:" + b3);  // b3:false
        System.out.println(coll);  // [张三, 李四, 王五, 田七]

        System.out.println("================");
        /**
         * public boolean contains(E e): 判断当前集合中是否包含给定的对象。
         * 如果包含返回true，不包含返回false
         */
        boolean b4 = coll.contains("李四");
        boolean b5 = coll.contains("赵四");
        System.out.println("b4:" + b4);  // b4:true
        System.out.println("b5:" + b5);  // b5:false
        System.out.println("==============");

        /**
         * public boolean isEmpty(): 判断当前集合是否为空。
         */
        boolean b6 = coll.isEmpty();
        System.out.println("b6:" + b6);
        System.out.println("==============");

        /**
         * public int size(): 返回集合中元素的个数。
         */
        int n = coll.size();
        System.out.println("n:" + n);
        System.out.println("=============");

        /**
         * public Object[] toArray(): 把集合中的元素，存储到数组中。
         */
        Object[] str1 = coll.toArray();
        // 遍历数组
        for (int i = 0; i < str1.length; i++) {
            System.out.println(str1[i]);
        }
        System.out.println("============");

        /**
         * public void clear():清空集合中所有的元素。
         */
        coll.clear();
        System.out.println(coll);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
[]
bi1:true
[张三]
[张三, 李四, 王五, 赵六, 田七]
==================
b2:true
b3:false
[张三, 李四, 王五, 田七]
================
b4:true
b5:false
==============
b6:false
==============
n:4
=============
张三
李四
王五
田七
============
[]

进程已结束,退出代码0

Iterator接口

java.util.Iterator接口:迭代器(对集合进行遍历)

有两个常用的方法

1
boolean hasNext()    如果仍有元素可以迭代，则返回 true。

判断集合中还有没有下一个元素，有就返回true，没有就返回false

1
E next()  返回迭代的下一个元素。

取出集合中的下一个元素

Iterator迭代器，是一个接口，我们无法直接使用，需要使用Iterator接口的实现类对象，获取实现类的方式比较特殊

Collection接口中有一个方法，叫iterator(),这个方法返回的就算迭代器的实现类对象

Iterator iterator() 返回在此 collection 的元素上进行迭代的迭代器。

迭代器的使用步骤（重点）：

  1. 使用集合中的方法iterator()获取迭代器的实现类对象，使用Iterator接口接收(多态)

  2. 使用Iterator()接口中的方法hasNext判断还有没有下一个元素

  3. 使用Iterator()接口中的next方法取出集合中的下一个元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package com.tipdm.Demo01;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class demo2 {
    public static void main(String[] args) {
        // 创建一个集合对象
        Collection<String> coll = new ArrayList<>();
        // 往集合中添加元素
        coll.add("姚明");
        coll.add("科比");
        coll.add("麦迪");
        coll.add("詹姆斯");
        coll.add("艾弗森");

        /**
         * 1. 使用集合中的方法iterator()获取迭代器的实现类对象，使用Iterator接口接收(多态)
         * 注意：
         *      Iterator<E> 接口也是有泛型的，迭代器的泛型跟着集合走，集合是什么泛型，迭代器就是什么泛型
         */

        // 多态    接口                  实现类对象
        Iterator<String> it = coll.iterator();
        System.out.println(coll);
        System.out.println("================");
        while(it.hasNext()){
            System.out.println(it.next());
        }
//        it.next();  // 没有元素，再取出元素会抛出异常：NoSuchElementException
    }
}
1
2
3
4
5
6
7
8
9
[姚明, 科比, 麦迪, 詹姆斯, 艾弗森]
================
姚明
科比
麦迪
詹姆斯
艾弗森

进程已结束,退出代码0

增强for循环

增强for循环：底层使用的也是迭代器，使用for循环的格式，简化了迭代器的书写

是JDK1.5之后出现的新特性

1
public interface Collection<E>extends Iterable<E>

实现这个接口允许对象成为 “foreach” 语句的目标。内部就是使用的迭代器

增强for循环：用来遍历集合和数组

格式：

1
2
3
for(集合/数组的数据类型 变量名：集合名/数组名){
sout(变量名)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
package com.tipdm.Demo01;

import java.util.ArrayList;
import java.util.Collection;

/**
 * 增强for循环：底层使用的也是迭代器，使用for循环的格式，简化了迭代器的书写
 * 是JDK1.5之后出现的新特性
 * public interface Collection<E>extends Iterable<E>
 *     实现这个接口允许对象成为 "foreach" 语句的目标。内部就是使用的迭代器
 *
 * 增强for循环：用来遍历集合和数组
 *
 * 格式：
 *      for(集合/数组的数据类型 变量名：集合名/数组名){
 *          sout(变量名)
 *      }
 */
public class demo3 {
    public static void main(String[] args) {
        demo01();
        System.out.println("==================");
        demo02();
    }

    // 使用增强for循环遍历数组
    private static void demo01() {
        int[] arr = {1, 2, 3, 4, 5};
        for (int i : arr) {
            System.out.println(i);
        }
    }

    // 使用增强for循环遍历集合
    private static void demo02() {
        // 创建一个集合对象
        Collection<String> coll = new ArrayList<>();
        // 往集合中添加元素
        coll.add("姚明");
        coll.add("科比");
        coll.add("麦迪");
        coll.add("詹姆斯");
        coll.add("艾弗森");
        for (String s : coll) {
            System.out.println(s);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
1
2
3
4
5
==================
姚明
科比
麦迪
詹姆斯
艾弗森

进程已结束,退出代码0

泛型

泛型：是一种未知的数据类型，当我们不知道使用什么数据类型的时候，可以使用泛型。

image-20211220110855452

为什么要使用泛型

1
2
3
E e：Element 元素

T t：Type 类型
1
2
3
4
5
6
* ArrayList集合在定义的时候，不知道集合中都会存储什么类型的数据，所以类型使用泛型
* E:未知的数据类型
* public class ArrayList<E>{                    创建集合对象的时候，就会确定泛型的数据类型
*     public boolean add(E, e){}                ArrayList<String> list = new ArrayList<String>();
*     public E get(int index){}
* }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
package com.tipdm.Demo02;

import java.util.ArrayList;
import java.util.Iterator;

/**
 * 泛型：是一种未知的数据类型，当我们不知道使用什么数据类型的时候，可以使用泛型
 * 泛型也可以看成是一个遍历，用来接收数据类型
 *      E e：Element 元素
 *      T t：Type 类型
 * ArrayList集合在定义的时候，不知道集合中都会存储什么类型的数据，所以类型使用泛型
 * E:未知的数据类型
 * public class ArrayList<E>{                    创建集合对象的时候，就会确定泛型的数据类型
 *     public boolean add(E, e){}                ArrayList<String> list = new ArrayList<String>();
 *     public E get(int index){}
 * }
 */
public class Demo01Generic {
    public static void main(String[] args) {
        show01();
        System.out.println("=============");
        show02();
    }

    /**
     * 创建集合对象，使用泛型
     * 好处：
     *      1. 避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型
     *      2. 把运行期异常（代码运行之后会抛出的异常），提升到了编译器（写代码的时候会报错）
     * 弊端：
     *      泛型是什么类型，只能存储什么类型的数据
     */
    private static void show02() {
        ArrayList<String> list = new ArrayList<>();
        list.add("abc");
//        list.add(123);  // 不能放入整数
        list.add("qwe");
        list.add("q123");
        // 使用迭代器遍历list集合
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }

    /**
     * 创建集合对象，不使用泛型
     * 好处：
     *      集合不使用泛型，默认的类型就算Object类型，可以存储任意类型的数据
     * 弊端：
     *      不安全，会引发异常
     */
    private static void show01() {
        ArrayList list = new ArrayList();
        list.add("abc");
        list.add(1);

        // 使用迭代器遍历list集合
        Iterator it = list.iterator();
        // 使用迭代器中的方法hasNext和next遍历集合
        while(it.hasNext()){
            // 取出元素也是Object类型
            Object obj = it.next();
            System.out.println(obj);

            // 想要使用类特有的方法，length获取字符串长度；不能使用  多态 Object obj = "abc";
            // 需要向下转型
//            String s = (String) obj;   // 第二次遍历时会抛出ClassCastException异常，不能把Integer类型转化为String
//            System.out.println(s.length());
        }
    }
}
1
2
3
4
5
6
7
8
abc
1
=============
abc
qwe
q123

进程已结束,退出代码0

泛型的定义与使用

定义一个含有泛型的类，模拟ArrayList集合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.tipdm.Demo02;

/**
 * 定义一个含有泛型的类，模拟ArrayList集合
 * 泛型是一个未知的数据类型，当我们不确定什么数据类型的时候，可以使用泛型
 * 泛型可以接收任意的数据类型，可以是使用Integer，String，Student...
 * 创建对象的时候确定泛型的数据类型
 */
public class GenericClass<E>{
    private E name;

    public E getName() {
        return name;
    }

    public void setName(E name) {
        this.name = name;
    }
}

调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package com.tipdm.Demo02;


/**
 * 泛型的定义与使用：
 * 我们在集合中会大量使用到泛型。
 * 泛型，用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递。
 */
public class Demo02Generic {
    public static void main(String[] args) {
        // 不写泛型默认为Object
        GenericClass gc = new GenericClass();
        gc.setName("字符串");
        Object obj = gc.getName();
        System.out.println(obj);
        System.out.println("====================");

        // 创建GenericClass对象，泛型使用Integer类型
        GenericClass<Integer> gc1 = new GenericClass<>();
        gc1.setName(123);
        int name = gc1.getName();
        System.out.println(name);
        System.out.println("=============");

        // 创建GenericClass对象，泛型使用boolean类型
        GenericClass<Boolean> gc2 = new GenericClass<>();
        gc2.setName(true);
        boolean name2 = gc2.getName();
        System.out.println(name2);
    }
}
1
2
3
4
5
6
7
字符串
====================
123
=============
true

进程已结束,退出代码0

含有泛型的方法

定义含有泛型的方法：泛型定义在方法的修饰符和返回值类型之间

格式：

1
2
3
修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)){
方法体;
}

含有泛型的方法，在调用方法的时候确定泛型的数据类型

传递什么类型的参数，泛型就是什么类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package com.tipdm.Demo02;

/**
 * 定义含有泛型的方法：泛型定义在方法的修饰符和返回值类型之间
 * 格式：
 *      修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)){
 *          方法体;
 *      }
 * 含有泛型的方法，在调用方法的时候确定泛型的数据类型
 * 传递什么类型的参数，泛型就是什么类型
 */
public class GenericMethod {
    // 定义一个含有泛型的方法
    public <M> void method01(M m){  // 想要使用泛型必须先定义<M>
        System.out.println(m);
    }

    // 定义一个含有泛型的静态方法
    public static <S> void method02(S s){
        System.out.println(s);
    }
}

调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.tipdm.Demo02;

/**
 * 测试含有泛型的方法
 */
public class Demo03GenericMethod {
    public static void main(String[] args) {
        // 创建GenericMethod方法对象
        GenericMethod gm = new GenericMethod();

        /**
         * 调用含有泛型的方法method01
         * 传递什么类型，泛型就是什么类型
         */
        gm.method01(10);
        gm.method01(10.0);
        gm.method01("10.1");
        gm.method01(true);
        System.out.println("================s");
        GenericMethod.method02("静态方法：123");
        GenericMethod.method02(123123);
    }
}
1
2
3
4
5
6
7
8
9
10
10.0
10.1
true
================s
静态方法：123
123123

进程已结束,退出代码0

含有泛型的接口

定义

1
2
3
4
5
6
7
8
package com.tipdm.Demo02;

/**
 * 定义含有泛型的接口
 */
public interface GenericInterface<I> {
    public abstract void method(I i);
}

第一种方式：定义接口的实现类，实现接口，指定接口的泛型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.tipdm.Demo02;

/**
 * 含有泛型的接口，第一种方式：定义接口的实现类，实现接口，指定接口的泛型
 * public interface Iterator<E>{
 *     E next();
 * }
 * Scanner类实现了Iterator接口，并指定接口的泛型为String，所以重写的next方法泛型默认就是String
 * public final class Scanner implements Iterator<String>{
 *     public String next(){}
 * }
 */
public class GenericInterfaceImpl1 implements GenericInterface<String>{
    @Override
    public void method(String s) {
        System.out.println(s);
    }
}

第二种使用方式：接口使用什么泛型，实现类就使用什么泛型，类跟着接口走

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.tipdm.Demo02;

import java.util.List;

/**
 * 含有泛型的接口第二种使用方式：接口使用什么泛型，实现类就使用什么泛型，类跟着接口走
 * 就相当于定义了一个含有泛型的类，创建对象的时候确定泛型的类型
 * public interface List<E>{
 *      boolean add(E e);
 *      E get(int index);
 * }
 * public class ArrayList<E> implements List<E>{
 *     public boolean add(E e){}
 *     public E get(int index){}
 * }
 *
 */
public class GenericInterfaceImpl2<I> implements GenericInterface<I>{
    @Override
    public void method(I i) {
        System.out.println(i);
    }
}

主函数调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.tipdm.Demo02;

/**
 * 测试含有泛型的接口
 */
public class Demo04GenericInterface {
    public static void main(String[] args) {
        // 创建GenericInterfaceImpl1对象
        GenericInterfaceImpl1 gi1 = new GenericInterfaceImpl1();
        gi1.method("字符串");
        System.out.println("==============");

        // 创建GenericInterfaceImpl2对象
        GenericInterfaceImpl2<Integer> gi2 = new GenericInterfaceImpl2<>();
        gi2.method(10);

        GenericInterfaceImpl2<Double> gi3 = new GenericInterfaceImpl2<>();
        gi3.method(8.8);

        GenericInterfaceImpl2<String> gi4 = new GenericInterfaceImpl2<>();
        gi4.method("字符串");
    }
}
1
2
3
4
5
6
7
字符串
==============
10
8.8
字符串

进程已结束,退出代码0

泛型的通配符<?>

泛型的通配符：<?>

代表任意的数据类型

使用方式：

  • 不能创建对象使用

  • 只能作为方法的参数使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
package com.tipdm.Demo02;

import java.util.ArrayList;
import java.util.Iterator;

/**
 * 泛型的通配符：<?>
 *      代表任意的数据类型
 * 使用方式：
 *      不能创建对象使用
 *      只能作为方法的参数使用
 */
public class Demo05Generic {
    public static void main(String[] args) {
        ArrayList<Integer> list01 = new ArrayList<>();
        list01.add(1);
        list01.add(2);

        ArrayList<String> list02 = new ArrayList<>();
        list02.add("aa");
        list02.add("bb");

        printArray(list01);
        printArray(list02);

//        ArrayList<?> list03 = new ArrayList<?>();  // 定义的时候不能使用通配符
    }

    /**
     * 定义一个方法，能遍历所有类型的ArrayList集合
     * 这时候我们不知道ArrayList集合使用什么数据类型，可以泛型的通配符?来接收数据类型
     * 注意：
     *      泛型没有继承概念的
     */
    public static void printArray(ArrayList<?> list){
        // 使用迭代器遍历集合
        Iterator<?> it = list.iterator();
        while(it.hasNext()){
            // it.next()方法取出的元素是Object类型，可以接收任意的数据类型
            Object o = it.next();
            System.out.println(o);
        }
    }
}
1
2
3
4
5
6
1
2
aa
bb

进程已结束,退出代码0

泛型的上下限限定

泛型的上限限定：? extends E 代表使用的泛型只能是E类型的子类/本身

泛型的下限限定：? super E 代表使用的泛型只能说E类型的父类/本身

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
package com.tipdm.Demo02;

import java.util.ArrayList;
import java.util.Collection;

/**
 * 泛型的上限限定：? extends E      代表使用的泛型只能是E类型的子类/本身
 * 泛型的下限限定：? super E        代表使用的泛型只能说E类型的父类/本身
 */
public class Demo06Generic {
    public static void main(String[] args) {
        Collection<Integer> list1 = new ArrayList<Integer>();
        Collection<String> list2 = new ArrayList<String>();
        Collection<Number> list3 = new ArrayList<Number>();
        Collection<Object> list4 = new ArrayList<Object>();

        getElement1(list1);
//        getElement1(list2);  // 报错
        getElement1(list3);
//        getElement1(list4);  // 报错

//        getElement2(list1);  // 报错
//        getElement2(list2);  // 报错
        getElement2(list3);
        getElement2(list4);

        /**
         * 类与类之间的继承关系
         * Integer extends Number extends Object
         * String extends Object
         */
    }


    // 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
    public static void getElement1(Collection<? extends Number> coll){}
    // 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
    public static void getElement2(Collection<? super Number> coll){}
}

image-20230611194818971

案例：斗地主发牌

案例分析

斗地主综合案例：

  1. 准备：54张牌，存储到一个集合中
1
2
3
4
5
6
特殊牌：大王、小王
其他52张牌：
	定义一个数组/集合，存储4种花色：♠，♥，♣，♦
	定义一个数组/集合，存储13个序号，2，A，K...3
循环嵌套遍历两个数组/集合，组装52张牌
♠ 2, ♠ A, ♠ K ... ♠ 3， ♥ 2， ♥ A， ♥ K ... ， ♥ 3
  1. 洗牌
1
2
3
4
使用集合工具类 Collections的方法
static void shuffle(List<?> list)
使用默认随机源对指定列表进行置换。
会随机打乱集合种元素的顺序
  1. 发牌
1
2
3
4
5
要求一人17张牌，剩余3张作为底牌，一人一张轮流发牌：集合的索引 %3
定义4个集合，存储3个玩家的牌和底牌
索引%2,有两个值(0, 1)   0%2=0，1%2=1，2%2=0，3%2=1
索引%3，有三个值(0, 1, 2) 0%3=0，1%3=1，2%3=2，3%3=0
索引>=51  改底牌发牌
  1. 看牌

直接打印集合，遍历存储玩家和底牌的集合

31.2 案例实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
package com.tipdm.Demo02;

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

public class Demo07Test {
    public static void main(String[] args) {
        // 首先定义一个扑克牌
        ArrayList<String> poker = new ArrayList<>();
        // 定义存储花色的数组
        String[] hs = {"♠", "♥", "♣", "♦"};
        // 定义存储牌大小的数组
        String[] dx = {"2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3"};
        // 循环嵌套将牌花色和大小进行组装
        for (int i = 0; i < hs.length; i++) {
            for (int i1 = 0; i1 < dx.length; i1++) {
                poker.add(hs[i] + dx[i1]);
            }
        }
        // 将大王和小王放入牌堆
        poker.add("大王");
        poker.add("小王");
        // 洗牌
        Collections.shuffle(poker);
        // 发牌
        ArrayList<String> poker1 = new ArrayList<>();
        ArrayList<String> poker2 = new ArrayList<>();
        ArrayList<String> poker3 = new ArrayList<>();
        ArrayList<String> poker4 = new ArrayList<>();
        for (int i = 0; i < poker.size(); i++) {
            if (i >= 51){
                poker4.add(poker.get(i));
            }else if(i % 3 == 0){
                poker1.add(poker.get(i));
            }else if(i % 3 == 1){
                poker2.add(poker.get(i));
            }else if(i % 3 == 2){
                poker3.add(poker.get(i));
            }
        }
        System.out.println("刘德华：" + poker1);
        System.out.println("周润发：" + poker2);
        System.out.println("陈小刀：" + poker3);
        System.out.println("底牌：" + poker4);
    }
}
1
2
3
4
5
6
刘德华：[方块4, 黑桃A, 梅花6, 红桃2, 红桃A, 梅花A, 梅花3, 梅花K, 方块3, 红桃J, 方块Q, 黑桃6, 方块6, 方块7, 黑桃2, 红桃4, 黑桃8]
周润发：[梅花J, 红桃Q, 小王, 黑桃K, 黑桃4, 红桃9, 红桃8, 梅花7, 梅花10, 红桃3, 梅花5, 方块J, 梅花2, 红桃6, 梅花9, 黑桃J, 大王]
陈小刀：[方块10, 红桃5, 红桃K, 黑桃7, 方块5, 方块8, 黑桃10, 梅花4, 梅花Q, 方块A, 方块K, 黑桃9, 方块2, 梅花8, 红桃10, 黑桃3, 方块9]
底牌：[红桃7, 黑桃Q, 黑桃5]

进程已结束,退出代码0
-------------本文结束感谢您的阅读-------------