Java--通过集合代码来解释斗地主发牌过程

最新推荐文章于 2023-04-06 23:36:24 发布
最新推荐文章于 2023-04-06 23:36:24 发布
阅读量1.2k 收藏
点赞数 2
分类专栏： JAVA 文章标签： java 集合 map 程序人生 经验分享
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52479012/article/details/110986811
版权

你打过牌吗？
你想知道系统是如何把牌随机的分配给玩家的吗？
今天的代码将介绍（以斗地主为例）系统的发牌系统的·代码内容
接下来，去探寻以下吧！！！！！

一：当你什么都没有时，想打牌时要干什么？（买牌）

牌是由花色和数字和大小王组成

第1：创建两个数组

花色数组

String [] aa = {"♥","♣","♦","♠"};   //为了方便观看用图来代替

数字数组

String [] bb = {"3","4","5","6","7","8","9","10","J","Q","K","A","2",};

第2：通过创建两种集合来存放牌和牌的位置

	Map< Integer, String> pokes = new HashMap();   //存放牌
		List<Integer> liss = new ArrayList<Integer>();   //存放后面要用牌的位置

第3：通过遍历的方法来把牌的花色和数字结合在一起，并且把牌存放在集合中 （遍历是通过增强for的方法去遍历打印）

int sum=1;     //这里定义的sum是最后输出牌做准备
		for (String b1:bb) {
			for(String a1:aa) {
				String pai=a1+b1;
				//System.out.println(pai);
				pokes.put(sum, pai);
				liss.add(sum);
				sum++;
			}
		}

第4：将大小王两张牌放进集合中

pokes.put(sum, "小王");
		liss.add(sum++);
		pokes.put(sum, "大王");
		liss.add(sum);

*这就是买牌的具体过程，接下来将输出打印和买牌的完整代码 *

Map< Integer, String> pokes = new HashMap();
		List<Integer> liss = new ArrayList<Integer>();
		String [] aa = {"♥","♣","♦","♠"};
		String [] bb = {"3","4","5","6","7","8","9","10","J","Q","K","A","2",};
		int sum=1;
		for (String b1:bb) {
			for(String a1:aa) {
				String pai=a1+b1;
				//System.out.println(pai);
				pokes.put(sum, pai);
				liss.add(sum);
				sum++;
			}
		}
		pokes.put(sum, "小王");
		liss.add(sum++);
		pokes.put(sum, "大王");
		liss.add(sum);
		
		
		System.out.println("牌"+pokes);
		System.out.println("位置"+liss);
		//输出两个集合的结果为：
		//牌{1=♥3, 2=♣3, 3=♦3, 4=♠3, 5=♥4, 6=♣4, 7=♦4, 8=♠4, 9=♥5, 10=♣5, 11=♦5, 12=♠5, 13=♥6, 14=♣6, 15=♦6, 16=♠6, 17=♥7, 18=♣7, 	      19=♦7, 20=♠7, 21=♥8, 22=♣8, 23=♦8, 24=♠8, 25=♥9, 26=♣9, 27=♦9, 28=♠9, 29=♥10, 30=♣10, 31=♦10, 32=♠10, 33=♥J, 34=♣J, 35=♦J, 36=♠J, 37=♥Q, 38=♣Q, 39=♦Q, 40=♠Q, 41=♥K, 42=♣K, 43=♦K, 44=♠K, 45=♥A, 46=♣A, 47=♦A, 48=♠A, 49=♥2, 50=♣2, 51=♦2, 52=♠2, 53=小王, 54=大王}
		
//位置[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]

二：当买完牌时要进行发牌。

第1：斗地主有三个玩家和底牌，所以需要四个集合来存放随机产生的数

		List<Integer> ma = new ArrayList<Integer>();
		List<Integer> yun = new ArrayList<Integer>();
		List<Integer> cai = new ArrayList<Integer>();
		List<Integer> di = new ArrayList<Integer>();

第2：发牌都是随机的，随机进行发牌

