JavaSE第15篇：集合之Collection集合上篇
核心概述：在之前的篇章中，我们学习了数组，因为数组本身数据结构的局限性，对于数组内元素除查询操作外的其他操作（增删改）比较低效，所以，我们又学习了集合ArrayList，初步体验了集合操作的便捷性。本篇我们将开始系统地学习Java中的集合体系。
第一章：对象数组
数组是容器，即可以存储基本数据类型也可以引用数据类型，存储了引用数据类型的数组称为对象数组，例如：String[]，Person[]，Student[]。
public static void main(String[] args){
//创建存储Person对象的数组
Person[] persons = {
new Person("张三",20),
new Person("李四",21),
new Person("王五",22),
};
//遍历数组
for(int i = 0 ; i < persons.length; i++){
Person person = persons[i];
System.out.println(person.getName()+"::"+person.getAge());
}
}
数组的弊端：
- 数组长度是固定的，一旦创建不可修改。
- 需要添加元素，只能创建新的数组，将原数组中的元素进行复制。
为了解决数组的定长问题，Java语言从JDK1.2开始出现集合框架。
第二章：认识集合
1.1-集合概述（了解）
在之前的篇章中我们已经学习过并使用过集合ArrayList<E> ，那么集合到底是什么呢？
简而言之，集合就是是java中提供的一种容器，可以用来存储多个数据。
这么说，集合和数组非常相似，就是存储多个数据的容器。那么，集合和数组有什么区别呢？
- 数组的长度是固定的。集合的长度是可变的。
- 数组中存储的是同一类型的元素，可以存储任意类型数据。集合存储的都是引用数据类型。如果想存储基本类型数据需要存储对应的包装类型。
1.2-Java中的集合框架（了解）
以下的集合体系描述，不是所有的集合，而是常用的集合。
单列集合体系
双列集合体系
由于集合体系丰富，我们将会分多个篇幅学习，本篇我们将学习单列集合体系Collection中的List系列集合。
1.3-Collection集合通用方法（记忆）
Collection是所有单列集合的父接口，因此在Collection中定义了单列集合(List和Set)通用的一些方法，这些方法可用于操作所有的单列集合。方法如下：
public boolean add(E e)： 把给定的对象添加到当前集合中 。public boolean addAll(Collection<? extends E>)将另一个集合元素添加到当前集合中。public void clear():清空集合中所有的元素。public boolean remove(E e): 把给定的对象在当前集合中删除。public boolean contains(Object obj): 判断当前集合中是否包含给定的对象。public boolean isEmpty(): 判断当前集合是否为空。public int size(): 返回集合中元素的个数。public Object[] toArray(): 把集合中的元素，存储到数组中。
代码示例
import java.util.ArrayList;
import java.util.List;
public class Test {
public static void main(String[] args) {
Collection<String> list = new ArrayList<>();
// 添加元素
list.add("张三");
list.add("李四");
Collection<String> list2 = new ArrayList<>();
list2.add("王五");
list2.add("赵六");
// 将list2集合元素添加到list集合中
list.addAll(list2);
System.out.println(list);
// 移除元素
list.remove("张三");
System.out.println(list);
// 判断集合中是否包含某个元素
boolean isHas = list.contains("张三");
System.out.println(isHas); // false
// 判断当前集合是否为空
boolean isEmpty = list.isEmpty();
System.out.println(isEmpty);
// 清空元素
list.clear();
System.out.println(list);
// 集合的长度
System.out.println(list.size());
// 集合中的元素存储到一个数组中
Object[]s = list.toArray();
}
}
第三章：遍历集合
3.1-Iterator方式遍历（记忆）
介绍
Iterator，是一个迭代器接口。Collection中的成员方法iterator()被调用后，会返回一个Iterator对象。利用这个对象可以实现遍历集合。如何遍历呢？在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。
Iterator对象的成员方法：
- hasNext(); 检测集合中是否存在下一个元素
- next(); 找到并获取下一个元素
示例代码：
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Test {
public static void main(String[] args) {
Collection<String> list = new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("王五");
// 得到一个迭代器对象
Iterator<String> it = list.iterator();
// 判断集合中是否还有元素
while (it.hasNext()) {
// 取出元素
String str = it.next();
System.out.println(str);
}
}
}
迭代器执行过程
在调用Iterator的next方法之前，迭代器的索引位于第一个元素之前，不指向任何元素，当第一次调用迭代器的next方法后，迭代器的索引会向后移动一位，指向第一个元素并将该元素返回，当再次调用next方法时，迭代器的索引会指向第二个元素并将该元素返回，依此类推，直到hasNext方法返回false，表示到达了集合的末尾，终止对元素的遍历。
迭代器源码分析
迭代器是遍历Collection集合的通用方式，任意Collection集合都可以使用迭代器进行遍历，那么每一种集合的自身特性是不同的，也就是存储元素的方式不同，那么是如何做到遍历方式的统一呢，接下来我们分析一下迭代器的源代码。
每个Collection集合都会实现，方法 Iterator iterator()，返回Iterator接口实现类，以ArrayList集合为例
java.util.Iterator接口：
public interface Iterator<E> {
boolean hasNext();
E next();
}
java.util.ArrayList类：
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
/*
* ArrayList实现接口Collection
* 重写方法iterator()
* 返回Iterator接口实现类 Itr类的对象
*/
public Iterator<E> iterator() {
return new Itr();
}
/*
* ArrayList中定义内部类Itr,实现接口Iterator
* 重写hasNext(),next()方法
*/
private class Itr implements Iterator<E> {
public boolean hasNext() {
// ...
}
public E next() {
// ...
}
}
所以结论是：
- 所有集合的迭代器，全由内部类实现。
- 集合中定义内部类，实现迭代器接口，可以使所有集合的遍历方式统一。
- 调用迭代器的方法hasNext()，next()均执行集合中内部类的重写方法。
并发修改异常
在使用迭代器遍历集合中，不能使用集合本身的方法改变集合的长度，一旦被改变将会抛出ConcurrentModificationException并发修改异常。
public static void main(String[] args){
Collection<String> coll = new ArrayList<String>();
coll.add("hello1");
coll.add("hello2");
coll.add("hello3");
coll.add("hello4");
Iterator<String> it = coll.iterator();
while (it.hasNext()){
String str = it.next();
if("hello2".equals(str)){
coll.add("hello5");
}
}
以上程序，在迭代器遍历过程中，使用了集合add方法修改集合的长度，这个操作是不允许的，被禁止的，程序中会抛出并发修改异常。
3.2-增强for方式遍历（记忆）
概述
增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。
语法格式
for(元素的数据类型 变量 : Collection集合or数组){
//写操作代码
}
变量，表示取出的某一个元素
代码示例：
import java.util.ArrayList;
import java.util.Collection;
public class Test {
public static void main(String[] args) {
Collection<String> list = new ArrayList<>();
list.add("张三");
list.add("李四");
list.add("王五");
for (String s : list) {
System.out.println(s);
}
}
}
/*
输出结果：
张三
李四
王五
*/
第四章：数据结构
4.1-概述（了解）
数据结构就是计算机存储、组织数据的方式 。
指的是相互之间存在着特定关系的一种或多种的数据元素集合。
为什么要学习数据结构呢？
通常情况下，精心选择合适的数据结构可以带来更高的运行或存储的效率。
比如：为什么数组查询速度快，增删改效率较低？为什么有的集合更适合用于查询，有的更适合用于增删改？
4.2-数据结构-栈（了解）
介绍
栈：栈（stack）又名堆栈，是一种运算受限的线性表。
受限：限定仅在表尾进行插入和删除操作的线性表（这一端被称为栈顶，另一端称为栈底）
这里两个名词需要注意：
- 压栈（入栈）：就是存元素。即，把元素存储到栈的顶端位置，栈中已有元素依次向栈底方向移动一个位置。
- 弹栈（出栈）：就是取元素。即，把栈的顶端位置元素取出，栈中已有元素依次向栈顶方向移动一个位置。
特性
先进后出，是栈结构的特点。
4.3-数据结构-队列（了解）
介绍
队列：是一种受限的特殊线性表。
受限：只允许在表的前端（队头）进行删除操作，后端（队尾）进行插入操作。
特性
先进先出，是队列数据结构的特点。
4.4-数据结构-数组（了解）
介绍
数组：一组有序的（索引有序并且从0开始）类型相同的长度固定的元素集合。
特性
- 元素有序
- 元素同类型
- 长度固定
应用效果
查询快，从数组索引0开始查找，根据指定位置的偏移量可快速获取数据。
增删慢，数组的长度是固定的，若删除或增加一格元素，则会先创建一个新的数组，再把原数组的数据根据操作复制到新数组中。
4.5-数据结构-链表（了解）
链表
链表:linked list,由一系列结点node（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。我们常说的链表结构有单向链表与双向链表，那么这里给大家介绍的是单向链表。
特性
- 多个结点之间，通过地址进行连接。例如，多个人手拉手，每个人使用自己的右手拉住下个人的左手，依次类推，这样多个人就连在一起了。
- 结点可以在运行时动态生成。
- 每个结点包括两个部分（单链表）
- 一个是存储数据元素的数据域
- 另一个是存储下一个结点地址的指针域。
应用效果
查询慢：链表的地址不是连续的，每次查找都得从头开始查找。增删快：增删操作不会影响链表的整体结构。
第五章：List集合
5.1-概述（了解）
概述
java.util.List接口，继承Collection接口，有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。与Set接口不同，List接口通常允许重复元素。
特点
- List集合是有序的集合，存储和取出的顺序一致。
- List集合允许存储重复的元素。
- List集合中的每个元素具有索引。
集合类名后缀是List，例如ArrayList，LinkedList等，都是List接口实现类，都具有List接口的特点。
5.2-List集合常用方法（记忆）
List作为Collection集合的子接口，不但继承了Collection接口中的全部方法，而且还增加了一些根据元素索引来操 作集合的特有方法，如下：
方法：
public void add(int index, E element): 将指定的元素，添加到该集合中的指定位置上。public E get(int index):返回集合中指定位置的元素。public E remove(int index): 移除列表中指定位置的元素, 返回的是被移除的元素。public E set(int index, E element):用指定元素替换集合中指定位置的元素,返回值的更新前的元素
代码：
List list = new ArrayList();
list.add("a");
list.add("b");
list.add("c");
// public void add(int index, E element) : 将指定的元素，添加到该集合中的指定位置上。
list.add(1,"d");
System.out.println(list); // [a, d, b, c]
// public E get(int index) :返回集合中指定位置的元素。
System.out.println(list.get(2)); // b
// public E remove(int index) : 移除列表中指定位置的元素, 返回的是被移除的元素。
list.remove(1);
System.out.println(list); // [a, b, c]
// public E set(int index, E element) :用指定元素替换集合中指定位置的元素,返回值的更新前的元素
list.set(1,"B");
System.out.println(list); // [a, B, c]
第六章：ArrayList集合
6.1-概述（了解）
java.util.ArrayList集合数据存储的结构是数组结构。元素增删慢，查找快，线程不安全，运行速度快。由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合。
许多程序员开发时非常随意地使用ArrayList完成任何需求，并不严谨，这种用法是不提倡的。
6.2-ArrayList源代码分析（了解）
底层就是数组
底层是Object对象数组，数组存储的数据类型是Object，数组名字为elementData。
ArrayList类中部分源码
transient Object[] elementData;
创建ArrayList对象分析：无参数
初始化ArrayList对象，创建一个为10的空列表。也可以指定列表长度，构造方法传递长度即可。
new ArrayList(); //默认长度为10
new ArrayList(int initialCapacity); //指定长度
ArrayList无参数构造方法分析：
// 定义Object对象类型的空数组，数组在内存中存在，但长度为0
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
解析：这里可以看出，当我们new ArrayList()的时候，并没有创建长度为10的数组，而是创建了一个长度为0的数组，当我们使用add()方法添加元素的时候，就会将数组由0长度，扩容为10长度。
ArrayList添加元素add方法分析：
//ArrayList的成员变量size，默认为0，统计集合中元素的个数
private int size;
public boolean add(E e) {
ensureCapacityInternal(size + 1);
elementData[size++] = e;
return true;
}
解析：集合添加元素之前，先调用方法ensureCapacityInternal()增加容量，传递size+1，size默认为0。传递参数0+1的结果。
ensureCapacityInternal()增加容量方法分析：
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
解析：方法ensureCapacityInternal()接收到参数1，继续调用方法calculateCapacity()计算容量，传递数组和1。
calculateCapacity()计算容量方法分析：
private static final int DEFAULT_CAPACITY = 10;
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
解析：方法中判断elementData是否和DEFAULTCAPACITY_EMPTY_ELEMENTDATA数组相等，在构造方法中：this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;因此结果为true，方法将会返回参数DEFAULT_CAPACITY（=10）和 minCapacity（=1）中最大的值，return 10;此时方法calculateCapacity()结束，继续执行() ensureExplicitCapacity()，传递参数10
ensureExplicitCapacity()保证明确容量方法分析:
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
解析：方法中进行判断（10-elemetData.length>0）结果为true，10-0>0。调用方法grow()传递10。
grow()增加容量方法分析：
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
//**将10赋值给变量newCapacity
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
//**数组复制， Arrays.copyOf底层实现是System.arrayCopy()
elementData = Arrays.copyOf(elementData, newCapacity);
}
解析：方法grow()接收到参数10，进过计算，执行newCapacity = minCapacity;这行程序，此时变量newCapacity的值为10，然后进行数组复制操作，复制新数组的长度为10，为此ArrayList集合初始化创建过程完毕。
创建ArrayList对象分析：带有初始化容量构造方法
ArrayList有参数构造方法分析：new ArrayList(10)
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);
}
}
解析：创建ArrayList集合，传递参数10，变量initialCapacity接收到10，直接进行数组的创建：this.elementData = new Object[initialCapacity]。如果传递的参数为0，那么结果就和使用无参数构造方法相同，如果传递的参数小于0，抛出IllegalArgumentException无效参数异常。
add添加元素方法分析:
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
解析：集合添加元素，调用方法add并传递被添加的元素，首先调用方法ensureCapacityInternal()进行容量的检查，然后将元素添加到elemenetData数组中，size变量是记录存储多少个元素的，默认值为0，添加第一个元素的时候，size为0，添加第一个元素，再++。返回true，List集合允许重复元素。
ensureCapacityInternal()方法最终会执行到grow方法。
private void grow(int minCapacity) {
//定义变量（老容量），保存数组的长度 = 10
int oldCapacity = elementData.length;
//定义变量（新容量） = 老容量+老容量右移1位
//右移是二进制位计算，相等于除以2,得出新容量=老容量+老容量/2
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity);
}
解析：例如当前的集合中的数组长度为10，进行扩容。得出新容量+老容量=老容量/2
第七章：LinkedList集合
7.1-概述（了解）
java.util.LinkedList集合数据存储的结构是链表结构。方便元素添加、删除的集合。
集合特点：元素增删快，查找慢，线程不安全，运行速度快。
LinkedList是一个双向链表，那么双向链表是什么样子的呢，我们用个图了解下：
7.2-特有方法（了解）
实际开发中对一个集合元素的添加与删除经常涉及到首尾操作，而LinkedList提供了大量首尾操作的方法。这些方法我们作为了解即可：
public void addFirst(E e):将指定元素插入此列表的开头。public void addLast(E e):将指定元素添加到此列表的结尾。public E getFirst():返回此列表的第一个元素。public E getLast():返回此列表的最后一个元素。public E removeFirst():移除并返回此列表的第一个元素。public E removeLast():移除并返回此列表的最后一个元素。public E pop():从此列表所表示的堆栈处弹出一个元素。public void push(E e):将元素推入此列表所表示的堆栈。public boolean isEmpty()：如果列表不包含元素，则返回true。
LinkedList是List的子类，List中的方法LinkedList都是可以使用，这里就不做详细介绍，我们只需要了解LinkedList的特有方法即可。在开发时，LinkedList集合也可以作为堆栈，队列的结构使用。
LinkedList list = new LinkedList();
list.add("a");
list.add("b");
// public void addFirst(E e) :将指定元素插入此列表的开头。
list.addFirst("A");
// public void addLast(E e) :将指定元素添加到此列表的结尾。
list.addLast("B");
System.out.println(list); // [A, a, b, B]
// public E getFirst() :返回此列表的第一个元素。
System.out.println(list.getFirst()); // A
// public E getLast() :返回此列表的最后一个元素。
System.out.println(list.getLast()); // B
// public E removeFirst() :移除并返回此列表的第一个元素。
list.removeFirst();
// public E removeLast() :移除并返回此列表的最后一个元素。
list.removeLast();
System.out.println(list); //[a, b]
// public E pop() :从此列表所表示的堆栈处弹出一个元素。
list.pop();
System.out.println(list); // [b]
// public void push(E e) :将元素推入此列表所表示的堆栈。
list.push("a");
System.out.println(list); // [a, b]
// public boolean isEmpty() ：如果列表不包含元素，则返回true。
System.out.println(list.isEmpty()); // false
7.3-源码分析（了解）
LinkedList成员变量分析：
public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable{
transient int size = 0;
transient Node<E> first;
transient Node<E> last;
}
解析：成员变量size是长度，记录了集合中存储元素的个数。first和last分别表示链表开头和结尾的元素，因此链表可以方便的操作开头元素和结尾元素。
LinkedList内部类Node类分析：
private static class Node<E> {
E item;
Node<E> next;
Node<E> prev;
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
解析：LinkedList集合中的内部类Node，表示链表中的节点对象，Node类具有3个成员变量:
- item：存储的对象。
- next：下一个节点。
- prev：上一个节点。
从Node类的源代码中可以分析出，LinkedList是双向链表，一个对象，他记录了上一个节点，也记录了下一个节点。
LinkedList添加元素方法add()分析：
public boolean add(E e) {
linkLast(e);
return true;
}
linkLast方法
void linkLast(E e) {
final Node<E> l = last;
final Node<E> newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}
解析：调用集合方法add()添加元素，本质上调用的是linkLast()方法进行添加。
final Node<E> l = last：当集合中添加第一个元素时last=null。final Node<E> newNode = new Node<>(l, e, null)：创建Node类内部类对象，传递null（上一个节点），被添加的元素和null（下一个节点）。last = newNode：将新增的节点newNode,复制给链表中的最后一个节点last。if(l == null)：第一次添加元素时，结果为true，first=newNode，链表中的第一个节点=新添加的节点。size++：记录了集合中元素的个数。modCount++：记录了集合被操作的次数。
LinkedList获取元素方法get()分析
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
node方法
Node<E> node(int index) {
if (index < (size >> 1)) {
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
解析：index < (size >> 1)采用二分法，如果要获取元素的索引小于长度的一半，那么就从0开始，找到集合长度的一半，如果要获取的元素的长度大于集合的一半，那么就从最大索引开始，找到集合长度的一半。
结论：链表本身并没有索引，当我们通过索引获取的时候，内部采用了循环到集合长度的方式依次查找的。
第八章：综合案例
8.1-需求
按照斗地主的规则，完成洗牌发牌的动作。
具体规则：
- 使用54张牌打乱顺序,
- 三个玩家参与游戏，
- 三人交替摸牌，每人17张牌，
- 最后三张留作底牌。
8.2-分析
牌可以设计为一个ArrayList<String>,每个字符串为一张牌。
每张牌由花色数字两部分组成，我们可以使用花色集合与数字集合嵌套迭代完成每张牌的组装。
牌由Collections类的shuffle方法进行随机排序。
8.3-代码
package www.penglei666.com;
import java.util.ArrayList;
import java.util.Collections;
public class Poker {
public static void main(String[] args) {
/*
* 1: 准备牌操作
*/
//1.1 创建牌盒 将来存储牌面的
ArrayList<String> pokerBox = new ArrayList<String>();
//1.2 创建花色集合
ArrayList<String> colors = new ArrayList<String>();
//1.3 创建数字集合
ArrayList<String> numbers = new ArrayList<String>();
//1.4 分别给花色 以及 数字集合添加元素
colors.add("♥");
colors.add("♦");
colors.add("♠");
colors.add("♣");
for(int i = 2;i<=10;i++){
numbers.add(i+"");
}
numbers.add("J");
numbers.add("Q");
numbers.add("K");
numbers.add("A");
//1.5 创造牌 拼接牌操作
// 拿出每一个花色 然后跟每一个数字 进行结合 存储到牌盒中
for (int i =0 ; i<colors.size() ;i++) {
//color每一个花色 guilian
//遍历数字集合
for(int j = 0; j <numbers.size() ; j++){
//结合
String card = colors.get(i)+numbers.get(j);
//存储到牌盒中
pokerBox.add(card);
}
}
//1.6大王小王
pokerBox.add("小☺");
pokerBox.add("大☠");
// System.out.println(pokerBox);
//洗牌 是不是就是将 牌盒中 牌的索引打乱
// Collections类 工具类 都是 静态方法
// shuffer方法
/*
* static void shuffle(List<?> list)
* 使用默认随机源对指定列表进行置换。
*/
//2:洗牌
Collections.shuffle(pokerBox);
//3 发牌
//3.1 创建 三个 玩家集合 创建一个底牌集合
ArrayList<String> player1 = new ArrayList<String>();
ArrayList<String> player2 = new ArrayList<String>();
ArrayList<String> player3 = new ArrayList<String>();
ArrayList<String> dipai = new ArrayList<String>();
//遍历 牌盒 必须知道索引
for(int i = 0;i<pokerBox.size();i++){
//获取 牌面
String card = pokerBox.get(i);
//留出三张底牌 存到 底牌集合中
if(i>=51){//存到底牌集合中
dipai.add(card);
} else {
//玩家1 %3 ==0
if(i%3==0){
player1.add(card);
}else if(i%3==1){//玩家2
player2.add(card);
}else{//玩家3
player3.add(card);
}
}
}
//看看
System.out.println("东方月初："+player1);
System.out.println("涂山红红："+player2);
System.out.println("王权富贵："+player3);
System.out.println("底牌："+dipai);
}
}
