Collections、Set、Map、斗地主排序-CSDN博客

本文链接：https://blog.csdn.net/Java_x1/article/details/120563058

Collections常用功能

public static void shuffle(List<?> list) :打乱集合顺序。

public static void main(String[] args) { //- `public static void shuffle(List<?> list) :打乱集合顺序。` // 创建List集合,限制集合元素的类型为Integer类型 List<Integer> list = new ArrayList<>();

// 往集合中添加元素 list.add(500); list.add(100); list.add(300); list.add(200); list.add(400); System.out.println("打乱顺序前的集合:"+list);

// 打乱集合元素顺序 Collections.shuffle(list);

// 打印集合 System.out.println("打乱顺序后的集合:"+list);

}

public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。

public static void main(String[] args) {
//- `public static <T> void sort(List<T> list):将集合中元素按照默认规则排序。`
// 创建List集合,限制集合元素的类型为Integer类型
List<Integer> list = new ArrayList<>();

// 往集合中添加元素
list.add(500);
list.add(100);
list.add(300);
list.add(200);
list.add(400);
System.out.println("排序前的集合:"+list);

// 按照默认规则排序
Collections.sort(list);
System.out.println("排序后的集合:"+list);
}

public static <T> void sort(List<T> list，Comparator<? super T> comp):将集合中元素按照指定规则排序

public static void main(String[] args) {
//- `public static <T> void sort(List<T> list，Comparator<? super T> comp):将集合中元素按照指定规则排序`
// 创建List集合,限制集合元素的类型为Integer类型
List<Integer> list = new ArrayList<>();

// 往集合中添加元素
list.add(500);
list.add(100);
list.add(300);
list.add(200);
list.add(400);
System.out.println("排序前的集合:"+list);

// 按照指定规则排序
Collections.sort(list, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
// 指定排序规则
// 升序: 前减后
// 降序: 后减前
// 前: 参数1 后: 参数2
return o1 - o2;// 升序
}
});
System.out.println("排序后的集合:"+list);

Collections.sort(list, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
// 指定排序规则
// 升序: 前减后
// 降序: 后减前
// 前: 参数1 后: 参数2
return o2 - o1;// 降序
}
});
System.out.println("排序后的集合:"+list);

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

// 创建List集合,限制集合元素的类型为Person类型
List<Person> list1 = new ArrayList<>();

// 往集合中添加元素
list1.add(new Person("张三1",48));
list1.add(new Person("张三2",28));
list1.add(new Person("张三3",38));
list1.add(new Person("张三4",18));
list1.add(new Person("张三5",58));
System.out.println("排序前的集合:"+list1);

// 对list1集合元素按照指定规则进行排序
Collections.sort(list1, new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
return o2.age - o1.age;// 按照年龄降序
}
});
System.out.println("排序后的集合:"+list1);

// 对list1集合元素按照指定规则进行排序
Collections.sort(list1, new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
return o1.age - o2.age;// 按照年龄升序
}
});
System.out.println("排序后的集合:"+list1);

}

HashSet集合

public class Test {
public static void main(String[] args) {
// 创建HashSet集合,限制集合元素的类型为String
HashSet<String> set = new HashSet<>();

// 往集合中存储元素
set.add("nba");
set.add("abc");
set.add("bac");
set.add("cba");
set.add("abc");

// 特点: 元素没有索引,元素唯一,元素存取顺序不一致
System.out.println(set);
}
}

HashSet保证元素唯一原理（哈希表）

哈希表底层结构

在JDK1.8之前，哈希表底层采用数组+链表实现，即使用数组处理冲突，同一hash值的链表都存储在一个数组里。但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，哈希表存储采用数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。

HashMap的put方法源码解析

