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 int id;
    /**
     * 玩家名称
     */
    public String name;
    /**
     * 玩家身份
     * 
     * "农民" / "地主"
     */
    public String status;
    /**
     * 玩家手里的牌
     */
    public List<String> pais;

    public int[] paiInts;
    /**
     * 玩家在游戏中的位置
     * 
     * "1" / "2" / "3"
     */
    public String position;
    /**
     * 玩家要出的牌
     */
    public int[] chuPai;
    /**
     * 玩家在游行中的状态
     * 
     * "出牌" / "等待" / "胜利" / "失败"
     */
    public String operationStatus;

}

实现洗牌函数

 /**
 * 洗牌
 * 
 * @param pukepai
 *            初始化的扑克牌对象
 * @return 返回洗好后的扑克牌对象
 */
private String[] xipai(String[] pukepai) {
    //定义一副空的扑克牌
    String[] xipaiEnd = new String[54];
    // 把初始化的扑克牌元素插入到新的空的扑克牌中
    for (int i = 1; i < pukepai.length; i++) {
        int index = zeroToFifty_four(xipaiEnd);
        xipaiEnd[index] = pukepai[i];
        System.out.println("第 " + i + " 张牌 " + pukepai[i] + " 位置下标："
                + index);
    }
    return xipaiEnd;
}

寻找元素为空的下标，用到递归算法

/**
 * 寻找元素为空的下标
 * 
 * @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);
    } else {
        return temp;
    }
}

实现发牌函数

/**
 * 给三位玩家发牌的函数
 * 
 * @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);
    return wanjias;
}

测试洗牌发牌函数

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,
            wanjiaC);
    // 分别打印玩家手里的牌
    for (Wanjia wanjia : listWanjias) {
        System.out.println(wanjia.name + "手里的牌：" + wanjia.pais.toString()
                + "\n");
    }
    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");

// 玩家B
wanjiaB.paiInts = localXipai.transitionToInts(wanjiaB.pais);
wanjiaB.pais.clear();
wanjiaB.pais.addAll(localXipai.transitionToList(wanjiaB.paiInts));


// 玩家C
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 (pai.compareTo("红桃A") == 0) {
                ints[i] = 11;
            } else if (pai.compareTo("红桃2") == 0) {
                ints[i] = 21;
            } else if (pai.compareTo("红桃3") == 0) {
                ints[i] = 31;
            } else if (pai.compareTo("红桃4") == 0) {
                ints[i] = 41;
            } else if (pai.compareTo("红桃5") == 0) {
                ints[i] = 51;
            } else if (pai.compareTo("红桃6") == 0) {
                ints[i] = 61;
            } else if (pai.compareTo("红桃7") == 0) {
                ints[i] = 71;
            } else if (pai.compareTo("红桃8") == 0) {
                ints[i] = 81;
            } else if (pai.compareTo("红桃9") == 0) {
                ints[i] = 91;
            } else if (pai.compareTo("红桃10") == 0) {
                ints[i] = 101;
            } else if (pai.compareTo("红桃J") == 0) {
                ints[i] = 111;
            } else if (pai.compareTo("红桃Q") == 0) {
                ints[i] = 121;
            } else if (pai.compareTo("红桃K") == 0) {
                ints[i] = 131;
            } else if (pai.compareTo("方块A") == 0) {
                ints[i] = 12;
            } else if (pai.compareTo("方块2") == 0) {
                ints[i] = 22;
            } else if (pai.compareTo("方块3") == 0) {
                ints[i] = 32;
            } else if (pai.compareTo("方块4") == 0) {
                ints[i] = 42;
            } else if (pai.compareTo("方块5") == 0) {
                ints[i] = 52;
            } else if (pai.compareTo("方块6") == 0) {
                ints[i] = 62;
            } else if (pai.compareTo("方块7") == 0) {
                ints[i] = 72;
            } else if (pai.compareTo("方块8") == 0) {
                ints[i] = 82;
            } else if (pai.compareTo("方块9") == 0) {
                ints[i] = 92;
            } else if (pai.compareTo("方块10") == 0) {
                ints[i] = 102;
            } else if (pai.compareTo("方块J") == 0) {
                ints[i] = 112;
            } else if (pai.compareTo("方块Q") == 0) {
                ints[i] = 122;
            } else if (pai.compareTo("方块K") == 0) {
                ints[i] = 132;
            } else if (pai.compareTo("梅花A") == 0) {
                ints[i] = 13;
            } else if (pai.compareTo("梅花2") == 0) {
                ints[i] = 23;
            } else if (pai.compareTo("梅花3") == 0) {
                ints[i] = 33;
            } else if (pai.compareTo("梅花4") == 0) {
                ints[i] = 43;
            } else if (pai.compareTo("梅花5") == 0) {
                ints[i] = 53;
            } else if (pai.compareTo("梅花6") == 0) {
                ints[i] = 63;
            } else if (pai.compareTo("梅花7") == 0) {
                ints[i] = 73;
            } else if (pai.compareTo("梅花8") == 0) {
                ints[i] = 83;
            } else if (pai.compareTo("梅花9") == 0) {
                ints[i] = 93;
            } else if (pai.compareTo("梅花10") == 0) {
                ints[i] = 103;
            } else if (pai.compareTo("梅花J") == 0) {
                ints[i] = 113;
            } else if (pai.compareTo("梅花Q") == 0) {
                ints[i] = 123;
            } else if (pai.compareTo("梅花K") == 0) {
                ints[i] = 133;
            } else if (pai.compareTo("黑桃A") == 0) {
                ints[i] = 14;
            } else if (pai.compareTo("黑桃2") == 0) {
                ints[i] = 24;
            } else if (pai.compareTo("黑桃3") == 0) {
                ints[i] = 34;
            } else if (pai.compareTo("黑桃4") == 0) {
                ints[i] = 44;
            } else if (pai.compareTo("黑桃5") == 0) {
                ints[i] = 54;
            } else if (pai.compareTo("黑桃6") == 0) {
                ints[i] = 64;
            } else if (pai.compareTo("黑桃7") == 0) {
                ints[i] = 74;
            } else if (pai.compareTo("黑桃8") == 0) {
                ints[i] = 84;
            } else if (pai.compareTo("黑桃9") == 0) {
                ints[i] = 94;
            } else if (pai.compareTo("黑桃10") == 0) {
                ints[i] = 104;
            } else if (pai.compareTo("黑桃J") == 0) {
                ints[i] = 114;
            } else if (pai.compareTo("黑桃Q") == 0) {
                ints[i] = 124;
            } else if (pai.compareTo("黑桃K") == 0) {
                ints[i] = 134;
            } else if (pai.compareTo("大鬼") == 0) {
                ints[i] = 1;
            } else if (pai.compareTo("小鬼") == 0) {
                ints[i] = 0;
            }
        }
        return sortBubblingFromMinToMax(ints);
    }

整型数组由小到大排序函数，用到冒泡排序

/**
 * 冒泡排序， 由小到大
 * 
 * @param paramInts
 * @return
 */
