Map集合实例练习四--简单实战斗地主

忘是亡心i 2022-04-17 02:18 205阅读 0赞

## **集合嵌套** ##

集合嵌套并不是一个新的知识点，仅仅是集合内容又是集合，如单列集合嵌套、双列集合与单列集合嵌套、双列集合嵌套。

单列集合嵌套:

大学(List表示)有多个分校(list表示)，每个分校有多个班级(字符串)。

双列集合与单列集合嵌套

大学(Map表示，key:分校名称、value：分校集合)

有多个分校(List表示)

每个分校有多个班级(字符串)。

双列集合嵌套

大学(Map表示，key:分校名称、value：分校集合)

有多个分校(Map表示，key:班级名称、value 班级对象)

每个分校有多个班级(自定义班级类MyClass)。

如Collection集合嵌套、Collection集合与Map集合相互嵌套、Map集合嵌套。

*  ArrayList嵌套 ArrayList

ArrayList< ArrayList<String> >

Collection< ArrayList<Integer> >

*  Map嵌套 ArrayList

HashMap<String, ArrayList<Person>>

ArrayList< HashMap<String, String>>

*  Map集合嵌套

HashMap<String, HashMap<String,String>>

HashMap<String, HashMap<Person,String>>

# **模拟斗地主洗牌发牌** #

## 5.1 **案例介绍** ##

按照斗地主的规则，完成洗牌发牌的动作。

具体规则：

1. 组装54张扑克牌

2. 将54张牌顺序打乱

3. 三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。

4. 查看三人各自手中的牌（按照牌的大小排序）、底牌

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

具体代码逻辑如下：这是ArrayList集合的一个很好的接近实际意义的练习实战。对于新手来说，可能确实有点难，

但这只是最基础的练习。如果真想在这个行业干下去，请加强这些基础的练习。这些仅仅只是基础，在实际开发中，比这更难，

只有先从最基础的最基本的做起，实际开发，其实很多都是由这些最基础的知识去完成的。只是也相对的加了一些逻辑业务。

但不管怎么样，还是这句话，基础是关键，加油！不放弃，不抛弃！相信自己，你可以的。人生的酸甜苦辣，哪位成功的人士没有经历过呢?谁没有点这些风风雨雨的经历，只有经历这些大风大浪，才有可能成功。对自己说：come on!!!!!!!!!!!!