public class HashMap{
//......
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
//......
static final int hash(Object key) {//根据参数，产生一个哈希值
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
//......
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; //临时变量，存储"哈希表"——由此可见，哈希表是一个Node[]数组
Node<K,V> p;//临时变量，用于存储从"哈希表"中获取的Node
int n, i;//n存储哈希表长度；i存储哈希表索引

if ((tab = table) == null || (n = tab.length) == 0)//判断当前是否还没有生成哈希表
n = (tab = resize()).length;//resize()方法用于生成一个哈希表，默认长度：16，赋给n
if ((p = tab[i = (n - 1) & hash]) == null)//(n-1)&hash等效于hash % n，转换为数组索引
tab[i] = newNode(hash, key, value, null);//此位置没有元素，直接存储
else {//否则此位置已经有元素了
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))//判断哈希值和equals
e = p;//将哈希表中的元素存储为e
else if (p instanceof TreeNode)//判断是否为"树"结构
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {//排除以上两种情况，将其存为新的Node节点
for (int binCount = 0; ; ++binCount) {//遍历链表
if ((e = p.next) == null) {//找到最后一个节点
p.next = newNode(hash, key, value, null);//产生一个新节点，赋值到链表
if (binCount >= TREEIFY_THRESHOLD - 1) //判断链表长度是否大于了8
treeifyBin(tab, hash);//树形化
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))//跟当前变量的元素比较，如果hashCode相同，equals也相同
break;//结束循环
p = e;//将p设为当前遍历的Node节点
}
}
if (e != null) { // 如果存在此键
V oldValue = e.value;//取出value
if (!onlyIfAbsent || oldValue == null)
e.value = value;//设置为新value
afterNodeAccess(e);//空方法，什么都不做
return oldValue;//返回旧值
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
}

HashSet存储自定义类型元素

结论: HashSet集合要存储自定义类型的元素,保证元素唯一,那么就得必须重写hashCode和equals方法

public class Student {
String name;
int age;

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

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

// 重写hashCode方法: 根据所有属性值计算哈希值
// 重写equals方法: 比较所有的属性值
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name);
}

@Override
public int hashCode() {
return Objects.hash(name, age);
}
}

public class Test {
public static void main(String[] args) {
/*
场景:在开发中,2个同类型的对象所有属性相同,我们就认为是2个相同的对象
结论: HashSet集合要存储自定义类型的元素,保证元素唯一,那么就得必须重写hashCode和equals方法
*/
// 需求: 使用HashSet集合存储学生对象
// 创建HashSet集合,限制集合元素的类型为Student类型
HashSet<Student> set = new HashSet<>();

// 往集合中存储学生对象
set.add(new Student("张三",18));
set.add(new Student("李四",28));
set.add(new Student("王五",38));
set.add(new Student("赵六",48));
set.add(new Student("张三",18));

// 循环遍历集合
for (Student student : set) {
System.out.println(student);
}

}
}

LinkedHashSet

概述: java.util.LinkedHashSet 是HashSet的一个子类，底层采用链表+哈希表
特点:
- 元素没有索引,元素唯一,元素存取顺序一致
- 存储结构采用的是哈希表+链表结构,由哈希表保证元素唯一,由链表保证元素存取顺序一致
- 如果集合中存储的是自定义类型的元素,那么就要求该元素所属的类要重写hashCode和equals方法

public class Test {
public static void main(String[] args) {
// 创建LinkedHashSet集合,限制集合元素的类型为String
LinkedHashSet<String> set = new LinkedHashSet<>();

// 往集合中存储元素
set.add("nba");
set.add("abc");
set.add("bac");
set.add("cba");
set.add("abc");

// 特点: 元素没有索引,元素唯一,元素存取顺序一致
System.out.println(set);

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

// 创建HashSet集合,限制集合元素的类型为Student类型
LinkedHashSet<Student> set1 = new LinkedHashSet<>();

// 往集合中存储学生对象
set1.add(new Student("张三",18));
set1.add(new Student("李四",28));
set1.add(new Student("王五",38));
set1.add(new Student("赵六",48));
set1.add(new Student("张三",18));

// 循环遍历集合
for (Student student : set1) {
System.out.println(student);
}
}
}

TreeSet集合

概述: TreeSet集合是Set接口的一个实现类，底层依赖于TreeMap,是一种基于红黑树的实现
特点:
- 元素没有索引,元素唯一,可以对元素进行排序
- 存储结构采用的是红黑树结构,由红黑树保证元素唯一,由比较器来对元素进行排序
排序:
- 默认规则排序: public TreeSet(); 创建TreeSet集合对象,该集合对象使用默认规则对元素进行排序
  - 默认规则是在集合元素所属的类中指定的
  - 要求集合元素所属的类必须实现Comparable接口,重写compareTo方法,在compareTo方法中指定排序规则

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

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

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