public int[] sortBubblingFromMinToMax(int[] paramInts) {
    return sortBubblingFromMinToMax(paramInts, 0, paramInts.length - 1);
}
/**
 * 递归方式实现冒泡排序
 * @param paramInts 原始数组
 * @param index 数组下标
 * @param moreIndex 该下标是数组中剩余元素中的最大值
 * @return
 */
public int[] sortBubblingFromMinToMax(int[] paramInts, int index,
    int moreIndex) {
        if (moreIndex == 0) {
        return paramInts;
    } 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] = temp;
        // 比较一下对元素
        return sortBubblingFromMinToMax(paramInts, index + 1, moreIndex);
    } else {// 后一元素不于前一元素
        // 比较下一对元素
        return sortBubblingFromMinToMax(paramInts, index + 1, moreIndex);

    }
}

整型数组表示的扑克牌转化为字符串列表表示的扑克牌函数

    /**
     * 整型数组表示的扑克牌转化为字符串数组表示的扑克牌
     * 
     * 展示需要
     * 
     * @param paramInts
     * @return
     */
    public static List<String> transitionToList(int[] paramInts) {
        List<String> listStr = new ArrayList<String>();
        for (int value : paramInts) {
            switch (value) {
            case 0:
                listStr.add("小鬼");
                break;
            case 1:
                listStr.add("大鬼");
                break;
            case 11:
                listStr.add("红桃A");
                break;
            case 12:
                listStr.add("方块A");
                break;
            case 13:
                listStr.add("梅花A");
                break;
            case 14:
                listStr.add("黑桃A");
                break;
            case 21:
                listStr.add("红桃2");
                break;
            case 22:
                listStr.add("方块2");
                break;
            case 23:
                listStr.add("梅花2");
                break;
            case 24:
                listStr.add("黑桃2");
                break;
            case 31:
                listStr.add("红桃3");
                break;
            case 32:
                listStr.add("方块3");
                break;
            case 33:
                listStr.add("梅花3");
                break;
            case 34:
                listStr.add("黑桃3");
                break;
            case 41:
                listStr.add("红桃4");
                break;
            case 42:
                listStr.add("方块4");
                break;
            case 43:
                listStr.add("梅花4");
                break;
            case 44:
                listStr.add("黑桃4");
                break;
            case 51:
                listStr.add("红桃5");
                break;
            case 52:
                listStr.add("方块5");
                break;
            case 53:
                listStr.add("梅花5");
                break;
            case 54:
                listStr.add("黑桃5");
                break;
            case 61:
                listStr.add("红桃6");
                break;
            case 62:
                listStr.add("方块6");
                break;
            case 63:
                listStr.add("梅花6");
                break;
            case 64:
                listStr.add("黑桃6");
                break;
            case 71:
                listStr.add("红桃7");
                break;
            case 72:
                listStr.add("方块7");
                break;
            case 73:
                listStr.add("梅花7");
                break;
            case 74:
                listStr.add("黑桃7");
                break;
            case 81:
                listStr.add("红桃8");
                break;
            case 82:
                listStr.add("方块8");
                break;
            case 83:
                listStr.add("梅花8");
                break;
            case 84:
                listStr.add("黑桃8");
                break;
            case 91:
                listStr.add("红桃9");
                break;
            case 92:
                listStr.add("方块9");
                break;
            case 93:
                listStr.add("梅花9");
                break;
            case 94:
                listStr.add("黑桃9");
                break;
            case 101:
                listStr.add("红桃10");
                break;
            case 102:
                listStr.add("方块10");
                break;
            case 103:
                listStr.add("梅花10");
                break;
            case 104:
                listStr.add("黑桃10");
                break;
            case 111:
                listStr.add("红桃J");
                break;
            case 112:
                listStr.add("方块J");
                break;
            case 113:
                listStr.add("梅花J");
                break;
            case 114:
                listStr.add("黑桃J");
                break;
            case 121:
                listStr.add("红桃Q");
                break;
            case 122:
                listStr.add("方块Q");
                break;
            case 123:
                listStr.add("梅花Q");
                break;
            case 124:
                listStr.add("黑桃Q");
                break;
            case 131:
                listStr.add("红桃K");
                break;
            case 132:
                listStr.add("方块K");
                break;
            case 133:
                listStr.add("梅花K");
                break;
            case 134:
                listStr.add("黑桃K");
                break;
            default:
                listStr.add("程序错误");
                break;
            }
        }
        return listStr;
    }

