话不多说，直接上代码
1. PreparePoker类
import java.util.*;
/**
* @ClassName: PreparePoker
* @Description: 准备一副牌
* @Author: limq
* @Date: 2021/9/24 15:47
**/
public class PreparePoker {
/**
* @Description: 获取一副乱序的牌
* @Author: limq7
* @Param: []
* @Return: java.util.ArrayList<java.lang.String>
* @Date: 2021/9/24 16:16
* */
public static ArrayList<String> preparePoker(){
ArrayList<String> pokerList = new ArrayList<>();
//有序的
pokerList.add("A");pokerList.add("A");pokerList.add("A");pokerList.add("A");
pokerList.add("2");pokerList.add("2");pokerList.add("2");pokerList.add("2");
pokerList.add("3");pokerList.add("3");pokerList.add("3");pokerList.add("3");
pokerList.add("4");pokerList.add("4");pokerList.add("4");pokerList.add("4");
pokerList.add("5");pokerList.add("5");pokerList.add("5");pokerList.add("5");
pokerList.add("6");pokerList.add("6");pokerList.add("6");pokerList.add("6");
pokerList.add("7");pokerList.add("7");pokerList.add("7");pokerList.add("7");
pokerList.add("8");pokerList.add("8");pokerList.add("8");pokerList.add("8");
pokerList.add("9");pokerList.add("9");pokerList.add("9");pokerList.add("9");
pokerList.add("10");pokerList.add("10");pokerList.add("10");pokerList.add("10");
pokerList.add("J");pokerList.add("J");pokerList.add("J");pokerList.add("J");
pokerList.add("Q");pokerList.add("Q");pokerList.add("Q");pokerList.add("Q");
pokerList.add("K");pokerList.add("K");pokerList.add("K");pokerList.add("K");
//大王
pokerList.add("King");
//小王
pokerList.add("Kinglet");
//打乱牌的顺序
Collections.shuffle(pokerList);
return pokerList;
}
/***
* @Description: 发牌给两位玩家
* @Author: limq7
* @Param: [pokerList]
* @Return: java.util.Map<java.lang.String,java.util.List<java.lang.String>>
* @Date: 2021/9/24 16:22
* */
public static Map<String, List<String>> PokerToPlayer(List<String> pokerList){
Map<String,List<String>> playerPoker = new HashMap<>();
List<String> playerAList = new ArrayList<>();
List<String> playerBList = new ArrayList<>();
//开始发牌
for (int i = 0; i <pokerList.size() ; i++) {
if( i % 2 == 0){
playerAList.add(pokerList.get(i));
}else {
playerBList.add(pokerList.get(i));
}
}
playerPoker.put("playA",playerAList);
playerPoker.put("playB",playerBList);
return playerPoker;
}
public static void main(String[] args) {
ArrayList<String> randomPokerList = preparePoker();
System.out.println(randomPokerList);
}
}
2. JudgePokerRule类:制定游戏规则
/**
* @Description :
* @Author : limq7
* @Create in : 2021/9/24 16:27
**/
import java.util.*;
/**
* @ClassName: JudgePokerRule
* @Description: 判断出牌是否符合出牌规则
* @Author: limq
* @Date: 2021/9/24 16:27
**/
public class JudgePokerRule {
public static List<String> pokerList = new ArrayList<>();
static {
pokerList.add("3");
pokerList.add("4");
pokerList.add("5");
pokerList.add("6");
pokerList.add("7");
pokerList.add("8");
pokerList.add("9");
pokerList.add("10");
pokerList.add("J");
pokerList.add("Q");
pokerList.add("K");
pokerList.add("A");
pokerList.add("2");
pokerList.add("King");
pokerList.add("Kinglet");
}
/***
* @Description: 判断要出的牌是否在当前牌里面,如果在，保存临时删除的list
* @Author: limq7
* @Param: []
* @Return: boolean
* @Date: 2021/9/26 10:01
* */
public static Map<Boolean,List<String>> pokersIsInMyPoker(List<String> pokerList,List<String> myPokerList){
Map<Boolean,List<String>> tempDelMap = new HashMap<>();
Map<String,Integer> pokerMap = new HashMap<>();
Map<String,Integer> myPokerMap = new HashMap<>();
for (int i = 0; i <pokerList.size() ; i++) {
if(!pokerMap.containsKey(pokerList.get(i))){
pokerMap.put(pokerList.get(i),1);
}else {
Integer iCount = pokerMap.get(pokerList.get(i));
pokerMap.replace(pokerList.get(i),iCount+1);
}
}
//保存每种扑克及其对应的张数
for (int i = 0; i <myPokerList.size() ; i++) {
if(!myPokerMap.containsKey(myPokerList.get(i))){
myPokerMap.put(myPokerList.get(i),1);
}else {
Integer iCount = myPokerMap.get(myPokerList.get(i));
myPokerMap.replace(myPokerList.get(i),iCount+1);
}
}
for (int i = 0; i <pokerList.size() ; i++) {
Integer pokerNum = pokerMap.get(pokerList.get(i));
if(!myPokerMap.containsKey(pokerList.get(i))){
tempDelMap.put(false,new ArrayList<>());
return tempDelMap;
}else {
Integer myPokerNum = myPokerMap.get(pokerList.get(i));
if(myPokerNum < pokerNum){
//牌数不够
tempDelMap.put(false,new ArrayList<>());
return tempDelMap;
}
}
}
//如果上面都成功了，说明我的牌可以出
List<String> tempDelList = new ArrayList<>();
tempDelList.addAll(myPokerList);
for (Map.Entry<String,Integer> pokerEntry : pokerMap.entrySet()){
String pokerName = pokerEntry.getKey();
Integer pokerNum = pokerEntry.getValue();
Iterator<String> iterator = tempDelList.iterator();
int delCount = 1;
while (iterator.hasNext()) {
String myPokerName = iterator.next();
if (pokerName.equals(myPokerName)) {
if(delCount > pokerNum){
continue;
}else {
iterator.remove();//使用迭代器的删除方法删除
delCount++;
}
}
}
}
tempDelMap.clear();
tempDelMap.put(true,tempDelList);
return tempDelMap;
}
/***
* @Description: 对出牌进行合法判断
* @Author: limq7
* @Param: [inputPoker]
* @Return: boolean
* @Date: 2021/9/26 9:35
* */
public static boolean isPokerLegal(String inputPoker){
String[] inputArr = inputPoker.split(";");
if(inputArr.length > 27){
return false;
}else {
for (int i = 0; i <inputArr.length ; i++) {
if(!pokerList.contains(inputArr[i])){
return false;
}
}
}
return true;
}
/***
* @Description: 出牌必须符合出牌规则
* @Author: limq7
* @Param: [pokerList]
* @Return: boolean
* @Date: 2021/9/26 9:34
* */
public static boolean judgePokerRule(List<String> pokerList){
//1.出一张牌，肯定符合
if(pokerList.size() == 1){
return true;
}
/*
* 2.出两张牌，有两种情况：
* 2.1:两张牌相等，即对子;
* 2.2:王炸
* */
if(pokerList.size() == 2){
//大小一样
if(JudgePokerBigOrSmall.getPokerValue(pokerList.get(0)) == JudgePokerBigOrSmall.getPokerValue(pokerList.get(1))){
return true;
}
//大小王
if(pokerList.get(0).contains("King") && pokerList.get(1).contains("King")){
return true;
}
}
//3.出三张牌，三张牌必须相等
//4.出四张牌，四张牌也必须相等（两对不让出，三个只能带一对）
if(pokerList.size() == 3 || pokerList.size() == 4){
//set会自动去重
Set<String> pokerSet = new HashSet<>();
pokerSet.addAll(pokerList);
if(pokerSet.size() == 1){
//便于垃圾回收
pokerSet.clear();
return true;
}
}
/*
* 5.出五张牌
* 5.1 三带一对
* 5.2 单个的顺子
* */
if(pokerList.size() == 5){
//set会自动去重
Set<String> pokerSet = new HashSet<>();
pokerSet.addAll(pokerList);
//三带一对
if(pokerSet.size() == 2){
//便于垃圾回收
pokerSet.clear();
return true;
}
//五个单牌
if(pokerSet.size() == 5){
List<Integer> pokerValueList = new ArrayList<>();
for (int i = 0; i <pokerList.size() ; i++) {
pokerValueList.add(JudgePokerBigOrSmall.getPokerValue(pokerList.get(i)));
}
//对值进行排序
Collections.sort(pokerValueList);
boolean fitWithRule = true;
for (int i = 0; i <pokerValueList.size()-1 ; i++) {
if(pokerValueList.get(i) + 1 != pokerValueList.get(i+1) || pokerValueList.get(i+1) >= 12){
fitWithRule = false;
}
}
pokerValueList.clear();
return fitWithRule;
}
}
/*
* 六张牌：
* 6.1： 33 44 55 连对
* 6.2： 444 555
* 6.3： 4 5 6 7 8 9
* */
if(pokerList.size() == 6){
//1.判断是不是连对
if(isEvenPair(pokerList)){
return true;
}
//2.判断是不是 444 555
if(isThreePair(pokerList)){
return true;
}
//3.判断是不是单个的顺子
if(isSinglePair(pokerList)){
return true;
}
}
/*
* 六张牌以上：
* 1. 333 444 555形式
* 2. 33 44 55 66形式
* 3. 3 4 5 6 7 8 9形式
* 4. 333 444 55 66形式
* */
if(pokerList.size() > 6){
if(isThreePair(pokerList)){
return true;
}
if(isEvenPair(pokerList)){
return true;
}
if(isSinglePair(pokerList)){
return true;
}
if(isThreeAndEven(pokerList)){
return true;
}
}
return false;
}
/**
* @Description: 判断是不是连对
* @Author: limq7
* @Param: []
* @Return: boolean
* @Date: 2021/9/24 17:04
* */
public static boolean isEvenPair(List<String> pokerList){
if(pokerList.size() % 2 != 0 || pokerList.size() < 6 || pokerList.size() > 24){
return false;
}else {
//第一步，去重
Set<String> pokerSet = new HashSet<>();
pokerSet.addAll(pokerList);
if(pokerList.size() != pokerSet.size() * 2){
return false;
}else {
List<Integer> pokerValueList = new ArrayList<>();
Iterator<String> pokerIterator = pokerSet.iterator();
while (pokerIterator.hasNext()){
pokerValueList.add(JudgePokerBigOrSmall.getPokerValue(pokerIterator.next()));
}
//对值进行排序
Collections.sort(pokerValueList);
boolean fitWithRule = true;
for (int i = 0; i <pokerValueList.size()-1 ; i++) {
if(pokerValueList.get(i) + 1 != pokerValueList.get(i+1) || pokerValueList.get(i+1) >= 12){
fitWithRule = false;
}
}
pokerValueList.clear();
return fitWithRule;
}
}
}
/***
* @Description: 单牌顺子
* @Author: limq7
* @Param: [pokerList]
* @Return: boolean
* @Date: 2021/9/24 17:20
* */
public static boolean isSinglePair(List<String> pokerList){
if(pokerList.size() < 5 || pokerList.size() > 12){
return false;
}else {
Set<String> pokerSet = new HashSet<>();
pokerSet.addAll(pokerList);
if(pokerList.size() != pokerSet.size()){
return false;
}else {
List<Integer> pokerValueList = new ArrayList<>();
for (int i = 0; i <pokerList.size() ; i++) {
pokerValueList.add(JudgePokerBigOrSmall.getPokerValue(pokerList.get(i)));
}
//对值进行排序
Collections.sort(pokerValueList);
boolean fitWithRule = true;
for (int i = 0; i <pokerValueList.size()-1 ; i++) {
if(pokerValueList.get(i) + 1 != pokerValueList.get(i+1) || pokerValueList.get(i+1) >= 12){
fitWithRule = false;
}
}
pokerValueList.clear();
return fitWithRule;
}
}
}
/***
* @Description: 三个三个的牌
* @Author: limq7
* @Param: [pokerList]
* @Return: boolean
* @Date: 2021/9/24 17:26
* */
public static boolean isThreePair(List<String> pokerList){
if(pokerList.size() % 3 != 0 || pokerList.size() < 6 || pokerList.size() > 27){
return false;
}else {
Set<String> pokerSet = new HashSet<>();
pokerSet.addAll(pokerList);
if(pokerSet.size() * 3 != pokerList.size()){
return false;
}else {
List<Integer> pokerValueList = new ArrayList<>();
Iterator<String> pokerIterator = pokerSet.iterator();
while (pokerIterator.hasNext()){
pokerValueList.add(JudgePokerBigOrSmall.getPokerValue(pokerIterator.next()));
}
//对值进行排序
Collections.sort(pokerValueList);
boolean fitWithRule = true;
for (int i = 0; i <pokerValueList.size()-1 ; i++) {
if(pokerValueList.get(i) + 1 != pokerValueList.get(i+1) || pokerValueList.get(i+1) >= 12){
fitWithRule = false;
}
}
pokerValueList.clear();
return fitWithRule;
}
}
}
/***
* @Description: 判断是不是三带二
* @Author: limq7
* @Param: [pokerList]
* @Return: boolean
* @Date: 2021/9/24 17:32
* */
public static boolean isThreeAndEven(List<String> pokerList){
if(pokerList.size() == 10 ||pokerList.size() == 15 || pokerList.size() == 20 || pokerList.size() == 25){
//将三个三个的排在一块
Collections.sort(pokerList);
Map<String,Integer> pokerMap = new HashMap<>();
for (int i = 0; i <pokerList.size(); i++) {
if(pokerMap.containsKey(pokerList.get(i))){
Integer count = pokerMap.get(pokerList.get(i));
pokerMap.put(pokerList.get(i),count++);
}else {
pokerMap.put(pokerList.get(i),1);
}
}
List<String> isEvenList = new ArrayList<>();
List<String> isThreeList = new ArrayList<>();
for (int i = 0; i < pokerList.size(); i++) {
if(pokerMap.get(pokerList.get(i)) == 3){
isThreeList.add(pokerList.get(i));
}
if(pokerMap.get(pokerList.get(i)) == 2){
isEvenList.add(pokerList.get(i));
}
}
if(isThreePair(isThreeList) && (isThreeList.size() + isEvenList.size() == pokerList.size())){
return true;
}
}
return false;
}
public static void main(String[] args) {
List<String> pokerList = new ArrayList<>();
List<String> myPokerList = new ArrayList<>();
pokerList.add("A");
pokerList.add("A");
pokerList.add("K");
pokerList.add("K");
pokerList.add("Q");
pokerList.add("Q");
myPokerList.add("A");
myPokerList.add("A");
myPokerList.add("Q");
myPokerList.add("Q");
myPokerList.add("K");
myPokerList.add("K");
myPokerList.add("K");
System.out.println(myPokerList.retainAll(pokerList));
}
}
3. JudgePokerBigOrSmall类：比较牌大小
/**
* @Description :
* @Author : limq7
* @Create in : 2021/9/24 16:22
**/
import io.swagger.models.auth.In;
import java.util.*;
/**
* @ClassName: JudgePokerBigOrSmall
* @Description: 判断牌的大小
* @Author: limq
* @Date: 2021/9/24 16:22
**/
public class JudgePokerBigOrSmall {
/**
* @Description: 获得牌面的实际大小
* @Author: limq7
* @Param: [pokerName]
* @Return: java.lang.Integer
* @Date: 2021/9/24 16:27
* */
public static Integer getPokerValue(String pokerName){
Map<String,Integer> pokerNameValueMap = new HashMap<>();
pokerNameValueMap.put("3",0);
pokerNameValueMap.put("4",1);
pokerNameValueMap.put("5",2);
pokerNameValueMap.put("6",3);
pokerNameValueMap.put("7",4);
pokerNameValueMap.put("8",5);
pokerNameValueMap.put("9",6);
pokerNameValueMap.put("10",7);
pokerNameValueMap.put("J",8);
pokerNameValueMap.put("Q",9);
pokerNameValueMap.put("K",10);
pokerNameValueMap.put("A",11);
pokerNameValueMap.put("2",12);
pokerNameValueMap.put("King",13);
pokerNameValueMap.put("Kinglet",14);
return pokerNameValueMap.get(pokerName);
}
/***
* @Description: 比较自己出的牌跟牌面的牌的大小
* @Author: limq7
* @Param: [pokerAList, pokerBList]
* @Return: boolean
* @Date: 2021/9/24 18:00
* */
public static boolean compareTwoPokers(List<String> pokerNowList,List<String> pokerBeforeList){
//先匹配类型，再比较值
String pokerNowType = getPokerType(pokerNowList);
String pokerBeforeType = getPokerType(pokerBeforeList);
//只有当前的牌是炸弹或者跟之前的牌类型一样才有比较的意义
if(pokerNowType.equals("typeD") || pokerNowType.equals("typeJ") || pokerNowType.equals(pokerBeforeType)){
//如果当前是王炸，肯定赢
if(pokerNowType.equals("typeJ")){
return true;
}
//如果当前是四个的，且对方既不是王炸，也不是四个的，肯定赢
if(pokerNowType.equals("typeD") && ((!pokerBeforeType.equals("typeD")) || (!pokerBeforeType.equals("typeJ")))){
return true;
}
//如果两个都是四个的
if(pokerNowType.equals("typeD") && pokerBeforeType.equals("typeD")){
Integer nowValue = JudgePokerBigOrSmall.getPokerValue(pokerNowList.get(0));
Integer beforeValue = JudgePokerBigOrSmall.getPokerValue(pokerBeforeList.get(0));
if(nowValue > beforeValue){
return true;
}
}
//如果两个都不是炸,先排序，再比较最小的那个值
Collections.sort(pokerNowList);
Collections.sort(pokerBeforeList);
if(pokerNowType.equals("typeA") || pokerNowType.equals("typeB")
||pokerNowType.equals("typeC") || pokerNowType.equals("typeF")
||pokerNowType.equals("typeG") || pokerNowType.equals("typeH")){
Integer nowValue = JudgePokerBigOrSmall.getPokerValue(pokerNowList.get(0));
Integer beforeValue = JudgePokerBigOrSmall.getPokerValue(pokerBeforeList.get(0));
if(nowValue > beforeValue){
return true;
}
}
if(pokerNowType.equals("typeE") || pokerNowType.equals("typeI")){
Map<String,Integer> repairNowMap = new HashMap<>();
Map<String,Integer> repairBeforeMap = new HashMap<>();
for (int i = 0; i <pokerNowList.size() ; i++) {
if(repairNowMap.containsKey(pokerNowList.get(i))){
int count = repairNowMap.get(pokerNowList.get(i));
repairNowMap.replace(pokerNowList.get(i),count+1);
}else {
repairNowMap.put(pokerNowList.get(i),1);
}
}
for (int i = 0; i <pokerBeforeList.size() ; i++) {
if(repairBeforeMap.containsKey(pokerBeforeList.get(i))){
int count = repairBeforeMap.get(pokerBeforeList.get(i));
repairBeforeMap.replace(pokerBeforeList.get(i),count+1);
}else {
repairBeforeMap.put(pokerBeforeList.get(i),1);
}
}
Integer nowValue = 100;
for (Map.Entry<String, Integer> entry : repairNowMap.entrySet()){
if(entry.getValue() == 3){
Integer value = JudgePokerBigOrSmall.getPokerValue(entry.getKey());
if(value < nowValue){
nowValue = value;
}
}
}
Integer beforeValue = 100;
for (Map.Entry<String, Integer> entry : repairBeforeMap.entrySet()){
if(entry.getValue() == 3){
Integer value = JudgePokerBigOrSmall.getPokerValue(entry.getKey());
if(value < beforeValue){
beforeValue = value;
}
}
}
if(nowValue > beforeValue){
return true;
}
}
}else {
return false;
}
return false;
}
public static String getPokerType(List<String> pokerList){
/*
* 类型一 typeA：单牌一张 J
* 类型二 typeB：对子 JJ
* 类型三 typeC：三个的 JJJ
* 类型四 typeD：四个的 JJJJ
* 类型五 typeE：三带一对 JJJKK
* 类型六 typeF：连对 JJQQKK
* 类型七 typeG：单牌顺子 10 J Q K A
* 类型八 typeH：三个三个的
* 类型九 typeI：三个三个带两个两个
* 类型十 typeJ：王炸
* */
if(pokerList.size() == 1){
return "typeA";
}
if(pokerList.size() == 2){
if(pokerList.get(0).equals(pokerList.get(1))){
return "typeB";
}else {
//王炸
return "typeJ";
}
}
if(pokerList.size() == 3){
return "typeC";
}
if(pokerList.size() == 4){
return "typeD";
}
if(pokerList.size() == 5){
Set<String> pokerSet = new HashSet<>();
pokerSet.addAll(pokerList);
if(pokerSet.size() == 5){
//类型七 typeG：单牌顺子 10 J Q K A
return "typeG";
}else {
//类型五 typeE：三带一对 JJJKK
return "typeE";
}
}
//连对
if(pokerList.size() > 5){
Set<String> pokerSet = new HashSet<>();
pokerSet.addAll(pokerList);
if(pokerSet.size() * 2 == pokerList.size()){
//类型六 typeF：连对 JJQQKK
return "typeF";
}else if(pokerSet.size() * 3 == pokerList.size()){
//类型八 typeH：三个三个的
return "typeH";
}else if(pokerSet.size() == pokerList.size()){
//类型七 typeG：单牌顺子 10 J Q K A
return "typeG";
}else {
//类型九 typeI：三个三个带两个两个
return "typeI";
}
}
return "";
}
}
4.PlayingPokers类：游戏启动类
/**
* @Description :
* @Author : limq7
* @Create in : 2021/9/26 9:17
**/
import java.util.*;
/**
* @ClassName: PlayingPokers
* @Description: 开始正式玩游戏了
* @Author: limq
* @Date: 2021/9/26 9:17
**/
public class PlayingPokers {
public static List<String> beforePokerList = new ArrayList<>();
//上家是否出牌
public static boolean beforePokerStatus = true;
public static void main(String[] args) {
//1.准备两个玩家的牌，开始发牌
List<String> pokerList = PreparePoker.preparePoker();
Map<String, List<String>> playerMap = PreparePoker.PokerToPlayer(pokerList);
List<String> playerAList = playerMap.get("playA");
List<String> playerBList = playerMap.get("playB");
//排个序
Collections.sort(playerAList);
Collections.sort(playerBList);
//2.开始打牌
boolean gameStatus = true;
int iCount = 0;
while (gameStatus){
if(iCount % 2 == 0){
//A玩家出牌
//1.先打印上家出的牌，才能决定自己要出什么牌
if(iCount != 0){
System.out.println("上家出的牌：" + beforePokerList);
}
//2.打印自己手上有什么牌
System.out.println("A玩家的牌：" + playerAList);
//3.开始决定出牌
boolean isInputFail = true;
List<String> myPokerList = new ArrayList<>();
while (isInputFail){
Scanner inputScanner = new Scanner(System.in);
System.out.println("=================输入规则：多张牌请用分号;隔开,否则输入失败================");
String inputPokers = inputScanner.nextLine();
if("pass".equals(inputPokers) && iCount != 0){
//要不起
isInputFail = false;
beforePokerStatus = false;
System.out.println("==================A玩家要不起，B玩家继续出牌===============");
}else {
boolean isSuccess = JudgePokerRule.isPokerLegal(inputPokers);
if(isSuccess){
myPokerList = Arrays.asList(inputPokers.split(";"));
//判断出牌是否符合游戏的规则
boolean isMatchRule = JudgePokerRule.judgePokerRule(myPokerList);
if(isMatchRule){
//符合规则，继续比较跟上家牌的大小，如果比上家牌大，则出牌成功；否则，重新出牌
boolean isMyPokerBigger = true;
if(iCount != 0 && beforePokerStatus == true){
isMyPokerBigger = JudgePokerBigOrSmall.compareTwoPokers(myPokerList,beforePokerList);
}
if(isMyPokerBigger){
//最后再判断我是否有这个牌
Map<Boolean,List<String>> tempDelMap = JudgePokerRule.pokersIsInMyPoker(myPokerList,playerAList);
if(tempDelMap.containsKey(true)){
System.out.println("A玩家出牌成功！");
beforePokerList.clear();
beforePokerList.addAll(myPokerList);
//删除后的A的牌
playerAList.clear();
playerAList = tempDelMap.get(true);
System.out.println("A玩家剩下的牌："+playerAList);
if(playerAList.size() == 0){
//牌出完了，A玩家赢了，游戏结束！
System.out.println("=================游戏结束，A玩家获胜=================");
System.exit(0);
}
isInputFail = false;
}else {
System.out.println("====================手里没有这样的牌，请重新出牌=======================");
}
}else {
System.out.println("====================牌不够大，请重新出牌=======================");
}
}else {
//不符合规则，重新出牌
System.out.println("===============不符合玩法规则，请重新出牌===================");
}
}else {
myPokerList.clear();
System.out.println("===============输入不合法，请重新出牌===================");
}
}
}
}
if(iCount % 2 == 1){
//B玩家出牌
System.out.println("上家出的牌：" + beforePokerList);
//2.打印自己手上有什么牌
System.out.println("B玩家的牌：" + playerBList);
//3.开始决定出牌
boolean isInputFail = true;
List<String> myPokerList = new ArrayList<>();
while (isInputFail){
Scanner inputScanner = new Scanner(System.in);
System.out.println("=================输入规则：多张牌请用分号;隔开,否则输入失败================");
String inputPokers = inputScanner.nextLine();
if("pass".equals(inputPokers) && iCount != 0){
//要不起
isInputFail = false;
beforePokerStatus = false;
System.out.println("==================B玩家要不起，A玩家继续出牌===============");
}else {
boolean isSuccess = JudgePokerRule.isPokerLegal(inputPokers);
if(isSuccess){
myPokerList = Arrays.asList(inputPokers.split(";"));
//判断出牌是否符合游戏的规则
boolean isMatchRule = JudgePokerRule.judgePokerRule(myPokerList);
if(isMatchRule){
//符合规则，继续比较跟上家牌的大小，如果比上家牌大，则出牌成功；否则，重新出牌
boolean isMyPokerBigger = true;
if(iCount != 0 && beforePokerStatus == true){
isMyPokerBigger = JudgePokerBigOrSmall.compareTwoPokers(myPokerList,beforePokerList);
}
if(isMyPokerBigger){
//最后再判断我是否有这个牌
Map<Boolean,List<String>> tempDelMap = JudgePokerRule.pokersIsInMyPoker(myPokerList,playerBList);
if(tempDelMap.containsKey(true)){
System.out.println("B玩家出牌成功！");
beforePokerList.clear();
beforePokerList.addAll(myPokerList);
//删除后的B的牌
playerBList.clear();
playerBList = tempDelMap.get(true);
System.out.println("B玩家剩下的牌："+playerBList);
if(playerBList.size() == 0){
//牌出完了，B玩家赢了，游戏结束！
System.out.println("=================游戏结束，B玩家获胜=================");
System.exit(0);
}
isInputFail = false;
}else {
System.out.println("====================手里没有这样的牌，请重新出牌=======================");
}
}else {
System.out.println("====================牌不够大，请重新出牌=======================");
}
}else {
//不符合规则，重新出牌
System.out.println("===============不符合玩法规则，请重新出牌===================");
}
}else {
System.out.println("===============输入不合法，请重新出牌===================");
}
}
}
}
iCount++;
}
}
}