@Override
public int compareTo(Student o) {
//return this.age - o.age;// 升序
return o.age - this.age;// 降序
}
}

public class Test1 {
public static void main(String[] args) {
// 创建TreeSet集合,限制集合元素的类型为Integer
TreeSet<Integer> set1 = new TreeSet<>();
// 添加元素
set1.add(500);
set1.add(100);
set1.add(400);
set1.add(200);
set1.add(300);
// set1:[100, 200, 300, 400, 500]---->升序
System.out.println("set1:"+set1);

System.out.println("---------------------");
// 创建TreeSet集合,限制集合元素的类型为Student
TreeSet<Student> set2 = new TreeSet<>();

// 添加元素
set2.add(new Student("张三1",48));
set2.add(new Student("张三2",28));
set2.add(new Student("张三3",58));
set2.add(new Student("张三4",18));
set2.add(new Student("张三5",38));

// 循环遍历集合
for (Student student : set2) {
System.out.println(student);
}

}
}

Map集合

键唯一,值可以重复,如果键重复了,值就会覆盖
Map集合根据键取值

HashMap: 键值对存取无序
   底层采用的是哈希表结构,由哈希表保证键唯一
LinkedHashMap:键值对存取顺序一致
   底层采用的是哈希表+链表结构,由哈希表保证键唯一,由链表保证键值对存取顺序一致
TreeMap:底层采用的是红黑色结构,可以对键进行排序
   底层采用的是红黑色结构,使用的比较器对键进行排序

public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
public V remove(Object key): 把指定的键所对应的键值对元素在Map集合中删除，返回被删除元素的值。
public V get(Object key) 根据指定的键，在Map集合中获取对应的值。
public boolean containsKey(Object key):判断该集合中是否有此键
public boolean containsValue(Object value):判断该集合中是否有此值
public Set<K> keySet(): 获取Map集合中所有的键，存储到Set集合中。
public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。

Map的遍历

获取Map集合的所有键--->keySet()方法
循环遍历所有的键
根据键找值--->get(K k)方法

public class Test1 {
public static void main(String[] args) {
// 创建Map集合,限制键的类型String,限制值的类型String
Map<String, String> map = new HashMap<>();

// 添加键值对
map.put("晓明", "杨颖");
map.put("文章", "伊琍");
map.put("霆锋", "王菲");
map.put("亚鹏", "王菲");

//- 获取Map集合的所有键--->keySet()方法
Set<String> keys = map.keySet();

//- 循环遍历所有的键
for (String key : keys) {
//- 根据键找值--->get(K k)方法
String value = map.get(key);
System.out.println("key:"+key+",value:"+value);
}

}
}

方式2:键值对对象方式

获取所有的键值对对象----> entrySet()方法
循环遍历所有的键值对对象
使用键值对对象获取键和值--->使用Entry接口的方法
Entry<K,V>接口:
- Entry接口是Map接口的成员内部接口,使用的方式是Map.Entry<K,V>
- Entry表示键值对对象,也就是说Entry是用来封装键值对的
- Entry接口里面的常用方法:
  - K getKey(); 获取键值对对象封装的键
  - V getValue(); 获取键值对对象封装的值

HashMap存储自定义类型的键

Map集合的键是自定义类型,那么该类必须重写hashCode和equals方法保证键唯一

public class Test {
public static void main(String[] args) {
/*
练习：每位学生（姓名，年龄）都有自己的家庭住址。那么，既然有对应关系，则将学生对象和家庭住址存储到map集合中。
学生作为键, 家庭住址作为值。
> 注意，学生姓名相同并且年龄相同视为同一名学生。
*/
// 创建HashMap集合,限制键的类型为Student,值的类型为String
HashMap<Student,String> map = new HashMap<>();

// 往map集合中存储键值对
Student stu1 = new Student("张三", 18);
Student stu2 = new Student("李四", 28);
Student stu3 = new Student("王五", 38);
Student stu4 = new Student("赵六", 48);
Student stu5 = new Student("张三", 18);
map.put(stu1,"深圳");
map.put(stu2,"北京");
map.put(stu3,"上海");
map.put(stu4,"广州");
map.put(stu5,"香港");

// 遍历Map集合
Set<Student> keys = map.keySet();
for (Student key : keys) {
System.out.println(key+","+map.get(key));
}

}
}