游戏规则

规则类，符合如下两个原则：
1.玩家出的牌拍是否符合出牌的规则
2.玩家出的牌是否压过其他玩家出的牌

1.玩家出的牌是否符合出牌的规则
玩家出一张牌：随意一涨牌
玩家出二张牌：两张相同的牌--"一对"
玩家出三张牌：三张相同的牌--"三不带"
玩家出四张牌：
1.三张相同的牌带其他的牌--"三带一"
2.四张相同的牌--"炸"
3.两鬼带随意两张牌

玩家出五张牌："顺子"--
1."A" "10" "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);
    flag = true;
} else if (lastHandPais.length == 1) {// 牌桌上一张牌
    int lastHandPai = lastHandPais[0];
    flag = GameRuleUtil.commpareTwoPai(handPai[0], lastHandPai);
    if (flag == true) {
        System.out.println("一张 " + handPaiStr + " 压住 一张 "
                    + lastHandPaisStr);
    } else {
        System.out.println("一张 " + handPaiStr + " 压不住 一张 "
                    + lastHandPaisStr);
    }
} else {// 牌桌上大于一张牌
    System.out.println("一张 " + handPaiStr + " 压不住 "
        + lastHandPaisStr);
    flag = false;
}

判断两张牌的大小的函数

/**
 * 判断两张牌的大小
 * 
 * @param onePai
 *            玩家出的牌
 * @param otherPai
 *            牌桌上的牌
 * @return true:玩家出的牌压住牌桌上的牌 false:牌桌上的牌压不住牌桌上的牌
 */
public static boolean commpareTwoPai(int onePai, int otherPai) {
    boolean flag = false;
    if (otherPai / 10 > 2) {// 是3 ~ 13的牌
        if (onePai / 10 > otherPai || onePai / 10 <= 2) {
            flag = true;
        } else {
            flag = false;
        }
    } else if (otherPai == 0 && onePai == 1) {// "大鬼"压"小鬼"
        flag = true;
    } else if (otherPai / 10 == 1 && (onePai / 10 == 0 || onePai / 10 == 2)) {// 大小鬼及2压A
        flag = true;
    } else if (otherPai / 10 == 2 && onePai / 10 == 0) {// 大小鬼压2
        flag = true;
    } else {
        flag = false;
    }
    return flag;
}

玩家出两张牌
先判断两张牌是否符合出牌规则
再判断是否压过牌桌上其他玩家出的牌

判断牌中有几张相同牌的函数
这个函数也可以判断牌中有两张相同的牌及有三张相同的牌及四张相同的牌


/**
 * 判断有序数组中存在相同元素个数为x个
 * 
 * 第一个元素与第二个元素对比
 * 
 * 元素相等，统计相等元素的变量加1
 * 
 * 元素不相等，统计相等元素的变量归0，重新统计相等元素个数
 * 
 * 第二个元素与第三个元素对比
 * 
 * @param paramInts
 *            有序数组(由大到小，或者由小到大)
 * @param index
 * @param num
 * @return
 */
private boolean isXEqual(int[] paramInts, int index, int num, int x) {
    if (num == x) {// 有x个相同元素
        return true;
    } else if (index == paramInts.length - 1) {// 对比到最后一个元素，没有可比较的
        // 说明没有四个相同的元素
        return false;
    } else if (paramInts[index] / 10 == paramInts[index + 1] / 10) {// 相邻元素相等
        // 计算相等元素个数变量num加1，继续对比之后的相邻元素
        // ++num先计算赋值给num然后再用
        return isXEqual(paramInts, index + 1, ++num, x);
    } else {
        // 相邻元素不相等，计算相等元素个数变量设置为0，继续对比之后的相邻元素
        return isXEqual(paramInts, index + 1, 1, x);
    }
}

再判断两张牌是否压过牌桌上其他玩家出的牌

if (isXEqual(handPai, 0, 1, 2)) {// 一对,例如：AA
    if (paiZHuo.isEmpty()) {// 牌桌上没有牌
        System.out.println("一对 " + handPaiStr);
        flag = true;
    } else if (handPai[0] / 10 == 0 && handPai[1] / 10 == 0) {// 玩家出的"大小鬼"
        System.out.println("俩鬼 压住 " + lastHandPaisStr);
        flag = true;
    } else if (lastHandPais.length == 2) {// 牌桌上两张牌
        int lastHandPai = lastHandPais[0];
    //判断队的大小，其实判断两张牌的大小一样，调用判断两张牌大小的函数比较
        flag = GameRuleUtil.commpareTwoPai(handPai[0], lastHandPai);
        if (flag == true) {
            System.out.println("\"一对\"  " + handPaiStr + " 压住 "
                        + lastHandPaisStr);
        } else {
            System.out.println("\"一对\" " + handPaiStr
                + " 压不住 \"一对\"" + lastHandPaisStr);
        }
    } else {// 牌桌上不是两张牌
        System.out.println("\"一对\"  " + handPaiStr + " 压不住 "
                    + lastHandPaisStr);
        flag = false;
    }
} else {// 玩家出的两张牌:不符合规则
    System.out.println("两张牌不是一对，不符合游戏规则");
    flag = false;
}

