你所在的位置： >
斗地主小游戏大全
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.
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.
【斗地主小游戏专题】
专题介绍：7399小游戏为您提供最新最全【斗地主】小游戏在线免费玩，还有各类斗地主小游戏下载，最新的斗地主小游戏排行榜，更多好玩的小游戏尽在7399游戏大全!
人气：3155691人气：1754640人气：1174332人气：430139人气：406741人气：357418人气：290747人气：207083人气：150284人气：141435人气：96581人气：84628人气：76504人气：73005人气：49286人气：42753人气：31477人气：11372人气：4960人气：3860人气：3417人气：2976人气：2324人气：2250人气：1419人气：465Java斗地主游戏开发 - 简书
Java斗地主游戏开发
游戏中用到的技术：递归，排序游戏中用到的对象：
游戏中的操作：
游戏规则：
定义一副扑克牌数组对象
定义大小为54的字符串数组表示一副扑克牌更直观的展示给游戏玩家
* 一副扑克牌，54张，初始化
*字符串数组，
private String[] pukepai = new String[] {
"红桃A", "方块A", "梅花A", "黑桃A",
"红桃2", "方块2", "梅花2", "黑桃2",
"红桃3", "方块3", "梅花3", "黑桃3",
"红桃4", "方块4", "梅花4", "黑桃4",
"红桃5", "方块5", "梅花5", "黑桃5",
"红桃6", "方块6", "梅花6", "黑桃6",
"红桃7", "方块7", "梅花7", "黑桃7",
"红桃8", "方块8", "梅花8", "黑桃8",
"红桃9", "方块9", "梅花9", "黑桃9",
"红桃10", "方块10", "梅花10", "黑桃10",
"红桃J", "方块J", "梅花J", "黑桃J",
"红桃Q", "方块Q", "梅花Q", "黑Q",
"红桃K", "方块K", "梅花K", "黑桃K",
"大鬼", "小鬼" };
定义大小为54的整型数组表示一副扑克牌用户进行扑克牌的大小比较
*定义一个整型数组对象
*字符串表示的扑克牌，比较大小相对困难
*定义一个整型数组对象表示扑克牌来替代字符串表示的扑克牌
*进行扑克牌的大小比较
int[] pukepaiInts = new int[] {
11, 12, 13, 14,//"红桃A", "方块A", "梅花A", "黑桃A",
21, 22, 23, 24,//"红桃2", "方块2", "梅花2", "黑桃2",
31, 32, 33, 34,//"红桃3", "方块3", "梅花3", "黑桃3",
41, 42, 43, 44,//"红桃4", "方块4", "梅花4", "黑桃4",
51, 52, 53, 54,//"红桃5", "方块5", "梅花5", "黑桃5",
61, 62, 63, 64,//"红桃6", "方块6", "梅花6", "黑桃6",
71, 72, 73, 74,//"红桃7", "方块7", "梅花7", "黑桃7",
81, 82, 83, 84,//"红桃8", "方块8", "梅花8", "黑桃8",
91, 92, 93, 94,//"红桃9", "方块9", "梅花9", "黑桃9",
101, 102, 103, 104,//"红桃10", "方块10", "梅花10", "黑桃10",
111,112,113,114,//"红桃J", "方块J", "梅花J", "黑桃J",
121, 122, 123, 124,//"红桃Q", "方块Q", "梅花Q", "黑桃Q",
131, 132, 133, 134,//"红桃K", "方块K", "梅花K", "黑桃K",
0, 1//"大鬼", "小鬼"
定义游戏玩家类
游戏玩家：ID、名称、在游戏中的身份、在游戏中的状态、手里的牌、要出的牌、在牌桌上的位置
public class Gamers {
* 玩家唯一ID
* 玩家名称
* 玩家身份
* "农民" / "地主"
* 玩家手里的牌
public List&String&
public int[] paiI
* 玩家在游戏中的位置
* "1" / "2" / "3"
* 玩家要出的牌
public int[] chuP
* 玩家在游行中的状态
* "出牌" / "等待" / "胜利" / "失败"
public String operationS
实现洗牌函数
* @param pukepai
初始化的扑克牌对象
* @return 返回洗好后的扑克牌对象
private String[] xipai(String[] pukepai) {
//定义一副空的扑克牌
String[] xipaiEnd = new String[54];
// 把初始化的扑克牌元素插入到新的空的扑克牌中
for (int i = 1; i & pukepai. i++) {
int index = zeroToFifty_four(xipaiEnd);
xipaiEnd[index] = pukepai[i];
System.out.println("第 " + i + " 张牌 " + pukepai[i] + " 位置下标："
return xipaiE
寻找元素为空的下标，用到递归算法
* 寻找元素为空的下标
* @param pukepai
* @return 元素为空的下标
private int zeroToFifty_four(String[] pukepai) {
// 0 &= Math.random & 1
//随机获取下标，范围0~53
int index = (int) (Math.random() * 54);
if (pukepai[index] != null) {
// System.out.println("下标 " + index + " 元素不为空");
// 继续寻找元素为空的下标
return zeroToFifty_four(pukepai);
实现发牌函数
* 给三位玩家发牌的函数
* @param pukepai
传入洗完后的扑克牌对象
* @param wanjiaA
* @param wanjiaB
* @paramwanjiaC
* @return 返回三位玩家对象列表
private List&Wanjia& fapai(String[] pukepai, Wanjia wanjiaA,
Wanjia wanjiaB, Wanjia wanjiaC) {
List&Wanjia& wanjias = new ArrayList&Xipai.Wanjia&();
// 预留最后三张底牌
for (int i = 0; i & pukepai.length - 3; i++) {
if (i % 3 == 0) {// 第一个
wanjiaA.pais.add(pukepai[i]);
} else if (i % 3 == 1) {// 第二个
wanjiaB.pais.add(pukepai[i]);
} else if (i % 3 == 2) {// 第三个
wanjiaC.pais.add(pukepai[i]);
wanjias.add(wanjiaA);
wanjias.add(wanjiaB);
wanjias.add(wanjiaC);
测试洗牌发牌函数
public static void main(String[] arg) {
Xipai localXipai = new Xipai();
// 洗完之后的扑克牌
String[] xipaiEnd = localXipai.xipai(localXipai.pukepai);
// 初始化三个玩家对象
Wanjia wanjiaA = localXipai.new Wanjia();
wanjiaA.name = "路人甲";
wanjiaA.status = "农民";
wanjiaA.position = "左";
wanjiaA.pais = new ArrayList&String&();
Wanjia wanjiaB = localXipai.new Wanjia();
wanjiaB.name = "路人乙";
wanjiaB.status = "农民";
wanjiaB.position = "右";
wanjiaB.pais = new ArrayList&String&();
Wanjia wanjiaC = localXipai.new Wanjia();
wanjiaC.name = "官二代C";
wanjiaC.status = "地主";
wanjiaC.position = "下";
wanjiaC.pais = new ArrayList&String&();
// 给三个玩家发牌
List&Wanjia& listWanjias = localXipai.fapai(xipaiEnd, wanjiaA, wanjiaB,
// 分别打印玩家手里的牌
for (Wanjia wanjia : listWanjias) {
System.out.println(wanjia.name + "手里的牌：" + wanjia.pais.toString()
System.out.println("底牌：" + xipaiEnd[53] + " " + xipaiEnd[52] + " "
+ xipaiEnd[51]);
测试结果图
测试发牌效果
游戏玩家抢地主
把底牌发给抢到地主的玩家
System.out.println("开始抢地主" + "\n");
System.out.println("玩家 --- " + wanjiaB.name + " --- 抢到地主" + "\n");
wanjiaB.status = "地主";
wanjiaB.pais.add(xipaiEnd[53]);
wanjiaB.pais.add(xipaiEnd[52]);
wanjiaB.pais.add(xipaiEnd[51]);
//其他玩家为农民
wanjiaA.status = "农民";
wanjiaC.status = "农民";
//分别打印玩家手里的牌
for (Wanjia wanjia : listWanjias) {
System.out.println("玩家=== " + wanjia.name + " ( " + wanjia.status
+ " ) ===手里的牌" + "\n");
System.out.println(wanjia.pais.toString() + "\n");
抢地主结束各玩家手里的牌
地主与农民手里的牌
对玩家手里的牌进行排序
发给玩家的牌是无序的，对玩家手里的牌由小到大排序，这里用到整型数组
System.out.println("由小到大排序手里的牌" + "\n");
System.out.println("开始对玩家 " + wanjiaA.name + " 手中的牌排序" + "\n");
// 玩家A，玩家手里的牌转换成对应的整型数组
wanjiaA.paiInts = localXipai.transitionToInts(wanjiaA.pais);
System.out.println("排序中... 玩家 " + wanjiaA.name + " 手中的牌排序 "
+ wanjiaA.paiInts[0] + "\n");
wanjiaA.pais.clear();
//排序完成，再把整型数组转换成字符串数组
wanjiaA.pais.addAll(localXipai.transitionToList(wanjiaA.paiInts));
System.out.println("玩家 " + wanjiaA.name + " 手中的牌排序结束" + "\n");
wanjiaB.paiInts = localXipai.transitionToInts(wanjiaB.pais);
wanjiaB.pais.clear();
wanjiaB.pais.addAll(localXipai.transitionToList(wanjiaB.paiInts));
wanjiaC.paiInts = localXipai.transitionToInts(wanjiaC.pais);
wanjiaC.pais.clear();
wanjiaC.pais.addAll(localXipai.transitionToList(wanjiaC.paiInts));
System.out.println("排序结果:" + "\n");
for (Wanjia wanjia : listWanjias) {
System.out.println("玩家=== " + wanjia.name + " ( " + wanjia.status
+ " ) ===手里的牌" + "\n");
System.out.println(wanjia.pais.toString() + "\n");
扑克牌排序结束
玩家手里的牌排序结果
字符串列表表示的扑克牌转化为整型数组表示的扑克牌函数
*字符串列表表示的扑克牌转化为整型数组表示的扑克牌
* 然后再由小到大排序
* @param str
* @return 返回由小到大排序的数组
private int[] transitionToInts(List&String& str) {
int[] ints = new int[str.size()];
for (int i = 0; i & str.size(); i++) {
String pai = str.get(i);
if (pareTo("红桃A") == 0) {
ints[i] = 11;
} else if (pareTo("红桃2") == 0) {
ints[i] = 21;
} else if (pareTo("红桃3") == 0) {
ints[i] = 31;
} else if (pareTo("红桃4") == 0) {
ints[i] = 41;
} else if (pareTo("红桃5") == 0) {
ints[i] = 51;
} else if (pareTo("红桃6") == 0) {
ints[i] = 61;
} else if (pareTo("红桃7") == 0) {
ints[i] = 71;
} else if (pareTo("红桃8") == 0) {
ints[i] = 81;
} else if (pareTo("红桃9") == 0) {
ints[i] = 91;
} else if (pareTo("红桃10") == 0) {
ints[i] = 101;
} else if (pareTo("红桃J") == 0) {
ints[i] = 111;
} else if (pareTo("红桃Q") == 0) {
ints[i] = 121;
} else if (pareTo("红桃K") == 0) {
ints[i] = 131;
} else if (pareTo("方块A") == 0) {
ints[i] = 12;
} else if (pareTo("方块2") == 0) {
ints[i] = 22;
} else if (pareTo("方块3") == 0) {
ints[i] = 32;
} else if (pareTo("方块4") == 0) {
ints[i] = 42;
} else if (pareTo("方块5") == 0) {
ints[i] = 52;
} else if (pareTo("方块6") == 0) {
ints[i] = 62;
} else if (pareTo("方块7") == 0) {
ints[i] = 72;
} else if (pareTo("方块8") == 0) {
ints[i] = 82;
} else if (pareTo("方块9") == 0) {
ints[i] = 92;
} else if (pareTo("方块10") == 0) {
ints[i] = 102;
} else if (pareTo("方块J") == 0) {
ints[i] = 112;
} else if (pareTo("方块Q") == 0) {
ints[i] = 122;
} else if (pareTo("方块K") == 0) {
ints[i] = 132;
} else if (pareTo("梅花A") == 0) {
ints[i] = 13;
} else if (pareTo("梅花2") == 0) {
ints[i] = 23;
} else if (pareTo("梅花3") == 0) {
ints[i] = 33;
} else if (pareTo("梅花4") == 0) {
ints[i] = 43;
} else if (pareTo("梅花5") == 0) {
ints[i] = 53;
} else if (pareTo("梅花6") == 0) {
ints[i] = 63;
} else if (pareTo("梅花7") == 0) {
ints[i] = 73;
} else if (pareTo("梅花8") == 0) {
ints[i] = 83;
} else if (pareTo("梅花9") == 0) {
ints[i] = 93;
} else if (pareTo("梅花10") == 0) {
ints[i] = 103;
} else if (pareTo("梅花J") == 0) {
ints[i] = 113;
} else if (pareTo("梅花Q") == 0) {
ints[i] = 123;
} else if (pareTo("梅花K") == 0) {
ints[i] = 133;
} else if (pareTo("黑桃A") == 0) {
ints[i] = 14;
} else if (pareTo("黑桃2") == 0) {
ints[i] = 24;
} else if (pareTo("黑桃3") == 0) {
ints[i] = 34;
} else if (pareTo("黑桃4") == 0) {
ints[i] = 44;
} else if (pareTo("黑桃5") == 0) {
ints[i] = 54;
} else if (pareTo("黑桃6") == 0) {
ints[i] = 64;
} else if (pareTo("黑桃7") == 0) {
ints[i] = 74;
} else if (pareTo("黑桃8") == 0) {
ints[i] = 84;
} else if (pareTo("黑桃9") == 0) {
ints[i] = 94;
} else if (pareTo("黑桃10") == 0) {
ints[i] = 104;
} else if (pareTo("黑桃J") == 0) {
ints[i] = 114;
} else if (pareTo("黑桃Q") == 0) {
ints[i] = 124;
} else if (pareTo("黑桃K") == 0) {
ints[i] = 134;
} else if (pareTo("大鬼") == 0) {
ints[i] = 1;
} else if (pareTo("小鬼") == 0) {
ints[i] = 0;
return sortBubblingFromMinToMax(ints);
整型数组由小到大排序函数，用到冒泡排序
* 冒泡排序， 由小到大
* @param paramInts
public int[] sortBubblingFromMinToMax(int[] paramInts) {
return sortBubblingFromMinToMax(paramInts, 0, paramInts.length - 1);
* 递归方式实现冒泡排序
* @param paramInts 原始数组
* @param index 数组下标
* @param moreIndex 该下标是数组中剩余元素中的最大值
public int[] sortBubblingFromMinToMax(int[] paramInts, int index,
int moreIndex) {
if (moreIndex == 0) {
return paramI
} else if (index == moreIndex) {
return sortBubblingFromMinToMax(paramInts, 0, moreIndex - 1);
} else if (paramInts[index + 1] & paramInts[index]) {// 后一元素小于于前一元素
// 交换数值
int temp = paramInts[index];
paramInts[index] = paramInts[index + 1];
paramInts[index + 1] =
// 比较一下对元素
return sortBubblingFromMinToMax(paramInts, index + 1, moreIndex);
} else {// 后一元素不于前一元素
// 比较下一对元素
return sortBubblingFromMinToMax(paramInts, index + 1, moreIndex);
整型数组表示的扑克牌转化为字符串列表表示的扑克牌函数
* 整型数组表示的扑克牌转化为字符串数组表示的扑克牌
* 展示需要
* @param paramInts
public static List&String& transitionToList(int[] paramInts) {
List&String& listStr = new ArrayList&String&();
for (int value : paramInts) {
switch (value) {
listStr.add("小鬼");
listStr.add("大鬼");
listStr.add("红桃A");
listStr.add("方块A");
listStr.add("梅花A");
listStr.add("黑桃A");
listStr.add("红桃2");
listStr.add("方块2");
listStr.add("梅花2");
listStr.add("黑桃2");
listStr.add("红桃3");
listStr.add("方块3");
listStr.add("梅花3");
listStr.add("黑桃3");
listStr.add("红桃4");
listStr.add("方块4");
listStr.add("梅花4");
listStr.add("黑桃4");
listStr.add("红桃5");
listStr.add("方块5");
listStr.add("梅花5");
listStr.add("黑桃5");
listStr.add("红桃6");
listStr.add("方块6");
listStr.add("梅花6");
listStr.add("黑桃6");
listStr.add("红桃7");
listStr.add("方块7");
listStr.add("梅花7");
listStr.add("黑桃7");
listStr.add("红桃8");
listStr.add("方块8");
listStr.add("梅花8");
listStr.add("黑桃8");
listStr.add("红桃9");
listStr.add("方块9");
listStr.add("梅花9");
listStr.add("黑桃9");
listStr.add("红桃10");
listStr.add("方块10");
listStr.add("梅花10");
listStr.add("黑桃10");
listStr.add("红桃J");
listStr.add("方块J");
listStr.add("梅花J");
listStr.add("黑桃J");
listStr.add("红桃Q");
listStr.add("方块Q");
listStr.add("梅花Q");
listStr.add("黑桃Q");
listStr.add("红桃K");
listStr.add("方块K");
listStr.add("梅花K");
listStr.add("黑桃K");
listStr.add("程序错误");
return listS
规则类，符合如下两个原则：1.玩家出的牌拍是否符合出牌的规则2.玩家出的牌是否压过其他玩家出的牌
1.玩家出的牌是否符合出牌的规则玩家出一张牌：随意一涨牌玩家出二张牌：两张相同的牌--"一对"玩家出三张牌：三张相同的牌--"三不带"玩家出四张牌：1.三张相同的牌带其他的牌--"三带一"2.四张相同的牌--"炸"3.两鬼带随意两张牌
玩家出五张牌："顺子"--1."A"
"J" "Q" "K"2.不能有鬼跟"2",五张连着的牌
玩家出六张牌：1."顺子"2."三连对"3."飞机"4."四带二"
玩家出七张牌：1."顺子"
玩家出八张牌：1."顺子"2."四连对"3."飞机带二"
玩家出九张牌：1."顺子"
玩家出十张牌：1."顺子"2."五连对"
玩家出十一张牌：1."顺子"
玩家出十二张牌：1."顺子"2."六连对"
玩家出十三张牌：1.违反游戏规则
玩家出十四张牌：1."七连对"
玩家出十五张牌：1.不符合游戏规则
玩家出十六张牌：1."八连对"
玩家出十七张牌：1.不符合游戏规则
玩家出十八张牌：1."九连对"
玩家出十九张牌：1.不符合游戏规则
玩家出二十张牌：1."十连对"
2.玩家出的牌是否压过其他玩家出的牌需要有一个牌桌存放玩家出的牌，定义一个牌桌
* 牌桌，存放玩家每次出的牌
private List&int[]& paiZHuo = new ArrayList&int[]&();
方便计算，对玩家出的牌进行又小到大排序
// 对玩家出的牌由小到大排序，这里调用之前实现的冒泡排序函数进行排序
handPai = sortBubblingFromMinToMax(handPai);
玩家出一张牌
if (paiZHuo.isEmpty()) {// 牌桌上没有牌
System.out.println("一张 " + handPaiStr);
} else if (lastHandPais.length == 1) {// 牌桌上一张牌
int lastHandPai = lastHandPais[0];
flag = mpareTwoPai(handPai[0], lastHandPai);
if (flag == true) {
System.out.println("一张 " + handPaiStr + " 压住 一张 "
+ lastHandPaisStr);
System.out.println("一张 " + handPaiStr + " 压不住 一张 "
+ lastHandPaisStr);
} else {// 牌桌上大于一张牌
System.out.println("一张 " + handPaiStr + " 压不住 "
+ lastHandPaisStr);
判断两张牌的大小的函数
* 判断两张牌的大小
* @param onePai
玩家出的牌
* @param otherPai
牌桌上的牌
* @return true:玩家出的牌压住牌桌上的牌 false:牌桌上的牌压不住牌桌上的牌
public static boolean commpareTwoPai(int onePai, int otherPai) {
boolean flag =
if (otherPai / 10 & 2) {// 是3 ~ 13的牌
if (onePai / 10 & otherPai || onePai / 10 &= 2) {
} else if (otherPai == 0 && onePai == 1) {// "大鬼"压"小鬼"
} else if (otherPai / 10 == 1 && (onePai / 10 == 0 || onePai / 10 == 2)) {// 大小鬼及2压A
} else if (otherPai / 10 == 2 && onePai / 10 == 0) {// 大小鬼压2
玩家出两张牌先判断两张牌是否符合出牌规则再判断是否压过牌桌上其他玩家出的牌
判断牌中有几张相同牌的函数这个函数也可以判断牌中有两张相同的牌及有三张相同的牌及四张相同的牌
* 判断有序数组中存在相同元素个数为x个
* 第一个元素与第二个元素对比
* 元素相等，统计相等元素的变量加1
* 元素不相等，统计相等元素的变量归0，重新统计相等元素个数
* 第二个元素与第三个元素对比
* @param paramInts
有序数组(由大到小，或者由小到大)
* @param index
* @param num
private boolean isXEqual(int[] paramInts, int index, int num, int x) {
if (num == x) {// 有x个相同元素
} else if (index == paramInts.length - 1) {// 对比到最后一个元素，没有可比较的
// 说明没有四个相同的元素
} else if (paramInts[index] / 10 == paramInts[index + 1] / 10) {// 相邻元素相等
// 计算相等元素个数变量num加1，继续对比之后的相邻元素
// ++num先计算赋值给num然后再用
return isXEqual(paramInts, index + 1, ++num, x);
// 相邻元素不相等，计算相等元素个数变量设置为0，继续对比之后的相邻元素
return isXEqual(paramInts, index + 1, 1, x);
再判断两张牌是否压过牌桌上其他玩家出的牌
if (isXEqual(handPai, 0, 1, 2)) {// 一对,例如：AA
if (paiZHuo.isEmpty()) {// 牌桌上没有牌
System.out.println("一对 " + handPaiStr);
} else if (handPai[0] / 10 == 0 && handPai[1] / 10 == 0) {// 玩家出的"大小鬼"
System.out.println("俩鬼 压住 " + lastHandPaisStr);
} else if (lastHandPais.length == 2) {// 牌桌上两张牌
int lastHandPai = lastHandPais[0];
//判断队的大小，其实判断两张牌的大小一样，调用判断两张牌大小的函数比较
flag = mpareTwoPai(handPai[0], lastHandPai);
if (flag == true) {
System.out.println("\"一对\"
" + handPaiStr + " 压住 "
+ lastHandPaisStr);
System.out.println("\"一对\" " + handPaiStr
+ " 压不住 \"一对\"" + lastHandPaisStr);
} else {// 牌桌上不是两张牌
System.out.println("\"一对\"
" + handPaiStr + " 压不住 "
+ lastHandPaisStr);
} else {// 玩家出的两张牌:不符合规则
System.out.println("两张牌不是一对，不符合游戏规则");
玩家出三张牌
if (isXEqual(handPai, 0, 1, 3)) {// 例如：AAA
if (paiZHuo.isEmpty()) {// 牌桌上没有牌
System.out.println("\"三不带\"
" + handPaiStr);
} else if (lastHandPais.length == 3) {// 牌桌上是三张牌
int lastHandPai = lastHandPais[0];
//判断"三不带"的大小，其实判断两张牌的大小一样，调用判断两张牌大小的函数比较
flag = mpareTwoPai(handPai[0], lastHandPai);
if (flag == true) {
System.out.println("\"三不带\"
" + handPaiStr
+ " 压住 \"三不带\"" + lastHandPaisStr);
System.out.println("\"三不带\"
" + handPaiStr
+ " 压不住 \"三不带\"" + lastHandPaisStr);
} else {// 牌桌上不是三张牌
System.out.println("\"三不带\"
" + handPaiStr + " 压不住 "
+ lastHandPaisStr);
} else {// 玩家出的三张牌:不符合规则
System.out.println("三张牌 " + handPaiStr + " 不是\"三不带\"，不符合游戏规则");
玩家出四张牌
if (isXEqual(handPai, 0, 1, 4)) {// 四张牌:"一炸"
if (paiZHuo.isEmpty()) {// 牌桌为空
System.out.println("\"一炸\" " + handPaiStr);
} else if (lastHandPais.length == 2
&& lastHandPais[0] / 10 == 0
&& lastHandPais[1] / 10 == 0) {// 桌牌上是"俩鬼"
System.out.println("\"一炸\"
" + handPaiStr + " 压不住 \"两鬼\" "
+ lastHandPaisStr);
} else if (!isXEqual(lastHandPais, 0, 1, 4)) {// 牌桌上不是"一炸"
System.out.println("\"一炸\" " + handPaiStr + " 压住 "
+ lastHandPaisStr);
} else if (mpareTwoPai(handPai[0],
lastHandPais[0])) {// 玩家的炸大于牌桌上的"一炸"
System.out.println("\"一炸\" " + handPaiStr + " 压住 \"一炸\" "
+ lastHandPaisStr);
System.out.println("\"一炸\" " + handPaiStr + " 压不住 \"一炸\" "
+ lastHandPaisStr);
} else if (isXEqual(handPai, 0, 1, 3)) {// 四张牌："三带一"
if (paiZHuo.isEmpty()) {// 牌桌为空
System.out.println("\"三带一\"" + handPaiStr);
} else if (!isXEqual(lastHandPais, 0, 1, 3)) {// 牌桌上不是"三带一"
System.out.println("\"三带一\"
" + handPaiStr + " 压不住 "
+ lastHandPaisStr);
} else if (mpareTwoPai(
GameRuleUtil.getEqualInt(handPai),
GameRuleUtil.getEqualInt(lastHandPais))) {// 玩家出的"三带一"压住牌桌上的"三带一"
System.out.println("\"三带一\"
" + handPaiStr
+ " 压住 \"三带一\" " + lastHandPaisStr);
System.out.println("\"三带一\"
" + handPaiStr
+ " 压不住 \"三带一\" " + lastHandPaisStr);
} else if (handPai[0] == 0 && handPai[1] == 1) {// 四张牌:两鬼带两张
if (paiZHuo.isEmpty()) {
System.out.println("\"两鬼带二\" " + handPaiStr);
System.out.println("\"两鬼带二\" " + handPaiStr
if (isXEqual(handPai, 0, 1, 4)) {// 四张牌:"一炸"
if (paiZHuo.isEmpty()) {// 牌桌为空
System.out.println("\"一炸\" " + handPaiStr);
} else if (lastHandPais.length == 2
&& lastHandPais[0] / 10 == 0
&& lastHandPais[1] / 10 == 0) {// 桌牌上是"俩鬼"
System.out.println("\"一炸\"
" + handPaiStr + " 压不住 \"两鬼\" "
+ lastHandPaisStr);
} else if (!isXEqual(lastHandPais, 0, 1, 4)) {// 牌桌上不是"一炸"
System.out.println("\"一炸\" " + handPaiStr + " 压住 "
+ lastHandPaisStr);
} else if (mpareTwoPai(handPai[0],
lastHandPais[0])) {// 玩家的炸大于牌桌上的"一炸"
System.out.println("\"一炸\" " + handPaiStr + " 压住 \"一炸\" "
+ lastHandPaisStr);
System.out.println("\"一炸\" " + handPaiStr + " 压不住 \"一炸\" "
+ lastHandPaisStr);
} else if (isXEqual(handPai, 0, 1, 3)) {// 四张牌："三带一"
if (paiZHuo.isEmpty()) {// 牌桌为空
System.out.println("\"三带一\"" + handPaiStr);
} else if (!isXEqual(lastHandPais, 0, 1, 3)) {// 牌桌上不是"三带一"
System.out.println("\"三带一\"
" + handPaiStr + " 压不住 "
+ lastHandPaisStr);
} else if (mpareTwoPai(
GameRuleUtil.getEqualInt(handPai),
GameRuleUtil.getEqualInt(lastHandPais))) {// 玩家出的"三带一"压住牌桌上的"三带一"
System.out.println("\"三带一\"
" + handPaiStr
+ " 压住 \"三带一\" " + lastHandPaisStr);
System.out.println("\"三带一\"
" + handPaiStr
+ " 压不住 \"三带一\" " + lastHandPaisStr);
} else if (handPai[0] == 0 && handPai[1] == 1) {// 四张牌:两鬼带两张
if (paiZHuo.isEmpty()) {
System.out.println("\"两鬼带二\" " + handPaiStr);
System.out.println("\"两鬼带二\" " + handPaiStr + " 压不住 "
+ lastHandPaisStr);
} else {// 玩家出的四张牌:不符合规则
System.out.println("四张牌 " + handPaiStr
+ " 不是\"三带一\" or \"一炸\" or
\" 两鬼带二\"，不符合游戏规则");
} + " 压不住 "
+ lastHandPaisStr);
} else {// 玩家出的四张牌:不符合规则
System.out.println("四张牌 " + handPaiStr
+ " 不是\"三带一\" or \"一炸\" or
\" 两鬼带二\"，不符合游戏规则");
玩家出五张牌
// 五张牌按照规则，只能是顺子
if (isShunZi(handPai)) {// 五张牌：顺子
if (paiZHuo.isEmpty()) {//
System.out.println("\"顺子\" " + handPaiStr);
} else if (isShunZi(lastHandPais)) {// 牌桌上的不是顺子
System.out.println("\"顺子\" " + handPaiStr + " 压不住 "
+ lastHandPaisStr);
} else if (GameRuleUtil
.commpareTwoShunZi(handPai, lastHandPais)) {// 判断玩家出的顺子是否压过牌桌上的顺子
System.out.println("\"顺子\" " + handPaiStr + " 压住 "
+ "\"顺子\" " + lastHandPaisStr);
System.out.println("\"顺子\" " + handPaiStr + " 压不住 "
+ "\"顺子\" " + lastHandPaisStr);
} else {// 五张牌：不符合规则
System.out.println("五张牌 " + handPaiStr + " 不是\"顺子\"，不符合游戏规则");
玩家出六张牌
// 玩家出6张牌
if (isShunZi(handPai)) {// 六张牌：顺子
if (paiZHuo.isEmpty()) {//
System.out.println("\"顺子\" " + handPaiStr);
} else if (isShunZi(lastHandPais)) {// 牌桌上的不是顺子
System.out.println("\"顺子\" " + handPaiStr + " 压不住 "
+ lastHandPaisStr);
} else if (GameRuleUtil
.commpareTwoShunZi(handPai, lastHandPais)) {// 玩家出的顺子压过牌桌上的顺子
System.out.println("\"顺子\" " + handPaiStr + " 压住 "
+ "\"顺子\" " + lastHandPaisStr);
System.out.println("\"顺子\" " + handPaiStr + " 压不住 "
+ "\"顺子\" " + lastHandPaisStr);
} else if (isFeiji(handPai)) {// 六张牌：飞机
if (paiZHuo.isEmpty()) {//
System.out.println("\"飞机\" " + handPaiStr);
} else if (isFeiji(lastHandPais)) {// 牌桌上的不是飞机
System.out.println("\"飞机\" " + handPaiStr + " 压不住 "
+ lastHandPaisStr);
} else if (mpareTwoFeiJi(handPai, lastHandPais)) {// 玩家出的飞机压过牌桌上的飞机
System.out.println("\"飞机\" " + handPaiStr + " 压住 \"飞机\""
+ lastHandPaisStr);
System.out.println("\"飞机\" " + handPaiStr + " 压不住 \"飞机\""
+ lastHandPaisStr);
} else if (isLiandui(handPai)) {// 六张牌：三连对
if (paiZHuo.isEmpty()) {//
System.out.println("\"三连对\" " + handPaiStr);
} else if (isLiandui(lastHandPais)) {// 牌桌上的不是连对
System.out.println("\"三连对\" " + handPaiStr + " 压不住 "
+ handPaiStr);
} else if (mpareTwoLianDui(handPai,
lastHandPais)) {// 玩家出的连对压过牌桌上的连对
System.out.println("\"三连对\" " + handPaiStr
\"三连对\" " + handPaiStr);
System.out.println("\"三连对\" " + handPaiStr
+ " 压不住
\"三连对\" " + handPaiStr);
} else if (isXEqual(handPai, 0, 1, 4)) {// 六张牌：四带二
if (paiZHuo.isEmpty()) {//
System.out.println("\"四带二\" " + handPaiStr);
} else if (!isXEqual(lastHandPais, 0, 1, 4)) {// 牌桌上不是四带二
System.out.println("\"四带二\" " + handPaiStr + " 压不住 "
+ lastHandPaisStr);
} else if (mpareFourPaisBandTwoPai(handPai,
lastHandPais)) {// 玩家出的四带二压过桌牌上的四带二
System.out.println("\"四带二\" " + handPaiStr + " 压住 \"四带二\" "
+ lastHandPaisStr);
System.out.println("\"四带二\" " + handPaiStr
+ " 压不住 \"四带二\" " + lastHandPaisStr);
} else {// 玩家出的六张牌：不符合规则
System.out.println("六张牌 " + handPaiStr
+ " 不是\"顺子\" or \"四带二\" or \"三连对\" or \"飞机\"，不符合游戏规则");
玩家出七张牌
if (isShunZi(handPai)) {// 七张牌：顺子
if (paiZHuo.isEmpty()) {//
System.out.println("\"顺子\" " + handPaiStr);
} else if (isShunZi(lastHandPais)) {// 牌桌上的不是顺子
System.out.println("\"顺子\" " + handPaiStr + " 压住 "
+ lastHandPaisStr);
} else if (GameRuleUtil
.commpareTwoShunZi(handPai, lastHandPais)) {// 判断玩家出的顺子是否压过牌桌上的顺子
System.out.println("\"顺子\" " + handPaiStr + " 压住 \"顺子\" "
+ lastHandPaisStr);
System.out.println("\"顺子\" " + handPaiStr + " 压不住 \"顺子\" "
+ lastHandPaisStr);
} else {// 七张牌：不符合规则
System.out.println("七张牌 " + handPaiStr + " 不是\"顺子\"，不符合游戏规则");
case 8:// 玩家出8张牌
if (isShunZi(handPai)) {// 八张牌:顺子
if (paiZHuo.isEmpty()) {//
System.out.println("\"顺子\" " + handPaiStr);
} else if (isShunZi(lastHandPais)) {// 牌桌上的不是顺子
System.out.println("\"顺子\" " + handPaiStr + " 压不住
+ lastHandPaisStr);
} else if (GameRuleUtil
.commpareTwoShunZi(handPai, lastHandPais)) {// 玩家出的顺子是否压过牌桌上的顺子
System.out.println("\"顺子\" " + handPaiStr + " 压住 \"顺子\" "
+ lastHandPaisStr);
System.out.println("\"顺子\" " + handPaiStr + " 压不住 \"顺子\" "
+ lastHandPaisStr);
} else if (isFeijiBandTwo(handPai)) {// 八张牌：飞机带两张
if (paiZHuo.isEmpty()) {//
System.out.println("\"飞机带二\" " + handPaiStr);
} else if (!isFeijiBandTwo(lastHandPais)) {// 牌桌上不是飞机带两张
System.out.println("\"飞机带二\" " + handPaiStr + " 压不住
+ lastHandPaisStr);
} else if (mpareFeiJiBandTwoPai(handPai,
lastHandPais)) {// 玩家出的飞机带两张压过牌桌上的飞机带两张
System.out.println("\"飞机带二\" " + handPaiStr
\"飞机带二\" " + lastHandPaisStr);
System.out.println("\"飞机带二\" " + handPaiStr
+ " 压不住
\"飞机带二\" " + lastHandPaisStr);
} else if (isLiandui(handPai)) {// 八张牌：四连对
if (paiZHuo.isEmpty()) {
System.out.println("\"四连对\" " + handPaiStr);
} else if (isLiandui(lastHandPais)) {// 牌桌上的不是连对
System.out.println("\"四连对\" " + handPaiStr + " 压不住
+ lastHandPaisStr);
} else if (mpareTwoLianDui(handPai,
lastHandPais)) {// 玩家出的连对压过牌桌上的连对
System.out.println("\"四连对\" " + handPaiStr
\"四连对\" " + lastHandPaisStr);
System.out.println("\"四连对\" " + handPaiStr
+ " 压不住
\"四连对\" " + lastHandPaisStr);
} else {// 玩家出的八张牌：不符合规则
System.out.println("八张牌 " + handPaiStr
+ " 不是\"顺子\" or \"四连对\" or \"飞机带二\" or \"\"，不符合游戏规则");
case 9:// 玩家出9张牌
if (isShunZi(handPai)) {// 九张牌：顺子
if (paiZHuo.isEmpty()) {//
System.out.println("\"顺子\" " + handPaiStr);
} else if (isShunZi(lastHandPais)) {// 牌桌上的不是顺子
System.out.println("\"顺子\" " + handPaiStr + " 压不住 "
+ lastHandPaisStr);
} else if (GameRuleUtil
.commpareTwoShunZi(handPai, lastHandPais)) {// 判断玩家出的顺子是否压过牌桌上的顺子
System.out.println("\"顺子\" " + handPaiStr + " 压住 \"顺子\" "
+ lastHandPaisStr);
System.out.println("\"顺子\" " + handPaiStr + " 压不住 \"顺子\" "
+ lastHandPaisStr);
} else {// 玩家出的九张牌：不符合规则
System.out.println("九张牌 " + handPaiStr + " 不是\"顺子\"，不符合游戏规则");
case 10:// 玩家出10张牌
if (isShunZi(handPai)) {// 十张牌：顺子
if (paiZHuo.isEmpty()) {//
System.out.println("\"顺子\" " + handPaiStr);
} else if (isShunZi(lastHandPais)) {// 牌桌上的不是顺子
System.out.println("\"顺子\" " + handPaiStr + " 压不住 "
+ lastHandPaisStr);
} else if (GameRuleUtil
.commpareTwoShunZi(handPai, lastHandPais)) {// 判断玩家出的顺子是否压过牌桌上的顺子
System.out.println("\"顺子\" " + handPaiStr + " 压住 \"顺子\" "
+ lastHandPaisStr);
System.out.println("\"顺子\" " + handPaiStr + " 压不住 \"顺子\" "
+ lastHandPaisStr);
} else if (isLiandui(handPai)) {// 十张牌： 五连对
if (paiZHuo.isEmpty()) {//
System.out.println("\"五连对\" " + handPaiStr);
} else if (isLiandui(lastHandPais)) {// 牌桌上的不是连对
System.out.println("\"五连对\" " + handPaiStr + " 压不住 "
+ handPaiStr);
} else if (mpareTwoLianDui(handPai,
lastHandPais)) {// 玩家出的连对压过牌桌上的连对
System.out.println("\"五连对\" " + handPaiStr
+ " 压住 \"五连对\"
" + handPaiStr);
System.out.println("\"五连对\" " + handPaiStr
+ " 压不住 \"五连对\"
" + handPaiStr);
} else {// 玩家出的十张牌：不符合规则
System.out.println("十张牌 " + handPaiStr
+ " 不是\"顺子\" or
\"五连对\" ，不符合游戏规则");
case 11:// 玩家出11张牌
if (isShunZi(handPai)) {// 十一张牌：顺子
if (paiZHuo.isEmpty()) {//
System.out.println("\"顺子\" " + handPaiStr);
} else if (isShunZi(lastHandPais)) {// 牌桌上的不是顺子
System.out.println("\"顺子\" " + handPaiStr + " 压住 "
+ lastHandPaisStr);
} else if (GameRuleUtil
.commpareTwoShunZi(handPai, lastHandPais)) {// 判断玩家出的顺子是否压过牌桌上的顺子
System.out.println("\"顺子\" " + handPaiStr + " 压住 \"顺子\" "
+ lastHandPaisStr);
System.out.println("\"顺子\" " + handPaiStr + " 压不住 \"顺子\" "
+ lastHandPaisStr);
} else {// 玩家出的十一张牌：不符合规则
System.out.println("十一张牌 " + handPaiStr + " 不是\"顺子\"，不符合游戏规则");
case 12:// 玩家出12张牌
if (isShunZi(handPai)) {// 十二张牌：顺子
if (paiZHuo.isEmpty()) {//
System.out.println("\"顺子\" " + handPaiStr);
} else if (isShunZi(lastHandPais)) {// 牌桌上的不是顺子
System.out.println("\"顺子\" " + handPaiStr + " 压不住
+ lastHandPaisStr);
} else if (GameRuleUtil
.commpareTwoShunZi(handPai, lastHandPais)) {// 判断玩家出的顺子是否压过牌桌上的顺子
System.out.println("\"顺子\" " + handPaiStr + " 压住 \"顺子\" "
+ lastHandPaisStr);
System.out.println("\"顺子\" " + handPaiStr + " 压不住 \"顺子\" "
+ lastHandPaisStr);
} else if (isLiandui(handPai)) {// 十二张牌： 六连对
if (paiZHuo.isEmpty()) {//
System.out.println("\"六连对\" " + handPaiStr
+ " 压住 \"六连对\"
" + handPaiStr);
} else if (isLiandui(lastHandPais)) {// 牌桌上的不是连对
System.out.println("\"六连对\" " + handPaiStr + " 压不住
+ handPaiStr);
} else if (mpareTwoLianDui(handPai,
lastHandPais)) {// 玩家出的连对压过牌桌上的连对
System.out.println("\"六连对\" " + handPaiStr
+ " 压住 \"六连对\"
" + handPaiStr);
System.out.println("\"六连对\" " + handPaiStr
+ " 压不住 \"六连对\"
" + handPaiStr);
} else {// 玩家出的十二张牌：不符合规则
System.out.println("十二张牌 " + handPaiStr
+ " 不是\"顺子\" or \"六连对\"，不符合游戏规则");
case 13:// 玩家出13张牌
System.out.println("不能出十三张牌 " + handPaiStr + " ，不符合游戏规则");
case 14:// 玩家出14张牌
if (isLiandui(handPai)) {// 十四张牌：七连对
if (paiZHuo.isEmpty()) {//
System.out.println("\"七连对\" " + handPaiStr);
} else if (isLiandui(lastHandPais)) {// 牌桌上的不是连对
System.out.println("\"七连对\" " + handPaiStr + " 压不住 "
+ handPaiStr);
} else if (mpareTwoLianDui(handPai,
lastHandPais)) {// 玩家出的连对压过牌桌上的连对
System.out.println("\"七连对\" " + handPaiStr
+ " 压住 \"七连对\"
" + handPaiStr);
System.out.println("\"七连对\" " + handPaiStr
+ " 压不住 \"七连对\"
" + handPaiStr);
} else {// 玩家出的十四张牌：不符合规则
System.out.println("十四张牌 " + handPaiStr + " 不是\"七连对\"，不符合游戏规则");
case 15:// 玩家出15张牌
System.out.println("不能出十五张牌 " + handPaiStr + " ，不符合游戏规则");
case 16:// 玩家出16张牌
if (isLiandui(handPai)) {// 十六张牌：八连对
if (paiZHuo.isEmpty()) {//
System.out.println("\"八连对\" " + handPaiStr);
} else if (isLiandui(lastHandPais)) {// 牌桌上的不是连对
System.out.println("\"八连对\" " + handPaiStr + " 压不住 "
+ handPaiStr);
} else if (mpareTwoLianDui(handPai,
lastHandPais)) {// 玩家出的连对压过牌桌上的连对
System.out.println("\"八连对\" " + handPaiStr
+ " 压住 \"八连对\"
" + handPaiStr);
System.out.println("\"八连对\" " + handPaiStr
+ " 压不住 \"八连对\"
" + handPaiStr);
} else {// 玩家出的十六张牌：不符合规则
System.out.println("十六张牌 " + handPaiStr + " 不是\"八连对\"，不符合游戏规则");
case 17:// 玩家出17张牌
System.out.println("不能出十七张牌 " + handPaiStr + " ，不符合游戏规则");
case 18:// 玩家出18张牌
if (isLiandui(handPai)) {// 十八张牌：九连对
if (paiZHuo.isEmpty()) {//
System.out.println("\"九连对\" " + handPaiStr);
} else if (isLiandui(lastHandPais)) {// 牌桌上的不是连对
System.out.println("\"九连对\" " + handPaiStr + " 压不住 "
+ handPaiStr);
} else if (mpareTwoLianDui(handPai,
lastHandPais)) {// 玩家出的连对压过牌桌上的连对
System.out.println("\"九连对\" " + handPaiStr
+ " 压住 \"九连对\"
" + handPaiStr);
System.out.println("\"九连对\" " + handPaiStr
+ " 压不住 \"九连对\" " + handPaiStr);
} else {// 玩家出的十八张牌：不符合规则
System.out.println("十八张牌 " + handPaiStr + " 不是\"九连对\"，不符合游戏规则");
case 19:// 玩家出19张牌
System.out.println("不能出十九张牌 " + handPaiStr + " ，不符合游戏规则");
case 20:// 玩家出20张牌
if (isLiandui(handPai)) {// 20张牌：十连对
if (paiZHuo.isEmpty()) {//
System.out.println("\"十连对\" " + handPaiStr);
} else if (isLiandui(lastHandPais)) {// 牌桌上的不是连对
} else if (mpareTwoLianDui(handPai,
lastHandPais)) {// 玩家出的连对压过牌桌上的连对
} else {// 玩家出的二十张牌：不符合规则
System.out.println("二十张牌 " + handPaiStr + " 不是\"十连对\"，不符合游戏规则");
游戏玩家出牌
System.out.println("玩家 --- " + wanjiaA.name + " (
"+ wanjiaA.status + " ) --- 开始出牌" + "\n");
wanjiaA.operationStatus = "出牌";
wanjiaA.chupai = new int[] { 73, 74
System.out.println(" 出 " + wanjiaA.chupai.length + " 张牌 " + "\n");
Guize localGuize = localXipai.new Guize();
System.out.println(localXipai.transitionToList(
localXipai.sortBubblingFromMinToMax(wanjiaA.chupai)).toString()