Collections.shuffle(liss); //通过Collextion工具类来随机产生牌

第3：把打乱的牌序，分发给三个玩家，并且留下三张底牌。

		for(int i=0;i<liss.size();i++) {
			 Integer fa = liss.get(i);
			System.out.println(fa);
			
			if(i>=liss.size()-3) {
				di.add(fa);
				
			}
			else if(i % 3==0) {
				ma.add(fa);
			}
			else if(i % 3==1) {
				yun.add(fa);
			}
			else if(i % 3==2) {
				cai.add(fa);
			}
		}

***这就是发牌的具体过程，接下来将输出打印和发牌的完整代码 ***

		List<Integer> ma = new ArrayList<Integer>();
		List<Integer> yun = new ArrayList<Integer>();
		List<Integer> cai = new ArrayList<Integer>();
		List<Integer> di = new ArrayList<Integer>();
		Collections.shuffle(liss);
		System.out.println("洗好牌的的顺序"+liss);
		for(int i=0;i<liss.size();i++) {
			 Integer fa = liss.get(i);
			System.out.println(fa);
			
			if(i>=liss.size()-3) {
				di.add(fa);
				
			}
			else if(i % 3==0) {
				ma.add(fa);
			}
			else if(i % 3==1) {
				yun.add(fa);
			}
			else if(i % 3==2) {
				cai.add(fa);
			}
		}
		System.out.println("ma的牌:"+ma);
		System.out.println("yun的牌:"+yun);
		System.out.println("cai的牌:"+cai);
		System.out.println("底牌:"+di);
		//输出结果
		//ma的牌:[41, 2, 34, 27, 54, 43, 13, 33, 21, 40, 20, 44, 49, 16, 51, 29, 3]
		//yun的牌:[45, 36, 47, 15, 22, 26, 31, 35, 10, 38, 7, 39, 4, 9, 1, 52, 46]
		//cai的牌:[28, 25, 17, 24, 30, 42, 12, 48, 8, 37, 50, 53, 6, 23, 11, 5, 32]
		//底牌:[18, 14, 19]

三：以上的代码输出的都是数字，接下来进行输出打印牌

完整代码，在进行讲解

public static String pritepokes(List<Integer> nn,Map<Integer, String> mm) {    //使用方法来进行转换
		Collections.sort(nn);  //升序：为了输出的牌是从小到大的。
		StringBuffer pp = new StringBuffer();  //创建一个空列表，用来存放牌

		for(Integer nnn:nn) {    //这里是使用增强for的方法进行遍历打印
			String poke = mm.get(nnn);  //把对应的位置换成牌（把List集合 转换成对应 Map集合value值
			pp.append(poke+" ");        //将获得的值添加StringBuffer创建的空列表
		}String str = pp.toString();     //方法返回的是String 进行转换
			return str;
		
	}

**下面将展示出完整代码和完整的输出结果： **

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;