玩家出三张牌

if (isXEqual(handPai, 0, 1, 3)) {// 例如：AAA
    if (paiZHuo.isEmpty()) {// 牌桌上没有牌
        System.out.println("\"三不带\"  " + handPaiStr);
                    flag = true;
    } else if (lastHandPais.length == 3) {// 牌桌上是三张牌
        int lastHandPai = lastHandPais[0];
 //判断"三不带"的大小，其实判断两张牌的大小一样，调用判断两张牌大小的函数比较
        flag = GameRuleUtil.commpareTwoPai(handPai[0], lastHandPai);
        if (flag == true) {
            System.out.println("\"三不带\"  " + handPaiStr
                    + " 压住 \"三不带\"" + lastHandPaisStr);
        } else {
            System.out.println("\"三不带\"  " + handPaiStr
                    + " 压不住 \"三不带\"" + lastHandPaisStr);
        }
    } else {// 牌桌上不是三张牌
        System.out.println("\"三不带\"  " + handPaiStr + " 压不住 "
                + lastHandPaisStr);
        flag = false;
    }
} else {// 玩家出的三张牌:不符合规则
    System.out.println("三张牌 " + handPaiStr + " 不是\"三不带\"，不符合游戏规则");
        flag = false;
}

玩家出四张牌

            if (isXEqual(handPai, 0, 1, 4)) {// 四张牌:"一炸"
                if (paiZHuo.isEmpty()) {// 牌桌为空
                    System.out.println("\"一炸\" " + handPaiStr);
                    flag = true;

                } 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);
                    flag = true;
                } else if (GameRuleUtil.commpareTwoPai(handPai[0],
                        lastHandPais[0])) {// 玩家的炸大于牌桌上的"一炸"
                    System.out.println("\"一炸\" " + handPaiStr + " 压住 \"一炸\" "
                            + lastHandPaisStr);
                    flag = true;
                } else {
                    System.out.println("\"一炸\" " + handPaiStr + " 压不住 \"一炸\" "
                            + lastHandPaisStr);
                    flag = false;
                }

            } else if (isXEqual(handPai, 0, 1, 3)) {// 四张牌："三带一"
                if (paiZHuo.isEmpty()) {// 牌桌为空
                    System.out.println("\"三带一\"" + handPaiStr);
                    flag = true;

                } else if (!isXEqual(lastHandPais, 0, 1, 3)) {// 牌桌上不是"三带一"
                    System.out.println("\"三带一\"  " + handPaiStr + " 压不住 "
                            + lastHandPaisStr);
                    flag = false;
                } else if (GameRuleUtil.commpareTwoPai(
                        GameRuleUtil.getEqualInt(handPai),
                        GameRuleUtil.getEqualInt(lastHandPais))) {// 玩家出的"三带一"压住牌桌上的"三带一"
                    System.out.println("\"三带一\"  " + handPaiStr
                            + " 压住 \"三带一\" " + lastHandPaisStr);
                    flag = true;
                } else {
                    System.out.println("\"三带一\"  " + handPaiStr
                            + " 压不住 \"三带一\" " + lastHandPaisStr);
                    flag = false;
                }
            } else if (handPai[0] == 0 && handPai[1] == 1) {// 四张牌:两鬼带两张
                if (paiZHuo.isEmpty()) {
                    System.out.println("\"两鬼带二\" " + handPaiStr);
                    flag = true;
                } else {
                    System.out.println("\"两鬼带二\" " + handPaiStr         if (isXEqual(handPai, 0, 1, 4)) {// 四张牌:"一炸"
                if (paiZHuo.isEmpty()) {// 牌桌为空
                    System.out.println("\"一炸\" " + handPaiStr);
                    flag = true;

                } 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);
                    flag = true;
                } else if (GameRuleUtil.commpareTwoPai(handPai[0],
                        lastHandPais[0])) {// 玩家的炸大于牌桌上的"一炸"
                    System.out.println("\"一炸\" " + handPaiStr + " 压住 \"一炸\" "
                            + lastHandPaisStr);
                    flag = true;
                } else {
                    System.out.println("\"一炸\" " + handPaiStr + " 压不住 \"一炸\" "
                            + lastHandPaisStr);
                    flag = false;
                }

            } else if (isXEqual(handPai, 0, 1, 3)) {// 四张牌："三带一"
                if (paiZHuo.isEmpty()) {// 牌桌为空
                    System.out.println("\"三带一\"" + handPaiStr);
                    flag = true;

                } else if (!isXEqual(lastHandPais, 0, 1, 3)) {// 牌桌上不是"三带一"
                    System.out.println("\"三带一\"  " + handPaiStr + " 压不住 "
                            + lastHandPaisStr);
                    flag = false;
                } else if (GameRuleUtil.commpareTwoPai(
                        GameRuleUtil.getEqualInt(handPai),
                        GameRuleUtil.getEqualInt(lastHandPais))) {// 玩家出的"三带一"压住牌桌上的"三带一"
                    System.out.println("\"三带一\"  " + handPaiStr
                            + " 压住 \"三带一\" " + lastHandPaisStr);
                    flag = true;
                } else {
                    System.out.println("\"三带一\"  " + handPaiStr
                            + " 压不住 \"三带一\" " + lastHandPaisStr);
                    flag = false;
                }
            } else if (handPai[0] == 0 && handPai[1] == 1) {// 四张牌:两鬼带两张
                if (paiZHuo.isEmpty()) {
                    System.out.println("\"两鬼带二\" " + handPaiStr);
                    flag = true;
                } else {
                    System.out.println("\"两鬼带二\" " + handPaiStr + " 压不住 "
                            + lastHandPaisStr);
                    flag = false;
                }
            } else {// 玩家出的四张牌:不符合规则
                System.out.println("四张牌 " + handPaiStr
                        + " 不是\"三带一\" or \"一炸\" or  \" 两鬼带二\"，不符合游戏规则");
                flag = false;
            } + " 压不住 "
                            + lastHandPaisStr);
                    flag = false;
                }
            } else {// 玩家出的四张牌:不符合规则
                System.out.println("四张牌 " + handPaiStr
                        + " 不是\"三带一\" or \"一炸\" or  \" 两鬼带二\"，不符合游戏规则");
                flag = false;
            }