package cn.arrays;
 
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 
 /*要修改java文件编码，由GBK修改为UTF-8，
 因为默认的字符编码GBK没有我们要的梅花、方片、黑桃、红桃(♠♥♦♣)等特殊字符。*/
 public class Porker {
 	public static void main(String[] args) {
 		// 准备花色,创建ArrayList集合
 		ArrayList<String> color = new ArrayList<String>();
 		// 添加红 黑 梅花 方块 四种元素
 		color.add("♠");
 		color.add("♥");
 		color.add("♦");
 		color.add("♣");
 		// 准备数字，创建arrayList对象
 		ArrayList<String> number = new ArrayList<String>();
 		// Collections工具
 		Collections.addAll(number, "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2");
 		// 定义一个map集合：用来将数字与每一张牌进行对应
 		HashMap<Integer, String> map = new HashMap<Integer, String>();
 		int index = 0;
 		// 加入大小王
 		map.put(index++, "小☺");
 		map.put(index++, "大☻");
 		// 对这些数字进行遍历，arrayList的嵌套遍历
 		for (String thisNumber : number) {
 			// 对颜色进行遍历
 			for (String thisColor : color) {
 				// 添加到map集合对象中
 				map.put(index++, thisColor + thisNumber);
 			}
 		}
 		// 这样一副牌就准备好了，输出这副牌，可以查看下
 		System.out.println(map);
 		// 一副54张的牌 ArrayList里边为0-53的数的新牌
 		ArrayList<Integer> cards = new ArrayList<Integer>();
 		for (int i = 0; i <= 53; i++) {
 			cards.add(i);
 		}
 		// 控制台查看这53个数字
 		// System.out.println(cards);
 		// 洗牌，自然排序,即随机排序的
 		Collections.shuffle(cards);
 		System.out.println(cards);
 		// 创建三个玩家和底牌
 		ArrayList<Integer> iPlayer = new ArrayList<Integer>();
 		ArrayList<Integer> iPlayer2 = new ArrayList<Integer>();
 		ArrayList<Integer> iPlayer3 = new ArrayList<Integer>();
 		ArrayList<Integer> itCards = new ArrayList<Integer>();
 		// 遍历这副洗好的牌，遍历过程中，将牌发到三个玩家和底牌中
 		for (int i = 0; i < cards.size(); i++) {
 			// 如果i大于等于51
 			if (i >= 51) {
 				// 将其中的三张加入到底牌中
 				itCards.add(cards.get(i));
 			} else {
 				// 否则这51张牌平分给三位玩家
 				if (i % 3 == 0) {
 					// 玩家一获得的牌
 					iPlayer.add(cards.get(i));
 				} else if (i % 3 == 1) {
 					// 玩家二获得的牌
 					iPlayer2.add(cards.get(i));
 				} else {
 					// 玩家三获得的牌
 					iPlayer3.add(cards.get(i));
 				}
 			}
 		}
 		// 对每个人手中的牌排序，随机排序
 		Collections.sort(iPlayer);
 		Collections.sort(iPlayer2);
 		Collections.sort(iPlayer3);
 
 		// 对应数字形式的每个人手中的牌，定义字符串形式的牌
 		ArrayList<String> sPlayer = new ArrayList<String>();
 		ArrayList<String> sPlayer2 = new ArrayList<String>();
 		ArrayList<String> sPlayer3 = new ArrayList<String>();
 		ArrayList<String> sCards = new ArrayList<String>();
 		// 对三位玩家的牌进行遍历
 		for (Integer key : iPlayer) {
 			sPlayer.add(map.get(key));
 		}
 		for (Integer key : iPlayer2) {
 			sPlayer2.add(map.get(key));
 		}
 		for (Integer key : iPlayer3) {
 			sPlayer3.add(map.get(key));
 		}
 		// 对底牌进行遍历
 		for (Integer key : itCards) {
 			sCards.add(map.get(key));
 		}
 		// 最终： 看牌，各玩家查看自己的牌
 		System.out.println("玩家一的牌" + sPlayer); //
 		System.out.println("玩家二的牌" + sPlayer2);
 		System.out.println("玩家三的牌" + sPlayer3);
 		System.out.println("底牌" + sCards);
 	}
 }

### **掌握****Arrays类的常用方法；** ###

题目：

1) 定义类，定义main()方法，按以下要求编写代码：

*  定义int数组，初始化为：\{235,676,90,3,43,65,52,34,36,,776,9,86\}
 *  调用Arrays类的相关方法对数组进行升序排序；
 *  调用Arrays类的查找方法，在数组中查找元素：776，并打印查找结果；
 *  调用Arrays类的toString()方法打印这个int数组

### 6.1.2 **冒泡排序****、****选择排序****、****二分查找的程序实现****；** ###

### 6.1.3 **简述什么是Map集合，最常用的操作有哪些** ###

### 6.1.4 **参照集合体系图，说出所有常用集合及常用集合的相关方法** ###

### 6.1.5 **产生****10****个****1-20****之间的随机数要求随机数不能重复案例。** ###

### 6.1.6 ** ****键盘录入多个数据在控制台输出最大值案例。** ###

### 6.1.7 **ArrayList****集合的****toString()****方法源码阅读** ###

### 6.1.8 **键盘录入多个数据，按数据从小到大的顺序打印到控制台。** ###

### 6.1.9 **熟练使用带可变参数的方法(提示：Arrays类与Collections各一个)** ###

### 6.1.10 **描述4种数据结构的特点** ###

数组结构：一块连续的存储区域

链表结构：每个元素指向下一个元素

队列结构：容器先进先出的规则

栈结构：容器先进后出规则

### 6.1.11 **请你统计出,每个字母出现的次数.** ###

import java.util.HashMap;

import java.util.Map.Entry;

import java.util.Set;

/\*

\* String s  = "aliajflajfajfkjlajoiwpreiepoeroiewhroagflmslkgnmlkcnksahfoaphgnkjfia";

\* 请你统计出,每个字母出现的次数.

\* a - 2

\* l - 1