public class 买牌 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Map< Integer, String> pokes = new HashMap();
		List<Integer> liss = new ArrayList<Integer>();
		String [] aa = {"♥","♣","♦","♠"};
		String [] bb = {"3","4","5","6","7","8","9","10","J","Q","K","A","2",};
		int sum=1;
		for (String b1:bb) {
			for(String a1:aa) {
				String pai=a1+b1;
				//System.out.println(pai);
				pokes.put(sum, pai);
				liss.add(sum);
				sum++;
			}
		}
		pokes.put(sum, "小王");
		liss.add(sum++);
		pokes.put(sum, "大王");
		liss.add(sum);
		
		
		System.out.println("牌"+pokes);
		System.out.println("位置"+liss);
		
		//发牌
		List<Integer> ma = new ArrayList<Integer>();
		List<Integer> yun = new ArrayList<Integer>();
		List<Integer> cai = new ArrayList<Integer>();
		List<Integer> di = new ArrayList<Integer>();
		Collections.shuffle(liss);
		System.out.println("洗好牌的的顺序"+liss);
		for(int i=0;i<liss.size();i++) {
			 Integer fa = liss.get(i);
			System.out.println(fa);
			
			if(i>=liss.size()-3) {
				di.add(fa);
				
			}
			else if(i % 3==0) {
				ma.add(fa);
			}
			else if(i % 3==1) {
				yun.add(fa);
			}
			else if(i % 3==2) {
				cai.add(fa);
			}
		}
		System.out.println("ma的牌:"+ma);
		System.out.println("yun的牌:"+yun);
		System.out.println("cai的牌:"+cai);
		System.out.println("底牌:"+di);
		System.out.println("ma的牌:"+pritepokes(ma, pokes));
		System.out.println("yun的牌:"+pritepokes(yun, pokes));
		System.out.println("cai的牌:"+pritepokes(cai, pokes));
		System.out.println("底牌:"+pritepokes(di, pokes));
	}

	
	public static String pritepokes(List<Integer> nn,Map<Integer, String> mm) {
		Collections.sort(nn);  //升序
		StringBuffer pp = new StringBuffer();

		for(Integer nnn:nn) {
			String poke = mm.get(nnn);
			pp.append(poke+" ");
		}String str = pp.toString();
			return str;
		
	}
}

输出结果：
牌{1=♥3, 2=♣3, 3=♦3, 4=♠3, 5=♥4, 6=♣4, 7=♦4, 8=♠4, 9=♥5, 10=♣5, 11=♦5, 12=♠5, 13=♥6, 14=♣6, 15=♦6, 16=♠6, 17=♥7, 18=♣7, 19=♦7, 20=♠7, 21=♥8, 22=♣8, 23=♦8, 24=♠8, 25=♥9, 26=♣9, 27=♦9, 28=♠9, 29=♥10, 30=♣10, 31=♦10, 32=♠10, 33=♥J, 34=♣J, 35=♦J, 36=♠J, 37=♥Q, 38=♣Q, 39=♦Q, 40=♠Q, 41=♥K, 42=♣K, 43=♦K, 44=♠K, 45=♥A, 46=♣A, 47=♦A, 48=♠A, 49=♥2, 50=♣2, 51=♦2, 52=♠2, 53=小王, 54=大王}
位置[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]
洗好牌的的顺序[54, 48, 29, 52, 49, 16, 5, 26, 43, 27, 21, 47, 32, 12, 45, 7, 2, 51, 20, 14, 22, 50, 6, 4, 28, 34, 41, 9, 31, 35, 36, 11, 53, 40, 46, 42, 10, 17, 15, 25, 13, 39, 1, 38, 8, 3, 23, 19, 18, 33, 37, 24, 44, 30]
54
48
29
52
49
16
5
26
43
27
21
47
32
12
45
7
2
51
20
14
22
50
6
4
28
34
41
9
31
35
36
11
53
40
46
42
10
17
15
25
13
39
1
38
8
3
23
19
18
33
37
24
44
30
ma的牌:[54, 52, 5, 27, 32, 7, 20, 50, 28, 9, 36, 40, 10, 25, 1, 3, 18]
yun的牌:[48, 49, 26, 21, 12, 2, 14, 6, 34, 31, 11, 46, 17, 13, 38, 23, 33]
cai的牌:[29, 16, 43, 47, 45, 51, 22, 4, 41, 35, 53, 42, 15, 39, 8, 19, 37]
底牌:[24, 44, 30]
ma的牌:♥3 ♦3 ♥4 ♦4 ♥5 ♣5 ♣7 ♠7 ♥9 ♦9 ♠9 ♠10 ♠J ♠Q ♣2 ♠2 大王
yun的牌:♣3 ♣4 ♦5 ♠5 ♥6 ♣6 ♥7 ♥8 ♦8 ♣9 ♦10 ♥J ♣J ♣Q ♣A ♠A ♥2
cai的牌:♠3 ♠4 ♦6 ♠6 ♦7 ♣8 ♥10 ♦J ♥Q ♦Q ♥K ♣K ♦K ♥A ♦A ♦2 小王
底牌:♠8 ♣10 ♠K