玩家出五张牌

// 五张牌按照规则，只能是顺子
if (isShunZi(handPai)) {// 五张牌：顺子
    if (paiZHuo.isEmpty()) {//
        System.out.println("\"顺子\" " + handPaiStr);
        flag = true;
    } else if (isShunZi(lastHandPais)) {// 牌桌上的不是顺子
        System.out.println("\"顺子\" " + handPaiStr + " 压不住 "
                + lastHandPaisStr);
        flag = false;
    } else if (GameRuleUtil
                .commpareTwoShunZi(handPai, lastHandPais)) {// 判断玩家出的顺子是否压过牌桌上的顺子
        System.out.println("\"顺子\" " + handPaiStr + " 压住 "
                + "\"顺子\" " + lastHandPaisStr);
        flag = true;
    } else {
        System.out.println("\"顺子\" " + handPaiStr + " 压不住 "
                + "\"顺子\" " + lastHandPaisStr);
        flag = false;
    }
} else {// 五张牌：不符合规则
    System.out.println("五张牌 " + handPaiStr + " 不是\"顺子\"，不符合游戏规则");
    flag = false;
}

玩家出六张牌

// 玩家出6张牌
            if (isShunZi(handPai)) {// 六张牌：顺子
                if (paiZHuo.isEmpty()) {//
                    System.out.println("\"顺子\" " + handPaiStr);
                    flag = true;
                } else if (isShunZi(lastHandPais)) {// 牌桌上的不是顺子
                    System.out.println("\"顺子\" " + handPaiStr + " 压不住 "
                            + lastHandPaisStr);
                    flag = false;
                } else if (GameRuleUtil
                        .commpareTwoShunZi(handPai, lastHandPais)) {// 玩家出的顺子压过牌桌上的顺子
                    System.out.println("\"顺子\" " + handPaiStr + " 压住 "
                            + "\"顺子\" " + lastHandPaisStr);
                    flag = true;
                } else {
                    System.out.println("\"顺子\" " + handPaiStr + " 压不住 "
                            + "\"顺子\" " + lastHandPaisStr);
                    flag = false;
                }
            } else if (isFeiji(handPai)) {// 六张牌：飞机
                if (paiZHuo.isEmpty()) {//
                    System.out.println("\"飞机\" " + handPaiStr);
                    flag = true;
                } else if (isFeiji(lastHandPais)) {// 牌桌上的不是飞机
                    System.out.println("\"飞机\" " + handPaiStr + " 压不住 "
                            + lastHandPaisStr);
                    flag = false;
                } else if (GameRuleUtil.commpareTwoFeiJi(handPai, lastHandPais)) {// 玩家出的飞机压过牌桌上的飞机
                    System.out.println("\"飞机\" " + handPaiStr + " 压住 \"飞机\""
                            + lastHandPaisStr);
                    flag = true;
                } else {
                    System.out.println("\"飞机\" " + handPaiStr + " 压不住 \"飞机\""
                            + lastHandPaisStr);
                    flag = false;
                }
            } else if (isLiandui(handPai)) {// 六张牌：三连对
                if (paiZHuo.isEmpty()) {//
                    System.out.println("\"三连对\" " + handPaiStr);
                    flag = true;
                } else if (isLiandui(lastHandPais)) {// 牌桌上的不是连对
                    System.out.println("\"三连对\" " + handPaiStr + " 压不住 "
                            + handPaiStr);
                    flag = false;
                } else if (GameRuleUtil.commpareTwoLianDui(handPai,
                        lastHandPais)) {// 玩家出的连对压过牌桌上的连对
                    System.out.println("\"三连对\" " + handPaiStr
                            + " 压住  \"三连对\" " + handPaiStr);
                    flag = true;
                } else {
                    System.out.println("\"三连对\" " + handPaiStr
                            + " 压不住  \"三连对\" " + handPaiStr);
                    flag = false;
                }
            } else if (isXEqual(handPai, 0, 1, 4)) {// 六张牌：四带二
                if (paiZHuo.isEmpty()) {//
                    System.out.println("\"四带二\" " + handPaiStr);
                    flag = true;
                } else if (!isXEqual(lastHandPais, 0, 1, 4)) {// 牌桌上不是四带二
                    System.out.println("\"四带二\" " + handPaiStr + " 压不住 "
                            + lastHandPaisStr);
                    flag = false;

                } else if (GameRuleUtil.commpareFourPaisBandTwoPai(handPai,
                        lastHandPais)) {// 玩家出的四带二压过桌牌上的四带二
                    System.out.println("\"四带二\" " + handPaiStr + " 压住 \"四带二\" "
                            + lastHandPaisStr);
                    flag = true;
                } else {
                    System.out.println("\"四带二\" " + handPaiStr
                            + " 压不住 \"四带二\" " + lastHandPaisStr);
                    flag = false;
                }
            } else {// 玩家出的六张牌：不符合规则
                System.out.println("六张牌 " + handPaiStr
                        + " 不是\"顺子\" or \"四带二\" or \"三连对\" or \"飞机\"，不符合游戏规则");
                flag = false;
            }