public class Student {
String name;
int age;

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

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

@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age &&
Objects.equals(name, student.name);
}

@Override
public int hashCode() {
return Objects.hash(name, age);
}
}

LinkedHashMap

概述:LinkedHashMap是HashMap子类，底层由链表和哈希表组合,由哈希表保证键唯一,由链表保证键值对存取顺序一致
结论: 如果键是自定义类型的元素,要保证键唯一,那么该键所属的类需要重写hashCode和equals方法

public class Test {
public static void main(String[] args) {
// 创建HashMap集合,限制键的类型为Student,值的类型为String
LinkedHashMap<Student,String> map = new LinkedHashMap<>();

// 遍历Map集合
Set<Student> keys = map.keySet();
for (Student key : keys) {
System.out.println(key+","+map.get(key));
}
}
}

TreeMap集合

public class Test1 {
public static void main(String[] args) {
// 创建TreeMap集合,限制键的类型为Integer,值的类型为String------>键的默认规则排序
TreeMap<Integer,String> map = new TreeMap<>();

// 往集合中添加键值对的
map.put(5,"深圳");
map.put(1,"广州");
map.put(4,"惠州");
map.put(2,"东莞");
map.put(3,"佛山");
map.put(3,"中山");
System.out.println(map);

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

// 创建TreeMap集合,限制键的类型为Integer,值的类型为String------>键的指定规则排序
TreeMap<Integer,String> map1 = new TreeMap<>(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
});

// 往集合中添加键值对的
map1.put(5,"深圳");
map1.put(1,"广州");
map1.put(4,"惠州");
map1.put(2,"东莞");
map1.put(3,"佛山");
map1.put(3,"中山");
System.out.println(map1);
}
}

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

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

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

@Override
public int compareTo(Student o) {
return this.age - o.age;// 年龄升序
}
}

public class Test2 {
public static void main(String[] args) {
// 创建TreeMap集合,限制键的类型为Student,值的类型为String--->默认规则排序
TreeMap<Student,String> map = new TreeMap<>();

// 添加键值对
Student stu1 = new Student("张三", 18);
Student stu2 = new Student("李四", 48);
Student stu3 = new Student("王五", 28);
Student stu4 = new Student("赵六", 58);
Student stu5 = new Student("田七", 18);
map.put(stu1,"深圳");
map.put(stu2,"广州");
map.put(stu3,"惠州");
map.put(stu4,"东莞");
map.put(stu5,"佛山");

// 遍历map集合
Set<Student> keys = map.keySet();
for (Student key : keys) {
String value = map.get(key);
System.out.println(key+","+value);
}

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

// 创建TreeMap集合,限制键的类型为Student,值的类型为String--->指定规则排序
TreeMap<Student,String> map1 = new TreeMap<>(new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o2.age - o1.age;
}
});

// 添加键值对
map1.put(stu1,"深圳");
map1.put(stu2,"广州");
map1.put(stu3,"惠州");
map1.put(stu4,"东莞");
map1.put(stu5,"佛山");

// 遍历map集合
Set<Student> keys1 = map1.keySet();
for (Student key : keys1) {
String value = map1.get(key);
System.out.println(key+","+value);
}
}
}

public class Test {
public static void main(String[] args) {
//步骤:
//1.键盘输入一个字符串
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串:");
String str = sc.nextLine();

//2.创建Map集合,限制键的类型为Character,值的类型为Integer
HashMap<Character, Integer> map = new HashMap<>();

//3.循环遍历字符串
for (int i = 0; i < str.length(); i++) {
//4.在循环中,获取遍历出来的字符
char c = str.charAt(i);

//5.在循环中,使用该字符作为键,判断Map集合中是否含有该字符的键
boolean res = map.containsKey(c);

if (res == false) {
//6.如果没有该字符的键,说明第一次出现,那么该字符作为键,值为1,存储到Map集合中
map.put(c, 1);
} else {
//7.如果有该字符的键,说明已经出现过了,那么根据该字符作为键取出对应的值,然后值+1,作为新值,再存储到Map集合中
Integer value = map.get(c);
value++;
map.put(c, value);
}
}
//8.打印Map集合
System.out.println(map);
}
}