**

这就是完整的讲解过程，如果还可以，留个什么都行。 感谢

**

不想睡醒的梦
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java 斗地主_基于java实现斗地主代码实例解析
weixin_42512183的博客
02-12 769
斗地主规则：1. 组装54张扑克牌2. 将54张牌顺序打乱3. 三个玩家参与游戏，三人交替摸牌，每人17张牌，最后三张留作底牌。4. 查看三人各自手中的牌(按照牌的大小排序)、底牌手中扑克牌从大到小的摆放顺序：大王,小王,2,A,K,Q,J,10,9,8,7,6,5, 4,3分析：准备牌：完成数字与纸牌的映射关系：使用双列Map(HashMap)集合，完成一个数字与字符串纸牌的对应关系(相当于一个...
java斗地主发牌代码_java代码实现斗地主发牌功能
weixin_33726387的博客
02-16 975
本文实例为大家分享了java实现斗地主发牌功能的具体代码，供大家参考，具体内容如下实现斗地主发牌功能共54张牌，地主比其他两名玩家多三张牌。有一个card牌类和player玩家类，还有一个发牌类用于实现发牌的方法。为了模拟每个玩家的牌都是随机的，我是这样想的：1)初始化方法：用于将54张牌存到一个数组里，每张牌都一个唯一的序号。2) 利用随机数，将每个序号打乱存到一个新数组里。3)再根据序号取到初...
普歌-java 分析、实现 斗地主 案例（专为小白量身打造！！！）
m0_56168398的博客
04-25 151
斗地主综合案例： 1.准备牌：54张牌，存储到一个集合中 特殊牌：大王，小王 其他52张牌 定义一个数组/集合，存储4种花色：♠，♥，♣，♦
使用Java实现斗地主发牌逻辑（简单基础版）
个人博客
11-19 1631
大家好，我是垃圾佬，一个正在学Java的 “无业游民 ”，最近复习到了Map 集合，我觉得斗地主发牌这个案例来练习Map集合还是非常好的，话不多说先上图解。
JAVA之实现小项目——斗地主（随机发牌）
qq_44796093的博客
11-16 915
斗地主逻辑分析 1、准备牌： 准备牌54张，存储到一个集合中【特殊牌大王、小王】， 定义一个数组List colors = List.of( “♠”, “♥”, “♣”, “♦” ); 定义一个数组存储所有的牌13张List colors = List.of( “2”,“A”…“3” ); 2、洗牌： 随机打乱顺序再发牌 使用集合工具类 Collections 的方法 循环嵌套遍历所有的牌 shuffle(List<?> list, Random rnd)：使用指定的随机源对指定列表进行置换。
java实现斗地主发牌系统
08-19
Java实现斗地主发牌系统是一种基于Java语言的游戏系统，主要用于模拟斗地主游戏的发牌过程。下面是该系统的详细介绍和相关知识点。 玩家类 在该系统中，玩家类（Player）是游戏中的一个重要组件，负责存储玩家的...
Java项目-黑马斗地主完整Java代码
最新发布
04-23
6. **游戏逻辑**：斗地主的规则实现是一个复杂的逻辑过程，包括发牌、出牌、判断胜负等，这需要编写大量的条件判断和逻辑控制。 7. **网络编程**：如果项目支持多人在线对战，那么还会涉及TCP/IP通信协议，Socket...
java模拟斗地主洗牌发牌-可拓展
09-09
1）、将一副牌封装进入Map集合中，键为0-53的Integer数据，值为字符串 2）、洗牌：将Map集合的...3）、发牌：发给三个人，就是三个List加一个底牌的List 4）、看牌：将三人的List和底牌List的值进行排序（从大到小）
java实现模仿斗地主发牌
08-25
本文将为大家详细介绍如何使用 Java 实现模仿斗地主发牌，提供了详细的示例代码和实现步骤，为感兴趣的小伙伴们提供了有价值的参考。 资源提要 * Java 基础知识 * 斗地主游戏规则 * ArrayList 和 Collections 类的...
运用集合模拟斗地主发牌过程
12-03
利用集合模拟斗地主发牌的过程，运用TreeSet集合的自然排序特征和Map集合的键值对来匹配一张扑克牌。
java模拟斗地主发牌（代码）
weixin_53042504的博客
04-03 695
package practise; import java.util.*; import java.util.concurrent.Callable; public class Hash { public static void main(String[] args) { ArrayList<String> list=new ArrayList<String>(); //装牌 //花色 String[] .
Java实现模拟斗地主洗牌、发牌、看牌并排序
weixin_45734473的博客
03-30 3703
1、模拟斗地主洗牌、发牌、看牌 /* * 模拟斗地主洗牌、发牌、看牌*/ package PokerDemo; import java.util.ArrayList; import java.util.Collections; public class Poker { public static void main(String[] args) { //定义牌盒 ArrayList<String> arr=new ArrayList<S
Java实现斗地主的洗牌、发牌、看牌
mubiakai的博客
07-18 389
/斗地主/*
java--实现简单斗地主
WGS.
05-04 1521
/** * 模拟实现斗地主发牌过程的实现步骤 * 1.准备一副扑克牌 * a.定义一个ArrayList集合用来存放54张扑克 * b.定义一个String类型的数组用来构建花色[♠,♥,♦,♣] * c.定义一个String类型的数组用来保存扑克牌具体的值[3,4,5,6,7,8,9,10,J,Q,K,A,2] * d.把大小王添加到ArrayList集合中 ...
java应用——斗地主（二：抢地主的过程）
queen_queen的博客
02-07 2523
写代码的思路：     1.将留下的三张地主排重新定位     2.将每个玩家手里的牌进行排序：在将牌加入到每个玩家的链表时，就进行好排序     3.启动三个玩家的线程，根据排序好了的卡牌重新定位     4.进行抢地主：庄家在桌面添加组件，三个计时器（线程），抢地主的按钮。添加按钮监听器     5.在按钮监听事件中，将底牌添加到地主手中的牌里，并进行重新定位（不抢：要做判断是将卡牌
用Java实现简易的洗牌和发牌功能
不能再留遗憾了的博客
04-06 3143
用Java实现简易的洗牌和发牌功能
Java实现斗地主发牌
weixin_44296403的博客
09-09 1088
Java实现斗地主发牌，并自定义比较器，使用stream流的sorted方法进行排序
Java实现斗地主实例
悬在半空的博客
08-28 2097
准备牌阶段：斗地主一般用一副牌，有54张，其中有大王小王各1张，其他52张牌，分别是4个花色，每种花色13张。而每一种花色中的13张牌为：（由大到小）2 A K Q J 10 9 8 7 6 5 4 3,也定义一个集合来存储它们。发牌阶段：要求每一位玩家拥有17张牌，剩余三张作为底牌，一人一张轮流发牌：集合的索引（0-53）%3，定义4个集合，来存储3个玩家的牌和场上的底牌。索引%3，有三个值（0,1,2），0%3=0，1%3=1，2%3=2，3%3=0，当索引>=51时，改为发底牌。......
用java实现斗地主的思路
AriesLY0411的博客
11-18 1183
思路： 斗地主需要三个人：农民与地主，共54张牌随机发放给三个人，留三张底牌，每副牌有四种花色，13个序号 所以步骤大致分为： 1.准备牌：将54张牌存储到一个集合中 特殊牌：大王、小王 其他52张牌： 定义一个数组/集合：存储四种花色。 定义一个数组/集合：...
java利用集合完成斗地主的洗牌 发牌 排序 看牌功能
05-25
下面是利用Java集合实现斗地主的洗牌、发牌、排序和看牌功能的示例代码： ```java import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.List; import java....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不想睡醒的梦

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值