day08 【集合】
今日内容介绍
java
Map集合特点
Map集合的遍历方式
方法可变参数
斗地主案例排序第一章 Map 集合【重点】
1.1 Map 集合的特点
java
Map集合的概念
Map集合是双列集合，里面存储 一对对儿元素。
前面的叫键Key，后面的叫值Value。
Map集合特点
1:键是惟一的，值是可以重复。
2:一个键对应一个值，叫一一对应关系(映射Map关系\键值关系)。
3:这种关系是键来维护(你只能通过键找值，不能通过值找键)。
4:键+值--键值对。把它们俩当成一个对象，这个对象的类型叫Entry。
每一个entry包含一个键一个值。
Map集合API
Map<K,V> 双列集合的顶层接口，定义的功能，子类都有。
K -- key 代表键的类型
V -- value 代表值的类型。
泛型类型 必须写 引用类型。1.2 Map 集合的常用方法
put 功能的使用
public V put(K key, V value) : 把指定的键与指定的值添加到 Map 集合中。
text
如果键key,是第一次存储,返回null
如果键key已经存在,返回是被替换掉的值
键相同,值被替换java
package com.itheima.map01;
import java.util.HashMap;
import java.util.Map;
/*
Map集合的基本功能 都要能使用
put功能
设置一个键值对
如果键不存在 就做添加一个新的键值对
如果键存在 就完成根据键修改值。
返回值
被替换的元素。
*/
public class MapDemo {
public static void main(String[] args) {
// 创建集合对象 Map 双列 键 值
// 确定 键是什么类型 值是什么类型
Map<String,String> map = new HashMap<>();
// 一次存一对儿元素 键 值
// 需要使用 V put(K key ,V value) 设置一个键和一个值 到集合中
map.put("郭德纲","于谦");
System.out.println(map.put("喜羊羊","灰太狼"));
// 输出是null 设置一个键和一个值 既可以做添加 又可以做修改
map.put("王宝强","小灰灰");
//怎么知道我们存了三对元素
// int size() 查看map集合中的长度，有多少个键值对
System.out.println("map集合中有几对元素:"+map.size());
System.out.println(map.toString());//map集合重写toString
System.out.println("返回的是被替换的值"+map.put("郭德纲","柳岩"));
// 设置了一个已存在的键 但是值是不同
// put(K,V) 根据键设置新值
// 修改功能 根据键修改值。
System.out.println("集合里面的内容:"+map.toString());
}
}java
package com.itheima.map01;
import java.util.HashMap;
import java.util.Map;
/*
Map集合的基本功能 都要能使用
put功能
设置一个键值对
如果键不存在 就做添加一个新的键值对
如果键存在 就完成根据键修改值。
返回值
被替换的元素。
int size() 查看map集合中的长度，有多少个键值对
map集合对象都会重写toString用来展示集合中的内容
*/
public class MapDemo2 {
public static void main(String[] args) {
// 创建集合对象 Map 双列 键 值
// 确定 键是什么类型 值是什么类型
Map<String,String> map = new HashMap<>();
// 一次存一对儿元素 键 值
// 需要使用 V put(K key ,V value) 设置一个键和一个值 到集合中
map.put("郭德纲","于谦");
map.put("喜羊羊","灰太狼");
// 输出是null 设置一个键和一个值 既可以做添加 又可以做修改
map.put("王宝强","小灰灰");
//怎么知道我们存了三对元素
// int size() 查看map集合中的长度，有多少个键值对
System.out.println("map集合中有几对元素呢:"+map.size());
System.out.println("查看集合中的内容："+map.toString());
// 删除元素 V remove(K key) 根据键删除 键值对 返回被删除的值
System.out.println("根据键王宝强 删除对应的关系，返回的是被删除的值:"+map.remove("王宝强"));;
//根据键获取元素 V get(K key) 有就返回值 没有就返回null
System.out.println("根据王宝强键找值"+map.get("王宝强"));
System.out.println("根据郭德纲键找值"+map.get("郭德纲"));
System.out.println(map);
// boolean containsKey(Object k)集合中是否有此键
System.out.println("集合中是否有 王宝强 键:"+map.containsKey("王宝强"));
// boolean containsValue(Object v)集合中是否有此值
System.out.println("集合中 是否有 于谦 值:"+map.containsValue("于谦"));
// isEmpty()判断集合里面是否还有键值对
System.out.println("map集合是否有键值对儿元素:"+map.isEmpty());
// clear()清空集合中所有的键值对
map.clear();
System.out.println("map集合是否有键值对儿元素:"+map.isEmpty());
// 推荐练习一个 map.keySet()
// map.values()
}
}1.3 Map 集合的获取所有的键和值的功能
java
//
Map接口中的常用方法
public Set<K> keySet() : 获取Map集合中所有的键，存储到Set集合中。
public Collection<V> values() :返回Map集合中的所有值到Collection集合。
public class Demo03Map {
public static void main(String[] args) {
//多态创建Map集合对象
Map<String,Integer> map = new HashMap<>();
//put: 添加键值对
map.put("b",98);
map.put("d",100);
map.put("a",97);
map.put("c",99);
System.out.println(map);
//keySet方法:获取所有的键对应的Set集合
Set<String> set = map.keySet();
//迭代器遍历
Iterator<String> it = set.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
System.out.println("------------");
//values方法: 获取所有的值对应的Collection集合
Collection<Integer> coll = map.values();
//增强for遍历
for (Integer num : coll) {
System.out.println(num);
}
}
}1.4 Map 集合的遍历_通过键找值
需要用到的方法
java
package com.itheima.map02;
import java.util.HashMap;
import java.util.Set;
/**
* 第一种集合遍历方式
* 通过键找值
* 步骤:
* 1:先获取到所有键的集合 键集 keySet()方法
* 2:遍历键集 拿到每个键 使用增强for
* 3:根据键找到值 get(K key)
*
*/
public class MapForEach01 {
public static void main(String[] args) {
//1：创建一个集合 map集合
HashMap<String,String> map = new HashMap<>();
//2：存储元素
map.put("诸葛亮","黄月英");
map.put("刘备","孙尚香");
map.put("周瑜","小乔");
map.put("司马懿","张春华");
// 3:完成遍历 依次从集合中 取出 一对对儿元素。
// 3.1 先获取到所有键的集合 键集 keySet()方法
Set<String> keys = map.keySet();
//3.2 完成遍历 for
for (String key : keys) {
//拿到的可以 就是键 每个键
// 3.3 通过每个键找到值 get方法
String value = map.get(key);
System.out.println("遍历的键是:"+key+" 遍历的值是:"+value);
}
}
}1.5 Map 集合的遍历_通过键值对的方式分析
java
Map集合 是存储一对对儿键值对的集合
双列集合。
多个键值对儿的一种集合
Map<K,V>
map
字符 整型
键 值
a 97
b 98
c 99
map
键值对儿---Entry<K,V>
a-97 （一个Entry对象）
b-98 （一个Entry对象）
c-99 （一个Entry对象）
Map集合中
有个方法 entrySet()方法
将map集合中 每一对儿元素当成 一个Entry对象看待(键值对儿)
Set<Entry<K,V>> entrySet() 得到 entry的set集合
把map集合转换成一个Set集合 (双列--单列)
Entry对象，有特点里面有有键 有值
Entry entry 有一个键 有一个值
entry.getKey()返回键
entry.getValue() 返回值
entry.setValue(新值) 修改键对应的旧值
在Map接口中 有一个静态的子接口 Entry
因为Map的实现类类型，会把Map所有抽象方法都重写。
同时 也会在实现类中 产生一个Entry接口的实现类
重写 entrySet()方法
1.6 Map 集合的遍历_通过键值对的代码实现
java
package com.itheima.map02;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* 第二种集合遍历方式
* 找 键值对 方式
* 1:根据map集合--双列集合-->转换成 一个单列集合
* 单列集合里面放的是 一个个键值对
* Set<Map.Entry<K,V>> entrySet = map.entrySet()
* 2:遍历集合 拿到每个 键值对 增强for
* 3: 根据键值对对象 找到对应的键和值 getKey() getValue()
*
*/
public class MapForEach02 {
public static void main(String[] args) {
//1：创建一个集合 map集合
HashMap<String,String> map = new HashMap<>();
//2：存储元素
map.put("诸葛亮","黄月英");
map.put("刘备","孙尚香");
map.put("周瑜","小乔");
map.put("司马懿","张春华");
//3:遍历集合
// 1:根据map集合--双列集合-->转换成 一个单列集合
// * 单列集合里面放的是 一个个键值对
// * Set<Map.Entry<K,V>> entrySet = map.entrySet()
Set<Map.Entry<String, String>> entrySet = map.entrySet();
// 2:遍历集合 拿到每个 键值对 增强for
for (Map.Entry<String, String> entry : entrySet) {
//3: 根据键值对对象 找到对应的键和值 getKey() getValue()
// entry 代表键值对
String key = entry.getKey();
String value = entry.getValue();
System.out.println("键:"+key+" 值:"+value);
}
}
}第二章 Map 集合子类介绍
2.1 HashMap
特点
java
底层是哈希表结构
要保证键的唯一 ==== hashcode()和equals()方法
如果我们的键是一个自定义类型，我们认为类型中内容相同为同一元素，那么就要求我们必须重写hashCode()和equals()方法来确保 键的唯一性。代码 使用 HashMap 键---自定义类型
java
package com.itheima.map03;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class HashMapDemo {
public static void main(String[] args) {
//创建几个学生对象
Student stu1 = new Student("尼古拉斯赵四",18);
Student stu2 = new Student("法外狂徒广坤",19);
Student stu3 = new Student("作死界的典范苏大强",19);
Student stu4 = new Student("法外狂徒广坤",19);
// 定义一个Map集合 键 :学生类型 值 : 地址 字符串
HashMap<Student,String> map = new HashMap<>();
map.put(stu1,"象牙山");
map.put(stu2,"象牙山");
map.put(stu3,"苏州");
map.put(stu4,"中国台湾省");
//遍历
Set<Map.Entry<Student, String>> entries = map.entrySet();
for (Map.Entry<Student, String> entry : entries) {
System.out.println("来自"+entry.getValue()+"的"+entry.getKey().getName());
}
}
}
2.2 LinkedHashMap
特点
java
HashMap有的特点它都有，
区别在于 它在哈希表上面加了一层链表，记录存取顺序。
所以 它的存取顺序是一致的。代码
java
package com.itheima.map03;
import java.util.*;
public class LinkedHashMapDemo {
public static void main(String[] args) {
//创建几个学生对象
Student stu1 = new Student("尼古拉斯赵四",18);
Student stu2 = new Student("法外狂徒广坤",19);
Student stu3 = new Student("作死界的典范苏大强",19);
Student stu4 = new Student("法外狂徒广坤",19);
// 定义一个Map集合 键 :学生类型 值 : 地址 字符串
LinkedHashMap<Student,String> map = new LinkedHashMap<>();
map.put(stu1,"象牙山");
map.put(stu2,"象牙山");
map.put(stu3,"苏州");
map.put(stu4,"中国台湾省");
//遍历
Set<Map.Entry<Student, String>> entries = map.entrySet();
for (Map.Entry<Student, String> entry : entries) {
System.out.println("来自"+entry.getValue()+"的"+entry.getKey().getName());
}
}
}2.4 特殊的 一个子类 Properties
特点
java
Map<K,V>
HashMap<K,V>
允许存null值null键
底层 线程是不安全，效率高。
Hashtable<K,V>
不允许存储null值null键
底层 线程安全，效率低。
---特殊的儿子
Properties 没有写泛型
Properties extends Hashtable<Object,Object>
这个特殊儿子有什么用呢？
它是可以和IO流交互的一种Map集合。
所以 map集合功能能不能用
因为没有写泛型，所以实现的 Map集合里面的功能，键和值 是Object
一般来说 这个集合会对应一个文件 。这个文件叫 .properties
说白了 这个集合是专门处理这个 .properties 的文件的。
username=root
password=root
url=http://localhost:3306
这个集合的作用是用来 处理 .properties文件的读取的，它可以把文件格式数据读到 集合中。特殊方法
java
setProperty("二仙桥","成华大道");相当于put
pp.stringPropertyNames(); keySet方法
pp.getProperty(key); get(key)
主要发现了 它可以直接把集合中数据写到文件中
pp.store(new FileWriter("D://a.txt"),"my txt");代码
java
package com.itheima.map03;
import java.io.FileWriter;
import java.io.IOException;
import java.util.HashMap;
import java.util.Properties;
import java.util.Set;
public class PropertiesDemo {
public static void main(String[] args) throws IOException {
//创建集合对象
Properties pp = new Properties();
//没有写 因为 继承的时候已经确定了泛型 Object Object
// pp.put("二仙桥","成华大道");
// pp.put("能拉吗","能拉一点点");
// pp.put("谭sir",111);
pp.setProperty("二仙桥","成华大道");//作用就是put
pp.setProperty("能拉吗","能拉一点点");
pp.setProperty("谭sir","谭谈交通");
//键集
// Set<Object> keys = pp.keySet();
Set<String> keys = pp.stringPropertyNames();//其实就是keysSet方法
for (String key : keys) {
//根据键找值
// Object value = pp.get(key);
String value = pp.getProperty(key);
System.out.println(key+":"+value);
}
pp.store(new FileWriter("D://a.txt"),"my txt");
}
}2.5 可变参数
java
Collections 有个 addAll(Collection<T> coll,T...t)
可变参数的概念：可以变化的参数
JDK1.5之后才有的，解决了一个方法，对于某种类型不确定参数个数问题。
格式
数据类型...变量名
相当于 有 0-n个 这个类型参数
要求 必须用在参数列表最后。
一旦定义好这样的方法，这个类型的参数 可以写0~n个，相当于扩展了 更多方法。java
可变参数的本质 是一个数组！！
使用特点
必须放在参数列表的最后
应用场景
在我们写方法的时候，如果某个类型的参数个数不确定，那就使用可变参数来完成。java
package com.itheima.changeargs;
public class ChangeArgs {
public static void main(String[] args) {
sum(1);
sum();
sum(1,2);
int sum = sum(100, 1111, 111, 1, 11, 1, 1, 1, 1, 1, 4, 3, 3, 3, 4, 4, 44, 4);
System.out.println(sum);
}
public static int sum(int...a){//int[] a
//怎么做加法？
int sum = 0;
for (int i : a) {
sum+=i;
}
return sum;
}
// public int sum(int a){
// return a;
// }
//
// public int sum(int a,int b){
// return a+b;
// }
//
// public int sum(int a,int b,int c){
// return a+b+c;
// }
//
// public int sum(int a,int b,int c,int d){
// return a+b+c+d;
// }
// //写 100个 101
}第三章 斗地主--Map 版本
顺序改为从小到大。
准备牌
java
/*
准备牌思路
1:创建Map集合，键(编号-Integer) 值(牌面-String)
2:List colors集合 存储颜色
四种花色添加到集合中
3: List numbers 集合 存储 数字 有大小顺序
3 4 5 6 7 8 9 10 J Q K A 2
4: 先遍历 数字再遍历花色
起始序号 从0开始
5： 拼接牌面， 把一个序号 与 牌面 一起存到 map集合中
序号++
6: 不要忘了 小王 大王
检测一下集合中 是否形成了对应关系
*/
// 1:创建Map集合，键(编号-Integer) 值(牌面-String)
HashMap<Integer, String> pokerMap = new HashMap<>();
//2: 创建花色集合
ArrayList<String> colors = new ArrayList<>();
Collections.addAll(colors,"♦","♣","♥","♠");
//3:创建数字集合
ArrayList<String> numbers = new ArrayList<>();
Collections.addAll(numbers,"3","4","5","6","7","8","9","10","J","Q","K","A","2");
//4: 遍历拼接牌面
//循环外面定义 牌的序号
//内层循环执行一次 牌的序号++
int xuhao=0;
//先遍历数字 再遍历花色
for (String number : numbers) {
for (String color : colors) {
//拼接
String card = color+number;
//牌面和序号存到 map集合
pokerMap.put(xuhao,card);
xuhao++;//序号++
}
}
// 52张搞定了
//轮到 小王 大王
pokerMap.put(52,"小♚");
pokerMap.put(53,"大♛");
System.out.println("当前查看一下map集合中的关系:"+pokerMap);
洗牌
java
/*
2：洗牌 洗的是（序号）编号
map没法直接洗 ，但是我的编号是唯一的，洗编号
2.1:获取编号集合 keySet
2.2:编号集合是一个 set集合 无序，
创建一个list集合。
2.3 把set集合数据存到List中
2.4 打乱list集合的顺序 (编号的顺序)
*/
// 2.1:获取编号集合 keySet
Set<Integer> xuhaoSet = pokerMap.keySet();
// 2.2:创建一个有序集合 存储编号 目的可以实现打乱顺序
ArrayList<Integer> xuhaoList = new ArrayList<>();
//2.3 把set集合数据存到List中
xuhaoList.addAll(xuhaoSet);
System.out.println("序号没有打乱顺序的时候:"+xuhaoList);
//2.4 打乱
Collections.shuffle(xuhaoList);
System.out.println("序(编)号打乱顺序之后:"+xuhaoList);
发牌
java
/*
既然洗的是序号(编号)，那么发牌就发编号
xuhaoList.get(i) ===才是编号 才是序号
3：发牌
3.1 创建 玩家1 玩家2 玩家3 底牌的 编号集合
3.2 留三张底牌
3.3 对3取余 分别存到 玩家一玩家二 玩家三的编号集合
*/
// 3.1 创建 玩家1 玩家2 玩家3 底牌的 编号集合
ArrayList<Integer> playerNum1 = new ArrayList<>();
ArrayList<Integer> playerNum2 = new ArrayList<>();
ArrayList<Integer> playerNum3 = new ArrayList<>();
ArrayList<Integer> dipaiNum = new ArrayList<>();
// 3.2 发牌--发的是编号 xuhaoList.get(i)
for (int i = 0; i < xuhaoList.size(); i++) {
//获取编号--序号
Integer pokerNum = xuhaoList.get(i);
if(i>=51){
//底牌
dipaiNum.add(pokerNum);
}else if(i%3==0){
//玩家一
playerNum1.add(pokerNum);
}else if(i%3==1){
playerNum2.add(pokerNum);
}else {
playerNum3.add(pokerNum);
}
}
查看牌
java
/*4:查看牌 ---现在到手里是乱序的 编号
4.1 给玩家手里的编号集合进行排序
4.2 创建 三个玩家的牌面集合
4.3 把玩家的编号 转换成牌面 存到 牌面集合中
4.4 查看牌面集合
*/
// 4.1 给玩家手里的编号集合进行排序
Collections.sort(playerNum1);
Collections.sort(playerNum2);
Collections.sort(playerNum3);
System.out.println("玩家1:"+playerNum1);
System.out.println("玩家2:"+playerNum2);
System.out.println("玩家3:"+playerNum3);
// 4.2 三个玩家牌面集合 一个底牌牌面集合
ArrayList<String> player1 = new ArrayList<>();
ArrayList<String> player2 = new ArrayList<>();
ArrayList<String> player3 = new ArrayList<>();
ArrayList<String> dipai = new ArrayList<>();
//4.3 转换 通过序号编号 找到对应的牌面 键找值
for (Integer num : playerNum1) {
//num 玩家牌的序号 根据需要找到 牌面
String card = pokerMap.get(num);
//牌面存到对应集合中
player1.add(card);
}
for (Integer num : playerNum2) {
//num 玩家牌的序号 根据需要找到 牌面
String card = pokerMap.get(num);
//牌面存到对应集合中
player2.add(card);
}
for (Integer num : playerNum3) {
//num 玩家牌的序号 根据需要找到 牌面
String card = pokerMap.get(num);
//牌面存到对应集合中
player3.add(card);
} for (Integer num : dipaiNum) {
//num 玩家牌的序号 根据需要找到 牌面
String card = pokerMap.get(num);
//牌面存到对应集合中
dipai.add(card);
}
System.out.println("玩家1:"+player1);
System.out.println("玩家2:"+player2);
System.out.println("玩家3:"+player3);
System.out.println("底牌:"+dipai);
完整代码
java
package com.itheima.poker;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Set;
public class Poker {
public static void main(String[] args) {
/*
准备牌思路
1:创建Map集合，键(编号-Integer) 值(牌面-String)
2:List colors集合 存储颜色
四种花色添加到集合中
3: List numbers 集合 存储 数字 有大小顺序
3 4 5 6 7 8 9 10 J Q K A 2
4: 先遍历 数字再遍历花色
起始序号 从0开始
5： 拼接牌面， 把一个序号 与 牌面 一起存到 map集合中
序号++
6: 不要忘了 小王 大王
检测一下集合中 是否形成了对应关系
*/
// 1:创建Map集合，键(编号-Integer) 值(牌面-String)
HashMap<Integer, String> pokerMap = new HashMap<>();
//2: 创建花色集合
ArrayList<String> colors = new ArrayList<>();
Collections.addAll(colors,"♦","♣","♥","♠");
//3:创建数字集合
ArrayList<String> numbers = new ArrayList<>();
Collections.addAll(numbers,"3","4","5","6","7","8","9","10","J","Q","K","A","2");
//4: 遍历拼接牌面
//循环外面定义 牌的序号
//内层循环执行一次 牌的序号++
int xuhao=0;
//先遍历数字 再遍历花色
for (String number : numbers) {
for (String color : colors) {
//拼接
String card = color+number;
//牌面和序号存到 map集合
pokerMap.put(xuhao,card);
xuhao++;//序号++
}
}
// 52张搞定了
//轮到 小王 大王
pokerMap.put(52,"小♚");
pokerMap.put(53,"大♛");
System.out.println("当前查看一下map集合中的关系:"+pokerMap);
/*
2：洗牌 洗的是（序号）编号
map没法直接洗 ，但是我的编号是唯一的，洗编号
2.1:获取编号集合 keySet
2.2:编号集合是一个 set集合 无序，
创建一个list集合。
2.3 把set集合数据存到List中
2.4 打乱list集合的顺序 (编号的顺序)
*/
// 2.1:获取编号集合 keySet
Set<Integer> xuhaoSet = pokerMap.keySet();
// 2.2:创建一个有序集合 存储编号 目的可以实现打乱顺序
ArrayList<Integer> xuhaoList = new ArrayList<>();
//2.3 把set集合数据存到List中
xuhaoList.addAll(xuhaoSet);
System.out.println("序号没有打乱顺序的时候:"+xuhaoList);
//2.4 打乱
Collections.shuffle(xuhaoList);
System.out.println("序(编)号打乱顺序之后:"+xuhaoList);
/*
既然洗的是序号(编号)，那么发牌就发编号
xuhaoList.get(i) ===才是编号 才是序号
3：发牌
3.1 创建 玩家1 玩家2 玩家3 底牌的 编号集合
3.2 留三张底牌
3.3 对3取余 分别存到 玩家一玩家二 玩家三的编号集合
*/
// 3.1 创建 玩家1 玩家2 玩家3 底牌的 编号集合
ArrayList<Integer> playerNum1 = new ArrayList<>();
ArrayList<Integer> playerNum2 = new ArrayList<>();
ArrayList<Integer> playerNum3 = new ArrayList<>();
ArrayList<Integer> dipaiNum = new ArrayList<>();
// 3.2 发牌--发的是编号 xuhaoList.get(i)
for (int i = 0; i < xuhaoList.size(); i++) {
//获取编号--序号
Integer pokerNum = xuhaoList.get(i);
if(i>=51){
//底牌
dipaiNum.add(pokerNum);
}else if(i%3==0){
//玩家一
playerNum1.add(pokerNum);
}else if(i%3==1){
playerNum2.add(pokerNum);
}else {
playerNum3.add(pokerNum);
}
}
/*4:查看牌 ---现在到手里是乱序的 编号
4.1 给玩家手里的编号集合进行排序
4.2 创建 三个玩家的牌面集合
4.3 把玩家的编号 转换成牌面 存到 牌面集合中
4.4 查看牌面集合
*/
// 4.1 给玩家手里的编号集合进行排序
Collections.sort(playerNum1);
Collections.sort(playerNum2);
Collections.sort(playerNum3);
System.out.println("玩家1:"+playerNum1);
System.out.println("玩家2:"+playerNum2);
System.out.println("玩家3:"+playerNum3);
// 4.2 三个玩家牌面集合 一个底牌牌面集合
ArrayList<String> player1 = new ArrayList<>();
ArrayList<String> player2 = new ArrayList<>();
ArrayList<String> player3 = new ArrayList<>();
ArrayList<String> dipai = new ArrayList<>();
//4.3 转换 通过序号编号 找到对应的牌面 键找值
for (Integer num : playerNum1) {
//num 玩家牌的序号 根据需要找到 牌面
String card = pokerMap.get(num);
//牌面存到对应集合中
player1.add(card);
}
for (Integer num : playerNum2) {
//num 玩家牌的序号 根据需要找到 牌面
String card = pokerMap.get(num);
//牌面存到对应集合中
player2.add(card);
}
for (Integer num : playerNum3) {
//num 玩家牌的序号 根据需要找到 牌面
String card = pokerMap.get(num);
//牌面存到对应集合中
player3.add(card);
} for (Integer num : dipaiNum) {
//num 玩家牌的序号 根据需要找到 牌面
String card = pokerMap.get(num);
//牌面存到对应集合中
dipai.add(card);
}
System.out.println("玩家1:"+player1);
System.out.println("玩家2:"+player2);
System.out.println("玩家3:"+player3);
System.out.println("底牌:"+dipai);
}
}