集合的嵌套

public class Test1_List嵌套List {
public static void main(String[] args) {
// List嵌套List: List集合的元素类型是List
// 创建List集合,并存储元素
List<String> list1 = new ArrayList<>();
list1.add("蔡徐坤");
list1.add("鹿晗");

// 创建List集合,并存储元素
List<String> list2 = new ArrayList<>();
list2.add("吴亦凡");
list2.add("黄子韬");

// 需求: 定义一个List集合,存储以上2个集合,并遍历集合所有元素
List<List<String>> list = new ArrayList<>();
// 添加元素
list.add(list1);
list.add(list2);
// 循环遍历集合
for (List<String> stringList : list) {
System.out.println(stringList);
// 循环遍历
for (String name : stringList) {
System.out.println(name);
}
}
}
}

public class Test {
public static void main(String[] args) {
// List嵌套Map: List集合元素的类型是Map
// 创建Map集合,添加键值对
HashMap<String,String> map1 = new HashMap<>();
map1.put("itheima001","古力娜扎");
map1.put("itheima002","马尔扎哈");

// 创建Map集合,添加键值对
HashMap<String,String> map2 = new HashMap<>();
map2.put("itcast001","迪丽热巴");
map2.put("itcast002","欧阳娜娜");

// 创建List集合,存储以上2个map集合,,并遍历集合所有元素
List<HashMap<String,String>> list = new ArrayList<>();
list.add(map1);
list.add(map2);
// 循环遍历
for (HashMap<String, String> map : list) {
System.out.println(map);
// 获取map的所有键
Set<String> keys = map.keySet();
// 循环遍历所有的键
for (String key : keys) {
// 根据键找值
System.out.println(key+","+map.get(key));
}
}

}
}

public class Test {
public static void main(String[] args) {
// Map嵌套Map: Map集合中存储Map集合
// 创建Map集合,添加键值对
HashMap<String, String> map1 = new HashMap<>();
map1.put("itheima001", "古力娜扎");
map1.put("itheima002", "马尔扎哈");

// 创建Map集合,添加键值对
HashMap<String, String> map2 = new HashMap<>();
map2.put("itcast001", "迪丽热巴");
map2.put("itcast002", "欧阳娜娜");

// 创建Map集合,存储以上2个Map集合(作为值),并遍历集合所有元素
HashMap<String, HashMap<String, String>> map = new HashMap<>();
// 添加键值对
map.put("黑马程序员", map1);
map.put("传智播客", map2);

// 获取map集合的所有键
Set<String> keys = map.keySet();// 黑马程序员,传智播客
for (String key : keys) {
// 根据键找值
HashMap<String, String> valueMap = map.get(key);
System.out.println(key + " : " + valueMap);
// 获取valueMap集合的所有键
Set<String> valueKeys = valueMap.keySet();
// 循环遍历所有的键
for (String valueKey : valueKeys) {
System.out.println(valueKey + ":" + valueMap.get(valueKey));
}

}

}
}

模拟斗地主洗牌发牌

组装54张扑克牌(从大到小进行造牌,然后每张牌给个标记)
54张牌顺序打乱
三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。
查看三人各自手中的牌（按照牌的大小排序）、底牌

规则：手中扑克牌从大到小的摆放顺序：大王,小王,2,A,K,Q,J,10,9,8,7,6,5,4,3