玩家出七张牌

if (isShunZi(handPai)) {// 七张牌：顺子
    if (paiZHuo.isEmpty()) {//
        System.out.println("\"顺子\" " + handPaiStr);
        flag = true;
    } else if (isShunZi(lastHandPais)) {// 牌桌上的不是顺子
        System.out.println("\"顺子\" " + handPaiStr + " 压住 "
                + lastHandPaisStr);
        flag = false;
    } else if (GameRuleUtil
                .commpareTwoShunZi(handPai, lastHandPais)) {// 判断玩家出的顺子是否压过牌桌上的顺子
        System.out.println("\"顺子\" " + handPaiStr + " 压住 \"顺子\" "
                    + lastHandPaisStr);
        flag = true;
    } else {
        System.out.println("\"顺子\" " + handPaiStr + " 压不住 \"顺子\" "
                + lastHandPaisStr);
        flag = false;
    }
} else {// 七张牌：不符合规则
    System.out.println("七张牌 " + handPaiStr + " 不是\"顺子\"，不符合游戏规则");
    flag = false;
}

        case 8:// 玩家出8张牌
            if (isShunZi(handPai)) {// 八张牌:顺子
                if (paiZHuo.isEmpty()) {//
                    System.out.println("\"顺子\" " + handPaiStr);
                    flag = true;
                } else if (isShunZi(lastHandPais)) {// 牌桌上的不是顺子
                    System.out.println("\"顺子\" " + handPaiStr + " 压不住  "
                            + lastHandPaisStr);
                    flag = false;
                } else if (GameRuleUtil
                        .commpareTwoShunZi(handPai, lastHandPais)) {// 玩家出的顺子是否压过牌桌上的顺子
                    System.out.println("\"顺子\" " + handPaiStr + " 压住 \"顺子\" "
                            + lastHandPaisStr);
                    flag = true;
                } else {
                    System.out.println("\"顺子\" " + handPaiStr + " 压不住 \"顺子\" "
                            + lastHandPaisStr);
                    flag = false;
                }
            } else if (isFeijiBandTwo(handPai)) {// 八张牌：飞机带两张
                if (paiZHuo.isEmpty()) {//
                    System.out.println("\"飞机带二\" " + handPaiStr);
                    flag = true;
                } else if (!isFeijiBandTwo(lastHandPais)) {// 牌桌上不是飞机带两张
                    System.out.println("\"飞机带二\" " + handPaiStr + " 压不住  "
                            + lastHandPaisStr);
                    flag = false;
                } else if (GameRuleUtil.commpareFeiJiBandTwoPai(handPai,
                        lastHandPais)) {// 玩家出的飞机带两张压过牌桌上的飞机带两张
                    System.out.println("\"飞机带二\" " + handPaiStr
                            + " 压住  \"飞机带二\" " + lastHandPaisStr);
                    flag = true;
                } else {
                    System.out.println("\"飞机带二\" " + handPaiStr
                            + " 压不住  \"飞机带二\" " + lastHandPaisStr);
                    flag = false;
                }
            } else if (isLiandui(handPai)) {// 八张牌：四连对
                if (paiZHuo.isEmpty()) {
                    System.out.println("\"四连对\" " + handPaiStr);
                    flag = true;
                } else if (isLiandui(lastHandPais)) {// 牌桌上的不是连对
                    System.out.println("\"四连对\" " + handPaiStr + " 压不住  "
                            + lastHandPaisStr);
                    flag = false;
                } else if (GameRuleUtil.commpareTwoLianDui(handPai,
                        lastHandPais)) {// 玩家出的连对压过牌桌上的连对
                    System.out.println("\"四连对\" " + handPaiStr
                            + " 压住  \"四连对\" " + lastHandPaisStr);
                    flag = true;
                } else {
                    System.out.println("\"四连对\" " + handPaiStr
                            + " 压不住  \"四连对\" " + lastHandPaisStr);
                    flag = false;
                }
            } else {// 玩家出的八张牌：不符合规则
                System.out.println("八张牌 " + handPaiStr
                        + " 不是\"顺子\" or \"四连对\" or \"飞机带二\" or \"\"，不符合游戏规则");
                flag = false;
            }
            break;
        case 9:// 玩家出9张牌
            if (isShunZi(handPai)) {// 九张牌：顺子
                if (paiZHuo.isEmpty()) {//
                    System.out.println("\"顺子\" " + handPaiStr);
                    flag = true;
                } else if (isShunZi(lastHandPais)) {// 牌桌上的不是顺子
                    System.out.println("\"顺子\" " + handPaiStr + " 压不住 "
                            + lastHandPaisStr);
                    flag = false;
                } else if (GameRuleUtil
                        .commpareTwoShunZi(handPai, lastHandPais)) {// 判断玩家出的顺子是否压过牌桌上的顺子
                    System.out.println("\"顺子\" " + handPaiStr + " 压住 \"顺子\" "
                            + lastHandPaisStr);
                    flag = true;
                } else {
                    System.out.println("\"顺子\" " + handPaiStr + " 压不住 \"顺子\" "
                            + lastHandPaisStr);
                    flag = false;
                }
            } else {// 玩家出的九张牌：不符合规则
                System.out.println("九张牌 " + handPaiStr + " 不是\"顺子\"，不符合游戏规则");
                flag = false;
            }
            break;
        case 10:// 玩家出10张牌
            if (isShunZi(handPai)) {// 十张牌：顺子
                if (paiZHuo.isEmpty()) {//
                    System.out.println("\"顺子\" " + handPaiStr);
                    flag = true;
                } else if (isShunZi(lastHandPais)) {// 牌桌上的不是顺子
                    System.out.println("\"顺子\" " + handPaiStr + " 压不住 "
                            + lastHandPaisStr);
                    flag = false;
                } else if (GameRuleUtil
                        .commpareTwoShunZi(handPai, lastHandPais)) {// 判断玩家出的顺子是否压过牌桌上的顺子
                    flag = true;
                    System.out.println("\"顺子\" " + handPaiStr + " 压住 \"顺子\" "
                            + lastHandPaisStr);
                } else {
                    System.out.println("\"顺子\" " + handPaiStr + " 压不住 \"顺子\" "
                            + lastHandPaisStr);
                    flag = false;
                }
            } else if (isLiandui(handPai)) {// 十张牌： 五连对
                if (paiZHuo.isEmpty()) {//
                    System.out.println("\"五连对\" " + handPaiStr);
                    flag = true;
                } else if (isLiandui(lastHandPais)) {// 牌桌上的不是连对
                    System.out.println("\"五连对\" " + handPaiStr + " 压不住 "
                            + handPaiStr);
                    flag = false;
                } else if (GameRuleUtil.commpareTwoLianDui(handPai,
                        lastHandPais)) {// 玩家出的连对压过牌桌上的连对
                    System.out.println("\"五连对\" " + handPaiStr
                            + " 压住 \"五连对\"  " + handPaiStr);
                    flag = true;
                } else {
                    System.out.println("\"五连对\" " + handPaiStr
                            + " 压不住 \"五连对\"  " + handPaiStr);
                    flag = false;
                }
            } else {// 玩家出的十张牌：不符合规则
                System.out.println("十张牌 " + handPaiStr
                        + " 不是\"顺子\" or  \"五连对\" ，不符合游戏规则");
                flag = false;
            }
            break;
        case 11:// 玩家出11张牌
            if (isShunZi(handPai)) {// 十一张牌：顺子
                if (paiZHuo.isEmpty()) {//
                    System.out.println("\"顺子\" " + handPaiStr);
                    flag = true;
                } else if (isShunZi(lastHandPais)) {// 牌桌上的不是顺子
                    System.out.println("\"顺子\" " + handPaiStr + " 压住 "
                            + lastHandPaisStr);
                    flag = false;
                } else if (GameRuleUtil
                        .commpareTwoShunZi(handPai, lastHandPais)) {// 判断玩家出的顺子是否压过牌桌上的顺子
                    System.out.println("\"顺子\" " + handPaiStr + " 压住 \"顺子\" "
                            + lastHandPaisStr);
                    flag = true;
                } else {
                    flag = false;
                    System.out.println("\"顺子\" " + handPaiStr + " 压不住 \"顺子\" "
                            + lastHandPaisStr);
                }
            } else {// 玩家出的十一张牌：不符合规则
                System.out.println("十一张牌 " + handPaiStr + " 不是\"顺子\"，不符合游戏规则");
                flag = false;
            }
            break;
        case 12:// 玩家出12张牌
            if (isShunZi(handPai)) {// 十二张牌：顺子
                if (paiZHuo.isEmpty()) {//
                    System.out.println("\"顺子\" " + handPaiStr);
                    flag = true;
                } else if (isShunZi(lastHandPais)) {// 牌桌上的不是顺子
                    System.out.println("\"顺子\" " + handPaiStr + " 压不住  "
                            + lastHandPaisStr);
                    flag = false;
                } else if (GameRuleUtil
                        .commpareTwoShunZi(handPai, lastHandPais)) {// 判断玩家出的顺子是否压过牌桌上的顺子
                    System.out.println("\"顺子\" " + handPaiStr + " 压住 \"顺子\" "
                            + lastHandPaisStr);
                    flag = true;
                } else {
                    System.out.println("\"顺子\" " + handPaiStr + " 压不住 \"顺子\" "
                            + lastHandPaisStr);
                    flag = false;
                }
            } else if (isLiandui(handPai)) {// 十二张牌： 六连对
                if (paiZHuo.isEmpty()) {//
                    System.out.println("\"六连对\" " + handPaiStr
                            + " 压住 \"六连对\"  " + handPaiStr);
                    flag = true;
                } else if (isLiandui(lastHandPais)) {// 牌桌上的不是连对
                    System.out.println("\"六连对\" " + handPaiStr + " 压不住   "
                            + handPaiStr);
                    flag = false;
                } else if (GameRuleUtil.commpareTwoLianDui(handPai,
                        lastHandPais)) {// 玩家出的连对压过牌桌上的连对
                    System.out.println("\"六连对\" " + handPaiStr
                            + " 压住 \"六连对\"  " + handPaiStr);
                    flag = true;
                } else {
                    System.out.println("\"六连对\" " + handPaiStr
                            + " 压不住 \"六连对\"  " + handPaiStr);
                    flag = false;
                }
            } else {// 玩家出的十二张牌：不符合规则
                System.out.println("十二张牌 " + handPaiStr
                        + " 不是\"顺子\" or \"六连对\"，不符合游戏规则");
                flag = false;
            }
            break;
        case 13:// 玩家出13张牌
            System.out.println("不能出十三张牌 " + handPaiStr + " ，不符合游戏规则");
            flag = false;
            break;
        case 14:// 玩家出14张牌
            if (isLiandui(handPai)) {// 十四张牌：七连对
                if (paiZHuo.isEmpty()) {//
                    System.out.println("\"七连对\" " + handPaiStr);
                    flag = true;
                } else if (isLiandui(lastHandPais)) {// 牌桌上的不是连对
                    System.out.println("\"七连对\" " + handPaiStr + " 压不住 "
                            + handPaiStr);
                    flag = false;
                } else if (GameRuleUtil.commpareTwoLianDui(handPai,
                        lastHandPais)) {// 玩家出的连对压过牌桌上的连对
                    System.out.println("\"七连对\" " + handPaiStr
                            + " 压住 \"七连对\"   " + handPaiStr);
                    flag = true;
                } else {
                    System.out.println("\"七连对\" " + handPaiStr
                            + " 压不住 \"七连对\"   " + handPaiStr);
                    flag = false;
                }
            } else {// 玩家出的十四张牌：不符合规则
                System.out.println("十四张牌 " + handPaiStr + " 不是\"七连对\"，不符合游戏规则");
                flag = false;
            }
            break;
        case 15:// 玩家出15张牌
            System.out.println("不能出十五张牌 " + handPaiStr + " ，不符合游戏规则");
            flag = false;
            break;
        case 16:// 玩家出16张牌
            if (isLiandui(handPai)) {// 十六张牌：八连对
                if (paiZHuo.isEmpty()) {//
                    System.out.println("\"八连对\" " + handPaiStr);
                    flag = true;
                } else if (isLiandui(lastHandPais)) {// 牌桌上的不是连对
                    System.out.println("\"八连对\" " + handPaiStr + " 压不住 "
                            + handPaiStr);
                    flag = false;
                } else if (GameRuleUtil.commpareTwoLianDui(handPai,
                        lastHandPais)) {// 玩家出的连对压过牌桌上的连对
                    System.out.println("\"八连对\" " + handPaiStr
                            + " 压住 \"八连对\"   " + handPaiStr);
                    flag = true;
                } else {
                    System.out.println("\"八连对\" " + handPaiStr
                            + " 压不住 \"八连对\"    " + handPaiStr);
                    flag = false;
                }
            } else {// 玩家出的十六张牌：不符合规则
                System.out.println("十六张牌 " + handPaiStr + " 不是\"八连对\"，不符合游戏规则");
                flag = false;
            }
            break;
        case 17:// 玩家出17张牌
            System.out.println("不能出十七张牌 " + handPaiStr + " ，不符合游戏规则");
            flag = false;
            break;
        case 18:// 玩家出18张牌
            if (isLiandui(handPai)) {// 十八张牌：九连对
                if (paiZHuo.isEmpty()) {//
                    System.out.println("\"九连对\" " + handPaiStr);
                    flag = true;
                } else if (isLiandui(lastHandPais)) {// 牌桌上的不是连对
                    System.out.println("\"九连对\" " + handPaiStr + " 压不住 "
                            + handPaiStr);
                    flag = false;
                } else if (GameRuleUtil.commpareTwoLianDui(handPai,
                        lastHandPais)) {// 玩家出的连对压过牌桌上的连对
                    System.out.println("\"九连对\" " + handPaiStr
                            + " 压住 \"九连对\"  " + handPaiStr);
                    flag = true;
                } else {
                    System.out.println("\"九连对\" " + handPaiStr
                            + " 压不住 \"九连对\" " + handPaiStr);
                    flag = false;
                }
            } else {// 玩家出的十八张牌：不符合规则
                System.out.println("十八张牌 " + handPaiStr + " 不是\"九连对\"，不符合游戏规则");
                flag = false;
            }
            break;
        case 19:// 玩家出19张牌
            System.out.println("不能出十九张牌 " + handPaiStr + " ，不符合游戏规则");
            flag = true;
            break;
        case 20:// 玩家出20张牌
            if (isLiandui(handPai)) {// 20张牌：十连对
                if (paiZHuo.isEmpty()) {//
                    System.out.println("\"十连对\" " + handPaiStr);
                    flag = true;
                } else if (isLiandui(lastHandPais)) {// 牌桌上的不是连对
                    flag = false;
                } else if (GameRuleUtil.commpareTwoLianDui(handPai,
                        lastHandPais)) {// 玩家出的连对压过牌桌上的连对
                    flag = true;
                } else {
                    flag = false;
                }
            } else {// 玩家出的二十张牌：不符合规则
                System.out.println("二十张牌 " + handPaiStr + " 不是\"十连对\"，不符合游戏规则");
                flag = false;
            }
            break;
        default:
            break;
        }

游戏玩家出牌

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()
        + "\n");

最后编辑于：2017.12.03 04:34:00

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 202,607评论 5赞 476
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 85,047评论 2赞 379
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 149,496评论 0赞 335
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 54,405评论 1赞 273
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 63,400评论 5赞 364
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 48,479评论 1赞 281
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 37,883评论 3赞 395
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,535评论 0赞 256
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 40,743评论 1赞 295
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,544评论 2赞 319
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 37,612评论 1赞 329
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,309评论 4赞 318
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 38,881评论 3赞 306
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 29,891评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,136评论 1赞 259
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 42,783评论 2赞 349
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,316评论 2赞 342

Java斗地主游戏开发

推荐阅读更多精彩内容