\* i - 1

\* j - 1

\* 1.遍历字符串

\* 2.保存到map 中 , 字母作为键 Character ,次数作为值 Integer

\* 3.map ,即是结果, 遍历 map .

\*/

public class Test \{

public static void main(String\[\] args) \{

String s  = "aliajflajfajfkjlajoiwpreiepoeroiewhroagflmslkgnmlkcnksahfoaphgnkjfia";

//创建map

HashMap<Character,Integer> hashMap = new HashMap<>();

// 1.遍历字符串

for (int i = 0; i < s.length() ; i++) \{

char key   = s.charAt(i);  // ch 为每一个字母.

//2.保存到map 中 , 字母作为键 Character ,次数作为值 Integer

//判断 是否包含key , 再保存.

if (hashMap.containsKey(key)) \{

// 包含,存过

//Integer count  = hashMap.get(key);// 获取之前次数,

//count++;  // + 1

hashMap.put(key, hashMap.get(key) + 1); // 再 保存

\}else \{

// 不包含 , 第一次存.

hashMap.put(key, 1);

// 3. 遍历map

Set<Entry<Character,Integer>> entrySet = hashMap.entrySet();

System.out.println( "字母  -- 次数 "  );

for (Entry<Character, Integer> entry : entrySet) \{

System.out.println(entry.getKey() +" -- "+ entry.getValue());

## 6.2 **代码题：** ##

### 6.2.1 **创建一个Map集合，添加数据进行测试，使用Map集合的两种遍历方式进行遍历** ###

<table style="width:568px;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;"> package&nbsp;day09_Test基础练习题; import&nbsp;java.util.HashMap; import&nbsp;java.util.Map; import&nbsp;java.util.Set; public&nbsp;class&nbsp;Test001 { //创建一个Map集合，添加数据进行测试，使用Map集合的两种遍历方式进行遍历 public&nbsp;static&nbsp;void&nbsp;main(String[]&nbsp;args) { Map&lt;String, String&gt;&nbsp;map&nbsp;=&nbsp;new&nbsp;HashMap&lt;String, String&gt;(); map.put("李连杰",&nbsp;"男人"); map.put("林志玲",&nbsp;"女人"); map.put("泰国有",&nbsp;"人妖"); //map集合第一种遍历方式 /*Set&lt;Entry&lt;String, String&gt;&gt; set = map.entrySet(); for (Entry&lt;String, String&gt; entry : set) { String key = entry.getKey(); String value = entry.getValue(); System.out.println("key="+key+",value="+value); }*/ //map集合第二种遍历方式 Set&lt;String&gt;&nbsp;set&nbsp;=&nbsp;map.keySet(); for&nbsp;(String&nbsp;key&nbsp;:&nbsp;set) { String&nbsp;value&nbsp;=&nbsp;map.get(key); System.out.println("key="+key+",value="+value); } } } </td> 
 </tr> 
 </tbody> 
</table>

## ##

### 6.2.2 **Map集合（相同键与不同键）** ###

定义一个测试类，在测试类中定义main()方法，按以下要求编写代码

1.实例化一个Map<String,String>集合

2.向集合内添加以下内容：

"NO01"，"安森"

"NO01"，"凯特"

"NO02"，"安森"

3.遍历集合，观察打印结果，请说明

4.如果存储“相同的键”时，会发生什么情况

5.如果存储“不同的键”，“相同的值”时，会怎样？

<table style="width:568px;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;"> package&nbsp;day09_Test基础练习题; import&nbsp;java.util.HashMap; import&nbsp;java.util.Map; import&nbsp;java.util.Map.Entry; import&nbsp;java.util.Set; public&nbsp;class&nbsp;Test002 { public&nbsp;static&nbsp;void&nbsp;main(String[]&nbsp;args) { Map&lt;String, String&gt;&nbsp;map&nbsp;=&nbsp;new&nbsp;HashMap&lt;&gt;(); map.put("NO01",&nbsp;"安森"); map.put("NO02",&nbsp;"凯特"); map.put("NO03",&nbsp;"安森"); Set&lt;Entry&lt;String, String&gt;&gt;&nbsp;entrySet&nbsp;=&nbsp;map.entrySet(); for&nbsp;(Entry&lt;String, String&gt;&nbsp;entry&nbsp;:&nbsp;entrySet) { String&nbsp;key&nbsp;=&nbsp;entry.getKey(); String&nbsp;value&nbsp;=&nbsp;entry.getValue(); System.out.println("key="+key+",value="+value); } System.out.println("---------------存储相同的键-------------------------"); map.put("NO01",&nbsp;"李安"); //查看map System.out.println(map);//将原先的值给覆盖了 System.out.println("---------------存储不同的键---------------------"); map.put("NO09",&nbsp;"008"); //查看此时的map System.out.println(map);//存储到Map中了 } } </td> 
 </tr> 
 </tbody> 
</table>

## ##

### 6.2.3 **遍历Map** ###

定义Student类，要求有如下成员：

成员属性(私有):

姓名(String类型)

性别(String类型)

年龄(int 类型)

构造方法：

无参

全参

成员方法：

get/set方法

(有兴趣，可以将toString()方法也添加上)

定义类测试类，在测试类中定义main()方法，按以下要求编写代码：

* 实例化一个Map<String,Student>集合
 * 向集合中添加以下元素：

“it001”,new Student(“王宝强”,’男’,20);

“it002”,new Student(“马蓉”,’女’,18);

“it003”,new Student(“宋喆”,’男’,19);

*  使用两种方式遍历这个Map

<table style="width:568px;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;"> Student类： package&nbsp;day09_Test基础练习题; public&nbsp;class&nbsp;Student { private&nbsp;String&nbsp;name; private&nbsp;char&nbsp;sex; private&nbsp;int&nbsp;age; public&nbsp;String getName() { return&nbsp;name; } public&nbsp;void&nbsp;setName(String&nbsp;name) { this.name&nbsp;=&nbsp;name; } public&nbsp;char&nbsp;getSex() { return&nbsp;sex; } public&nbsp;void&nbsp;setSex(char&nbsp;sex) { this.sex&nbsp;=&nbsp;sex; } public&nbsp;int&nbsp;getAge() { return&nbsp;age; } public&nbsp;void&nbsp;setAge(int&nbsp;age) { this.age&nbsp;=&nbsp;age; } @Override public&nbsp;String toString() { return&nbsp;"Student [name="&nbsp;+&nbsp;name&nbsp;+&nbsp;", sex="&nbsp;+&nbsp;sex&nbsp;+&nbsp;", age="&nbsp;+&nbsp;age&nbsp;+&nbsp;"]"; } public&nbsp;Student() { super(); //&nbsp;TODO&nbsp;Auto-generated constructor stub } public&nbsp;Student(String&nbsp;name,&nbsp;char&nbsp;sex,&nbsp;int&nbsp;age) { super(); this.name&nbsp;=&nbsp;name; this.sex&nbsp;=&nbsp;sex; this.age&nbsp;=&nbsp;age; } } </td> 
 </tr> 
 </tbody> 
</table>

<table style="width:568px;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;"> 测试类： package&nbsp;day09_Test基础练习题; import&nbsp;java.util.HashMap; import&nbsp;java.util.Map; import&nbsp;java.util.Map.Entry; import&nbsp;java.util.Set; public&nbsp;class&nbsp;Test003 { public&nbsp;static&nbsp;void&nbsp;main(String[]&nbsp;args) { Map&lt;String, Student&gt;&nbsp;map&nbsp;=&nbsp;new&nbsp;HashMap&lt;&gt;(); map.put("it001",&nbsp;new&nbsp;Student("王宝强",&nbsp;'男', 20)); map.put("it002",&nbsp;new&nbsp;Student("马蓉",&nbsp;'女', 18)); map.put("it003",&nbsp;new&nbsp;Student("宋哲",&nbsp;'男', 19)); //第一种方式 /*Set&lt;String&gt; keSet = map.keySet(); for (String key : keSet) { Student student = map.get(key); System.out.println("key="+key+",student的信息如下："+student); }*/ //第二种方式 Set&lt;Entry&lt;String, Student&gt;&gt;&nbsp;entrySet&nbsp;=&nbsp;map.entrySet(); for&nbsp;(Entry&lt;String, Student&gt;&nbsp;entry&nbsp;:&nbsp;entrySet) { String&nbsp;key&nbsp;=&nbsp;entry.getKey(); Student&nbsp;student&nbsp;=&nbsp;entry.getValue(); System.out.println("key="+key+",student的信息如下："+student); } } } </td> 
 </tr> 
 </tbody> 
</table>

### 6.2.4 **使用一种方式遍历集合，观察打印结果。怎样可以使这个集合判断出重复的键** ###

定义类Cat类，要求有以下成员：

成员属性(私有):

姓名

性别

年龄

构造方法：

无参

全参

成员方法：

get/set方法

定义一个测试类，在测试类中定义main()方法：

l在main()中按以下要求编写代码：

* 实例化一个Map<Cat,String>集合；
 * 向集合中添加以下元素：

new Cat(“波斯猫”,’公’,2)，”No01”

new Cat(“折耳猫”,’母’,1)，”No02”

new Cat(“折耳猫”,’母’,1)，”No03”

*  使用一种方式遍历集合，观察打印结果。怎样可以使这个集合判断出重复的键

<table style="width:568px;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;"> package&nbsp;day09_Test基础练习题; import&nbsp;java.util.HashMap; import&nbsp;java.util.Map; import&nbsp;java.util.Map.Entry; import&nbsp;java.util.Set; public&nbsp;class&nbsp;Test004 { public&nbsp;static&nbsp;void&nbsp;main(String[]&nbsp;args) { Map&lt;Cat, String&gt;&nbsp;map&nbsp;=&nbsp;new&nbsp;HashMap&lt;&gt;(); map.put(new&nbsp;Cat("波斯猫",&nbsp;'公', 2),&nbsp;"No01"); map.put(new&nbsp;Cat("折耳猫",&nbsp;'母', 1),&nbsp;"No02"); map.put(new&nbsp;Cat("折耳猫",&nbsp;'母', 1),&nbsp;"No03"); //遍历 Set&lt;Entry&lt;Cat, String&gt;&gt;&nbsp;entrySet&nbsp;=&nbsp;map.entrySet(); for&nbsp;(Entry&lt;Cat, String&gt;&nbsp;entry&nbsp;:&nbsp;entrySet) { Cat&nbsp;cat&nbsp;=&nbsp;entry.getKey(); String&nbsp;value&nbsp;=&nbsp;entry.getValue(); System.out.println("Cat="+cat+",value="+value); &nbsp; } } } </td> 
 </tr> 
 </tbody> 
</table>

## ##

### 6.2.5 **定义类，定义main()方法，按以下要求编写代码：定义一个ArrayList<Integer>，添加一些整数；使用Collections类的相关方法将内部元素排序；定义一个HashSet<Integer>，添加一些元素；请问是否可以使用同样的方式排序？为什么？将ArrayList内的元素打乱顺序；打印集合** ###

<table style="width:568px;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;"> package&nbsp;day09_Test基础练习题; import&nbsp;java.util.ArrayList; import&nbsp;java.util.Collections; import&nbsp;java.util.HashSet; public&nbsp;class&nbsp;Test005 { public&nbsp;static&nbsp;void&nbsp;main(String[]&nbsp;args) { ArrayList&lt;Integer&gt;&nbsp;list&nbsp;=&nbsp;new&nbsp;ArrayList&lt;&gt;(); list.add(11); list.add(222); list.add(3); list.add(40); list.add(5); //Collections.sort(list); System.out.println("此时的list集合元素为："+list); //HashSet HashSet&lt;Integer&gt;&nbsp;set&nbsp;=&nbsp;new&nbsp;HashSet&lt;&gt;(); set.add(23); set.add(2); set.add(203); set.add(24); set.add(3); System.out.println("没有排序的set="+set); //Collections.sort(set);使用Collections集合的sort方法里面只能放入List集合，不能放入set集合 //打印ArrayList集合 Collections.shuffle(list); System.out.println("打乱顺序的list集合元素为："+list); } } </td> 
 </tr> 
 </tbody> 
</table>

## ##

### 6.2.6 **定义一个Map，存储如下内容：增加一位新老师Allen教JDBC;Lucy改为教CoreJava****，****使用两种方式遍历集合；输出所有教JDBC的讲师** ###

定义一个Map，存储如下内容：

老师  课程

Tom  CoreJava

John  Oracle

Susan Oracle

Jerry  JDBC

Jim  Unix

Kevin    JSP

Lucy  JSP

完成以下要求：

1).增加一位新老师Allen教JDBC;

2).Lucy改为教CoreJava

3).使用两种方式遍历集合；

4).输出所有教JDBC的讲师

## ##

### 6.2.7 **静态方法，list集合** ###

1.定义一个类Demo；

2.内部定义一个静态方法asList，此方法可以接收任意多的String类型参数，方法功能：将所有String参数的值存储到一个具有String泛型的List集合中，并将此集合返回；

3.在Demo类中定义main()方法，并调用asList方法获取返回值，并遍历集合

<table style="width:568px;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;"> package day09_Test拓展三道编程题; import java.util.ArrayList; import java.util.List; public class Test002 { /* &nbsp;* 1.定义一个类Demo； 2.内部定义一个静态方法asList，此方法可以接收任意多的String类型参数， &nbsp;&nbsp;&nbsp;方法功能：将所有String参数的值存储到一个具有String泛型的List集合 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;中，并将此集合返回； 3.在Demo类中定义main()方法，并调用asList方法获取返回值，并遍历集 &nbsp;&nbsp;合； &nbsp;*/ public static void main(String[] args) { List&lt;String&gt; strList = asList("Java","Oracle","MySql","JDBC","JSP","HTML","jQuery"); for(String s : strList){ System.out.println(s); } } private static List&lt;String&gt; asList(String ... values) { List&lt;String&gt; strList = new ArrayList&lt;&gt;(); for(String s : values){ strList.add(s); } return strList; } } </td> 
 </tr> 
 </tbody> 
</table>

### 6.2.8 **抽到明牌者为地主** ###

成龙，甄子丹，李连杰三个人打斗地主，三人约定，洗牌后，随机抽取一张"明牌"并夹在中间；然后依次抓牌，谁抓到这张便自动作为地主，并收取最后三张。

要求：请用程序实现这一过程，最后打印地主名，以及三个人的牌(要求排序)；

思路：

1.定义一个Map集合存储一副扑克牌；List存储编号；

2.洗牌；

3.随机抽取一个索引(该值必须在倒数三张之前)，用于表示"明牌"，在发牌时谁抓到这一张便作为"地主"；

4.依次给三个人(成龙，甄子丹，李连杰)发牌，并监督谁作为地主；地主自动收取最后三张。

5.打印地主名；

6.最后以排序后的方式打印每个人手里的牌

<table style="width:568px;"> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;"> package&nbsp;day09_Test拓展三道编程题; import&nbsp;java.util.ArrayList; import&nbsp;java.util.Collections; import&nbsp;java.util.HashMap; import&nbsp;java.util.List; import&nbsp;java.util.Map; import&nbsp;java.util.Random; &nbsp; public&nbsp;class&nbsp;Test003 { /*成龙，甄子丹，李连杰三个人打斗地主，三人约定，洗牌后，随机抽取一张"明牌"并夹在中间；然后依次抓牌，谁抓到这张便自动作为地主，并收取最后三张。 要求：请用程序实现这一过程，最后打印地主名，以及三个人的牌(要求排序)； 思路： &nbsp;&nbsp;1.定义一个Map集合存储一副扑克牌；List存储编号； &nbsp;&nbsp;2.洗牌； &nbsp;&nbsp;3.随机抽取一个索引(该值必须在倒数三张之前)，用于表示"明牌"，在发牌 &nbsp;&nbsp;&nbsp;&nbsp;时谁抓到这一张便作为"地主"； &nbsp;&nbsp;4.依次给三个人(成龙，甄子丹，李连杰)发牌，并监督谁作为地主；地主自 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;动收取最后三张。 &nbsp;&nbsp;5.打印地主名； &nbsp;&nbsp;6.最后以排序后的方式打印每个人手里的牌 &nbsp;*/ public&nbsp;static&nbsp;void&nbsp;main(String[]&nbsp;args) { String[]&nbsp;colors&nbsp;= {"♥","♦","♠","♣"}; String[]&nbsp;numbers&nbsp;= {"3","4","5","6","7","8","9","10","J","Q","K","A","2"}; Map&lt;Integer,String&gt;&nbsp;pokerMap&nbsp;=&nbsp;new&nbsp;HashMap&lt;&gt;(); List&lt;Integer&gt;&nbsp;indexList&nbsp;=&nbsp;new&nbsp;ArrayList&lt;&gt;(); int&nbsp;index&nbsp;= 1; for(String&nbsp;n&nbsp;:&nbsp;numbers){ for(String&nbsp;c&nbsp;:&nbsp;colors){ pokerMap.put(index,&nbsp;c&nbsp;+&nbsp;n); indexList.add(index); index++; } } pokerMap.put(index,&nbsp;"小王"); indexList.add(index); index++; pokerMap.put(index,&nbsp;"大王"); indexList.add(index); //2.洗牌 Collections.shuffle(indexList); //3.随机抽取一张作为明牌 int&nbsp;flagIndex&nbsp;= -1; Random&nbsp;rdm&nbsp;=&nbsp;new&nbsp;Random(); flagIndex&nbsp;=&nbsp;rdm.nextInt(indexList.size() - 3); System.out.println("明牌索引："&nbsp;+&nbsp;flagIndex); //4.发牌 List&lt;Integer&gt;&nbsp;chenglongList&nbsp;=&nbsp;new&nbsp;ArrayList&lt;&gt;(); List&lt;Integer&gt;&nbsp;zhenzidanList&nbsp;=&nbsp;new&nbsp;ArrayList&lt;&gt;(); List&lt;Integer&gt;&nbsp;lilianjieList&nbsp;=&nbsp;new&nbsp;ArrayList&lt;&gt;(); int&nbsp;dizhu&nbsp;= 0;//1.成龙；2.甄子丹；3.李连杰 for(int&nbsp;i&nbsp;= 0;i&nbsp;&lt;&nbsp;indexList.size() ;&nbsp;i++){ if(i&nbsp;&gt;=&nbsp;indexList.size() - 3){ if(dizhu&nbsp;== 1){ chenglongList.add(indexList.get(i)); }else&nbsp;if(dizhu&nbsp;== 2){ zhenzidanList.add(indexList.get(i)); }else&nbsp;if(dizhu&nbsp;== 3){ lilianjieList.add(indexList.get(i)); } }else{ if(i&nbsp;% 3 == 0){ chenglongList.add(indexList.get(i)); if(i&nbsp;==&nbsp;flagIndex){ dizhu&nbsp;= 1; System.out.println("地主：成龙"); } }else&nbsp;if(i&nbsp;% 3 == 1){ zhenzidanList.add(indexList.get(i)); if(i&nbsp;==&nbsp;flagIndex){ dizhu&nbsp;= 2; System.out.println("地主：甄子丹"); } }else&nbsp;if(i&nbsp;% 3 == 2){ lilianjieList.add(indexList.get(i)); if(i&nbsp;==&nbsp;flagIndex){ dizhu&nbsp;= 3; System.out.println("地主：李连杰"); } } } } //排序 Collections.sort(chenglongList); Collections.sort(zhenzidanList); Collections.sort(lilianjieList); //看牌 System.out.println("成龙："&nbsp;+&nbsp;lookPoker(chenglongList,pokerMap)); System.out.println("甄子丹："&nbsp;+&nbsp;lookPoker(zhenzidanList,pokerMap)); System.out.println("李连杰："&nbsp;+&nbsp;lookPoker(lilianjieList,pokerMap)); &nbsp; } public&nbsp;static&nbsp;String lookPoker(List&lt;Integer&gt;&nbsp;list,Map&lt;Integer,String&gt;&nbsp;pokerMap){ StringBuffer&nbsp;buf&nbsp;=&nbsp;new&nbsp;StringBuffer("["); for(int&nbsp;i&nbsp;= 0;i&nbsp;&lt;&nbsp;list.size() ;&nbsp;i++){ buf.append(pokerMap.get(list.get(i))); if(i&nbsp;&lt;&nbsp;list.size() - 1){ buf.append(", "); } } buf.append("]"); return&nbsp;buf.toString(); } } </td> 
 </tr> 
 </tbody> 
</table>