public class Test {
public static void main(String[] args) {
//1.造牌:
//1.1 创建Map集合,用来存储牌的标记和牌
HashMap<Integer, String> map = new HashMap<>();

//1.2 创建花色的单列集合,用来存储4个花色
ArrayList<String> colors = new ArrayList<>();
colors.add("♠");
colors.add("♥");
colors.add("♣");
colors.add("♦");

//1.3 创建牌面值的单列集合,用来存储13个牌面值(从大到小)
ArrayList<String> numbers = new ArrayList<>();
Collections.addAll(numbers, "2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3");

//1.4 定义一个int类型的变量,用来存储牌的标记,初始值为0
int mark = 0;

//1.5 标记作为键,大王作为值,存储到Map集合中,然后标记+1
map.put(mark++, "大王");

//1.6 标记作为键,小王作为值,存储到Map集合中,然后标记+1
map.put(mark++, "小王");

//1.7 牌面值作为外层循环,花色作为内层循环
for (String number : numbers) {
for (String color : colors) {
//1.8 在循环中,拼接牌,标记作为键,拼接后的牌作为值,存储到Map集合中,然后标记+1
String pai = color + number;
map.put(mark++, pai);
}
}
System.out.println("map:" + map);
System.out.println("map:" + map.size());

//2.洗牌
//2.1 获取map集合中所有的键(所有牌的标记)
Set<Integer> marksSet = map.keySet();
ArrayList<Integer> markList = new ArrayList<>();
markList.addAll(marksSet);

//2.2 对标记进行打乱顺序
Collections.shuffle(markList);
System.out.println("打乱顺序之后的标记:" + markList);
System.out.println("打乱顺序之后的标记:" + markList.size());

//3.发牌:
//3.1 创建4个单列集合,分别用来存储玩家1,玩家2,玩家3,底牌的标记
ArrayList<Integer> player1Mark = new ArrayList<>();
ArrayList<Integer> player2Mark = new ArrayList<>();
ArrayList<Integer> player3Mark = new ArrayList<>();
ArrayList<Integer> diPaiMark = new ArrayList<>();

//3.2 循环遍历打乱顺序之后的标记
for (int i = 0; i < markList.size(); i++) {
// 获取标记
Integer paiMark = markList.get(i);
// 判断
if (i >= 51) {
//3.3 如果遍历出来的标记的索引 >= 51,该标记给底牌
diPaiMark.add(paiMark);
} else if (i % 3 == 0) {
//3.3 如果遍历出来的标记的索引%3==0,该标记给玩家1
player1Mark.add(paiMark);
} else if (i % 3 == 1) {
//3.3 如果遍历出来的标记的索引%3==1,该标记给玩家2
player2Mark.add(paiMark);
} else if (i % 3 == 2) {
//3.3 如果遍历出来的标记的索引%3==2,该标记给玩家3
player3Mark.add(paiMark);
}

}
//3.4 对玩家1,玩家2,玩家3,底牌获得标记进行从小到大排序
Collections.sort(player1Mark);
Collections.sort(player2Mark);
Collections.sort(player3Mark);
Collections.sort(diPaiMark);

//3.5 创建4个单列集合,分别用来存储玩家1,玩家2,玩家3,底牌的牌
ArrayList<String> player1 = new ArrayList<>();
ArrayList<String> player2 = new ArrayList<>();
ArrayList<String> player3 = new ArrayList<>();
ArrayList<String> diPai = new ArrayList<>();

//3.6 循环遍历排好序的标记,去map集合中取牌
for (Integer paiMark : player1Mark) {
// 根据标记去map中取牌
String pai = map.get(paiMark);
// 把牌添加到集合中
player1.add(pai);
}

for (Integer paiMark : player2Mark) {
// 根据标记去map中取牌
String pai = map.get(paiMark);
// 把牌添加到集合中
player2.add(pai);
}

for (Integer paiMark : player3Mark) {
// 根据标记去map中取牌
String pai = map.get(paiMark);
// 把牌添加到集合中
player3.add(pai);
}

for (Integer paiMark : diPaiMark) {
// 根据标记去map中取牌
String pai = map.get(paiMark);
// 把牌添加到集合中
diPai.add(pai);
}

//3.7 展示牌(打印输出)
System.out.println("玩家1:" + player1+",牌数:"+player1.size());
System.out.println("玩家2:" + player2+",牌数:"+player2.size());
System.out.println("玩家3:" + player3+",牌数:"+player3.size());
System.out.println("底牌:" + diPai);
}
}