java实现德州扑克比较大小

源码

gitee.com/wangLi1997/…

业务流程：

接口一：每个用户发放7张牌

接口二：用户选中其中5张牌

具体业务实现：

步骤一：先对牌做等级的划分（防止相同牌型出现并列排名的问题）

步骤二：再对相同牌型做排序

规则参考

规则明细

https://nimg.ws.126.net/?url=http%3A%2F%2Fdingyue.ws.126.net%2FOKobrQZryfH0ufaPNA0eeZ00zkfj1ZB8rz8pEgDihJL5t1517883939520compressflag.jpg&thumbnail=660x2147483647&quality=80&type=jpg

德州扑克规则
先比较牌型大小

牌型大小：
（1）基本法则是：“先比牌型后比点数”。
（2）牌型的大小顺序为：同花顺＞铁支＞葫芦＞同花＞顺子＞三条＞二对＞对子＞散牌
（3）点数大小顺序为：A＞K＞Q＞J＞10＞9＞8＞7＞6＞5＞4＞3＞2
（4）共有9种牌型。分别是：同花顺 铁支 葫芦 同花 顺子 三条 二对 对子 散牌
（5）牌型的大小顺序为：同花顺＞铁支＞葫芦＞同花＞顺子＞三条＞二对＞对子＞散牌
（6）不同牌型之间的大小按上方的大小顺序来比较。如果是相同牌型之间的比较呢？下面将逐一介绍
当牌型相同的时候，按照以下规则比较大小

1. 皇家同花顺之间的比较：
    2个玩家都是皇家同花顺，和。

2. 同花顺之间的比较：
    A、同花顺虽然以花色成牌型，但两个同花顺相比时不比花色，只比点数，从最大的一张牌开始比起，大者胜；
    B、如果相同，则再比稍小一点的那张，大者胜；
    C、如果再相同再往下比，直到分出大小来；
    D、若是五张牌的点数都一样大，则两个同花顺同样大小。
    E、比如黑桃的10、J、Q、K、A与梅花的10、J、Q、K、A相比，两者是同样大小的。

3. 铁支之间的比较：
    A、铁支的大小比较只看4条的点数。
    B、4条点数大的胜。
    C、如果4条点数相同（只有都取公牌时才会出现这种情况），则比杂牌大小，杂牌大者胜。如果杂牌点数也相等，则同大。

4. 葫芦之间的比较：
    A、葫芦的大小比较只看3条的点数。
    B、3条点数大的胜。
    C、如果3条点数相同（只有都取公牌时才会出现这种情况），则比一对的大小，一对大者胜，如果一对也相等，则同大。
    
5. 同花之间的比较：
    A、同花之间的比较不看花色，而看单张最大一张牌的点数。
    B、如果最大的一张牌的点数一样大，则比相对小一点的那张牌点数；
    C、如果还一样大，再往下比，直到分出大小来；
    D、如果五张牌的点数都一样大，那么判断为同等大小。 （同花中，“A”为最大的牌）

6. 顺子之间的比较：
    A、顺子之间的比较跟同花顺的相同，也是从最大的第一张牌比起。
    B、如果最大的第一张牌相同，则再比稍小一点的那张。
    C、如果再相同再往下比，直到分出大小来。
    D、若是五张牌的点数都一样大，则两个顺子同样大小。
    E、A在做顺子牌型的时候，只会出现在顺首和顺尾，并且会有截然不同的效果。比如下面的例子：
    A、K、Q、J、10 在此牌型中“A”为顺尾，它作为最大的牌使用。
    5、4、3、2、A 在此牌型中“A”为顺首，它作为最小的牌使用。
    比如： 5、4、3、2、A 就比 6、5、4、3、2 要小。

7. 三条之间的比较
    三条之间的比较是先比3条的点数，3条大者胜。如果3条同大。则比最大的一张杂牌的大小，大者胜。如果最大的杂牌点数也相等，则比第二张杂牌的大小，大者胜。若还是相等，则同大。

8. 二对之间的比较
    A、二对之间的比较先看最大的一对，点数大的胜；
    B、如果点数相同，则比第二对，同样是点数大的胜；
    C、若第二对也相同，则比杂牌的大小，杂牌点数大者胜；
    D、要是连杂牌点数都一样了，判断为相同大小。

9. 对子之间的比较
    A、对子之间的比较先看对子的大小，点数大的胜；
    B、若点数相同，则再看最大的第一张杂牌，点数大的胜；
    C、最大的一张杂牌点数相同的话，比第二张大的杂牌，点数大的胜；
    D、如果再相同，则比最后一张杂牌的大小，点数大的胜；
    E、若都相同，则判断为相同大小。

10. 散牌之间的比较
    A、散牌之间的比较先看最大的一张牌的点数，大者胜；
    B、最大的牌相同的话，比第二大牌的点数，大者胜；
    C、再相同，再比下一张，大者胜；一直到比出为止；
    D、如果五张牌点数都一样大，则判断为相同大小。
    E、散牌比较中，“A”为最大的牌。

牌型预估

package com.woodare.poker.helper;

import cn.hutool.core.collection.CollectionUtil;
import com.alibaba.fastjson.JSONObject;
import com.google.common.collect.Maps;
import com.woodare.poker.common.ApiStatus;
import com.woodare.poker.exception.ApiException;
import com.woodare.poker.pojo.data.PokerData;
import com.woodare.poker.pojo.data.PokerInfoData;
import com.woodare.poker.pojo.entity.GameRecord;
import com.woodare.poker.pojo.entity.GameRoom;
import com.woodare.poker.pojo.enums.PokerColorEnum;
import com.woodare.poker.pojo.enums.PokerEnum;
import com.woodare.poker.pojo.enums.PokerLevelEnum;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.*;
import java.util.stream.Collectors;

import static java.util.Map.Entry.comparingByKey;
import static java.util.Map.Entry.comparingByValue;
import static java.util.stream.Collectors.toMap;

/**
 * ClassName PokerHelper
 *
 * @author wang
 * Date 2022/3/21 18:15
 */
@Component
@Slf4j
public class PokerHelper {

    public static PokerInfoData POKER_INFO_DATA = null;

    public static final Integer DIFF_NUM = 2;

    @PostConstruct
    public static void init() {
        log.info("init poker data...");
        JSONObject map = new JSONObject();
        int i = 0;
        for (PokerColorEnum pokerColor : PokerColorEnum.values()) {
            for (PokerEnum poker : PokerEnum.values()) {
                i++;
                PokerData pokerData = new PokerData();
                pokerData.setDetail(pokerColor.getName() + poker.getName());
                pokerData.setPoker(poker.getWeight());
                pokerData.setPokerColor(pokerColor.toString());
                pokerData.setIdx(i);
                map.put(i + "", pokerData);
            }
        }
        POKER_INFO_DATA = new PokerInfoData();
        POKER_INFO_DATA.setPokerMap(map);
        log.info("init poker data end");
    }

    public static PokerInfoData initPokerGame() {
        return POKER_INFO_DATA;
    }


    /**
     * 发牌
     *
     * @param grantNum
     * @param pokerGame
     * @return
     */
    public static List<PokerData> grantPoker(Integer grantNum, GameRoom pokerGame) {
        List<PokerData> result = new ArrayList<>();
        JSONObject pokerMap = JSONObject.parseObject(pokerGame.getAllPokerList());
        Set<String> strings = pokerMap.keySet();
        if (pokerMap.size() < grantNum) {
            throw new ApiException(ApiStatus.POKER_HAS_RUN_OUT_FAIL);
        }
        LinkedList<String> indexList = new LinkedList<>(strings);
        for (int i = 1; i <= grantNum; i++) {
            Collections.shuffle(indexList);
            String poll;
            if (i % 2 == 0) {
                poll = indexList.pollFirst();
            } else {
                poll = indexList.pollLast();
            }
            assert poll != null;
            Object value = pokerMap.remove(poll);
            PokerData pokerData = JSONObject.parseObject(JSONObject.toJSONString(value), PokerData.class);
            result.add(pokerData);
        }
        pokerGame.setAllPokerList(pokerMap.toJSONString());
        return result;
    }

    /**
     * 计算得分
     *
     * @param list 前台选中的牌
     */
    public static Integer getPokerLevel(List<PokerData> list) {
        // 基础分数
        int level = 0;
        if (isSameColor(list) && isStraightV2(list)) {
            log.debug(PokerLevelEnum.STRAIGHT_FLUSH.toString());
            level = PokerLevelEnum.STRAIGHT_FLUSH.getWeight();
        } else if (isFourKind(list)) {
            log.debug(PokerLevelEnum.FOUR_OF_A_KIND.toString());
            level = PokerLevelEnum.FOUR_OF_A_KIND.getWeight();
        } else if (isFlushHouse(list)) {
            log.debug(PokerLevelEnum.FLUSH_HOUSE.toString());
            level = PokerLevelEnum.FLUSH_HOUSE.getWeight();
        } else if (isSameColor(list)) {
            log.debug(PokerLevelEnum.FLUSH.toString());
            level = PokerLevelEnum.FLUSH.getWeight();
        } else if (isStraightV2(list)) {
            log.debug(PokerLevelEnum.STRAIGHT.toString());
            level = PokerLevelEnum.STRAIGHT.getWeight();
        } else if (isThreeKind(list)) {
            log.debug(PokerLevelEnum.THREE_OF_A_KIND.toString());
            level = PokerLevelEnum.THREE_OF_A_KIND.getWeight();
        } else if (isTwoPair(list)) {
            log.debug(PokerLevelEnum.TWO_PAIR.toString());
            level = PokerLevelEnum.TWO_PAIR.getWeight();
        } else if (isOnePair(list)) {
            log.debug(PokerLevelEnum.ONE_PAIR.toString());
            level = PokerLevelEnum.ONE_PAIR.getWeight();
        } else if (isHighCard(list)) {
            level = PokerLevelEnum.HIGH_CARD.getWeight();
        }
        return level;
    }


    /**
     * 是不是同花
     *
     * @param requestPokerList
     * @return
     */
    public static boolean isSameColor(List<PokerData> requestPokerList) {
        String pokerColor = requestPokerList.get(0).getPokerColor();
        boolean flag = true;
        for (int i = 0; i < requestPokerList.size(); i++) {
            if (!pokerColor.equals(requestPokerList.get(i).getPokerColor())) {
                flag = false;
                break;
            }
        }
        return flag;
    }

    /**
     * 是不是顺子
     *
     * @param
     * @return
     */
    public static boolean isStraight(List<PokerData> requestPokerList) {
        boolean flag = true;
        int[] poker = requestPokerList.stream().mapToInt(PokerData::getPoker).toArray();
        Arrays.sort(poker);
        int temp = poker[0];
        for (int i = 1; i < poker.length; i++) {
            if (poker[i] - temp == 1) {
                temp = poker[i];
            } else {
                flag = false;
                break;
            }
        }
        return flag;
    }

    /**
     * 是不是顺子
     *
     * @param
     * @return
     */
    public static boolean isStraightV2(List<PokerData> requestPokerList) {
        boolean flag = true;
        // 正序排序
        List<Integer> list = requestPokerList.stream().map(PokerData::getPoker).sorted(Comparator.naturalOrder()).collect(Collectors.toList());
        list.removeIf(next -> next.equals(CompareHelper.BIG_ACE));
        int temp = list.get(0);
        for (int i = 1; i < list.size(); i++) {
            if (list.get(i) - temp == 1) {
                temp = list.get(i);
            } else {
                flag = false;
                break;
            }
        }
        if(flag){
            Integer first = list.get(0);
            Integer last = list.get(list.size() - 1);
            if(first == PokerEnum.TWO.getWeight() || last == PokerEnum.KING.getWeight()){
                return true;
            }
            flag = false;
        }
        return flag;
    }



    /**
     * 是不是四条
     *
     * @return
     */
    public static boolean isFourKind(List<PokerData> requestPokerList) {
        Map<Integer, Integer> map = listToMap(requestPokerList);
        if (map.size() == PokerEnum.TWO.getWeight()) {
            Collection<Integer> values = map.values();
            if (values.contains(PokerEnum.FOUR.getWeight()) && values.contains(CompareHelper.ONE)) {
                return true;
            }
        }
        return false;
    }


    /**
     * @param requestPokerList
     * @return （val - valCnt ）
     */
    public static Map<Integer, Integer> listToMap(List<PokerData> requestPokerList) {
        List<Integer> list = requestPokerList.stream().map(PokerData::getPoker).collect(Collectors.toList());
        Map<Integer, Integer> map = new HashMap<>();
        for (Integer val : list) {
            map.put(val, map.containsKey(val) ? map.get(val) + 1 : 1);
        }
        return map;
    }


    /**
     * 是不是葫芦（三带二）
     *
     * @return
     */
    public static boolean isFlushHouse(List<PokerData> requestPokerList) {
        Map<Integer, Integer> map = listToMap(requestPokerList);
        if (map.size() == PokerEnum.TWO.getWeight()) {
            Collection<Integer> values = map.values();
            if (values.contains(PokerEnum.TWO.getWeight()) && values.contains(PokerEnum.THREE.getWeight())) {
                return true;
            }
        }
        return false;
    }

    /**
     * 是不是三条（如：3、3、3、4、10）
     *
     * @return
     */
    public static boolean isThreeKind(List<PokerData> requestPokerList) {
        Map<Integer, Integer> map = listToMap(requestPokerList);
        Collection<Integer> values = map.values();
        if (values.contains(PokerEnum.THREE.getWeight())) {
            return true;
        }
        return false;
    }

    /**
     * 是不是两对（如：3、3、4、4、10）
     *
     * @return
     */
    public static boolean isTwoPair(List<PokerData> requestPokerList) {
        Map<Integer, Integer> map = listToMap(requestPokerList);
        if (map.size() == PokerEnum.THREE.getWeight()) {
            Collection<Integer> values = map.values();
            Integer sum = values.stream().reduce(Integer::sum).orElse(0);
            if (sum == PokerEnum.FIVE.getWeight()) {
                return true;
            }
        }
        return false;
    }

    /**
     * 是不是一对（如：3、3、4、7、10）
     *
     * @return
     */
    public static boolean isOnePair(List<PokerData> requestPokerList) {
        Map<Integer, Integer> map = listToMap(requestPokerList);
        if (map.size() == PokerEnum.FOUR.getWeight()) {
            Collection<Integer> values = map.values();
            Integer sum = values.stream().reduce(Integer::sum).orElse(0);
            if (sum == PokerEnum.FIVE.getWeight()) {
                return true;
            }
        }
        return false;
    }

    /**
     * 是不是高牌（如：3、7、4、J、10）
     *
     * @return
     */
    public static boolean isHighCard(List<PokerData> requestPokerList) {
        Map<Integer, Integer> map = listToMap(requestPokerList);
        if (map.size() == PokerEnum.FIVE.getWeight()) {
            return true;
        }
        return false;
    }

    /**
     * 根据扑克等级排序
     * 如果等级相同，需要比较牌大小
     *
     * @param playerList
     */
    public static List<GameRecord> orderByPokerLevel(List<GameRecord> playerList) {
        // 未确认的先取出来
        List<GameRecord> nullLevel = new ArrayList<>();
        Iterator<GameRecord> iterator = playerList.iterator();
        while (iterator.hasNext()) {
            GameRecord next = iterator.next();
            if(Objects.isNull(next.getPokerLevel())){
                nullLevel.add(next);
                iterator.remove();
            }
        }
        List<GameRecord> result = new ArrayList<>();
        Map<Integer, List<GameRecord>> map = playerList.stream()
                .collect(Collectors.groupingBy(GameRecord::getPokerLevel, LinkedHashMap::new, Collectors.toList()));
        // 按key降序
        Map<Integer, List<GameRecord>> integerListMap = sortByKey(map, true);
        if (playerList.size() == map.size()) {
            return playerList;
        }
        for (Map.Entry<Integer, List<GameRecord>> integerListEntry : integerListMap.entrySet()) {
            List<GameRecord> value = integerListEntry.getValue();
            List<GameRecord> ret;
            if (value.size() == 1) {
                ret = value;
            } else {
                ret = compareAndSwap(value);
            }
            result.addAll(ret);
        }
        // 未确认的放到最后
        if(CollectionUtil.isNotEmpty(nullLevel)){
            result.addAll(nullLevel);
        }
        // 设置分数、排名
        int rankNum = 0;
        for (GameRecord gameRecord : result) {
            rankNum++;
            gameRecord.setRankNum(rankNum);
        }
        return result;
    }

    /**
     * 根据map的key排序
     *
     * @param map 待排序的map
     * @param isDesc 是否降序，true：降序，false：升序
     * @return 排序好的map
     */
    public static <K extends Comparable<? super K>, V> Map<K, V> sortByKey(Map<K, V> map, boolean isDesc) {
        Map<K, V> result = Maps.newLinkedHashMap();
        if (isDesc) {
            map.entrySet().stream().sorted(Map.Entry.<K, V>comparingByKey().reversed())
                    .forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
        } else {
            map.entrySet().stream().sorted(Map.Entry.<K, V>comparingByKey())
                    .forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
        }
        return result;
    }



    /**
     * 比较并且交换
     *
     * @param playerList
     * @return
     */
    public static List<GameRecord> compareAndSwap(List<GameRecord> playerList) {
        GameRecord[] players = new GameRecord[playerList.size()];
        for (int i = 0; i < playerList.size(); i++) {
            players[i] = playerList.get(i);
        }
        GameRecord temp;
        for (int i = 0; i < players.length - 1; i++) {
            // 定义一个布尔类型的变量，标记数组是否已达到有序状态
            boolean flag = true;
            for (int j = 0; j < players.length - 1 - i; j++) {
                GameRecord curr = players[j];
                GameRecord next = players[j + 1];
                int num = compareEqualsLevelPoker(curr, next);
                if (num == -1) {
                    temp = players[j];
                    players[j] = players[j + 1];
                    players[j + 1] = temp;
                    // 本趟发生了交换，表明该数组在本趟处于无序状态，需要继续比较；
                    flag = false;
                }
            }
            // 根据标记量的值判断数组是否有序，如果有序，则退出；无序，则继续循环。
            if (flag) {
                break;
            }
        }
        return Arrays.asList(players);
    }

    public static void main(String[] args) {
        List<PokerData> requestPokerList = new ArrayList<>();
        PokerData item = new PokerData();
        item.setPoker(2);
        item.setPokerColor(PokerColorEnum.BLOCK.toString());
        requestPokerList.add(item);
        item = new PokerData();
        item.setPoker(14);
        item.setPokerColor(PokerColorEnum.BLOCK.toString());
        requestPokerList.add(item);
        item = new PokerData();
        item.setPoker(4);
        item.setPokerColor(PokerColorEnum.BLOCK.toString());
        requestPokerList.add(item);
        item = new PokerData();
        item.setPoker(3);
        item.setPokerColor(PokerColorEnum.BLOCK.toString());
        requestPokerList.add(item);
        item = new PokerData();
        item.setPoker(5);
        item.setPokerColor(PokerColorEnum.BLOCK.toString());
        requestPokerList.add(item);
        List<PokerData> pokerData = orderByPoker(requestPokerList, 5);
        System.out.println(pokerData);
    }


    /**
     * curr > next  1
     * curr == next  0
     * curr < next  -1
     *
     * @param curr
     * @param next
     * @return
     */
    public static int compareEqualsLevelPoker(GameRecord curr, GameRecord next) {
        Integer pokerLevel = next.getPokerLevel();
        List<PokerData> currList = JSONObject.parseArray(curr.getConfirmPokerInfo(), PokerData.class);
        List<PokerData> nextList = JSONObject.parseArray(next.getConfirmPokerInfo(), PokerData.class);
        if (PokerLevelEnum.STRAIGHT_FLUSH.getWeight() == pokerLevel) {
            return CompareHelper.compareSameColorOrStraight(currList, nextList);
        } else if (PokerLevelEnum.FOUR_OF_A_KIND.getWeight() == pokerLevel) {
            return CompareHelper.compareFourKind(currList, nextList);
        } else if (PokerLevelEnum.FLUSH_HOUSE.getWeight() == pokerLevel) {
            return CompareHelper.compareFlushHouse(currList, nextList);
        } else if (PokerLevelEnum.FLUSH.getWeight() == pokerLevel) {
            return CompareHelper.compareSameColor(currList, nextList);
        } else if (PokerLevelEnum.STRAIGHT.getWeight() == pokerLevel) {
            return CompareHelper.compareSameColorOrStraight(currList, nextList);
        } else if (PokerLevelEnum.THREE_OF_A_KIND.getWeight() == pokerLevel) {
            return CompareHelper.compareThreeKind(currList, nextList);
        } else if (PokerLevelEnum.TWO_PAIR.getWeight() == pokerLevel) {
            return CompareHelper.compareTwoPair(currList, nextList);
        } else if (PokerLevelEnum.ONE_PAIR.getWeight() == pokerLevel) {
            return CompareHelper.compareOnePair(currList, nextList);
        } else if (PokerLevelEnum.HIGH_CARD.getWeight() == pokerLevel) {
            return CompareHelper.compareHighCard(currList, nextList);
        } else {
            return 0;
        }
    }

    /**
     * 从小到大排序
     * @param pokerList
     * @param pokerLevel
     * @return
     */
    public static List<PokerData> orderByPoker(List<PokerData> pokerList, Integer pokerLevel) {
        // 默认升序
        List<PokerData> list = pokerList.stream().sorted(Comparator.comparing(PokerData::getPoker)).collect(Collectors.toList());
        if(PokerLevelEnum.STRAIGHT.getWeight() == pokerLevel || PokerLevelEnum.STRAIGHT_FLUSH.getWeight() == pokerLevel){
            // 如果是  2 3 4 5 A ，需要交换位置
            Integer first = list.get(0).getPoker();
            Integer last = list.get(list.size() - 1).getPoker();
            if(first == PokerEnum.TWO.getWeight() && last == PokerEnum.ACE.getWeight()){
                LinkedList<PokerData> linkedList = new LinkedList<>(list);
                PokerData pokerData = linkedList.pollLast();
                linkedList.add(0, pokerData);
                return linkedList;
            }
        }
        return list;
    }
}

相同牌型比较

package com.woodare.poker.helper;

import com.woodare.poker.pojo.data.PokerData;
import com.woodare.poker.pojo.enums.PokerColorEnum;

import java.util.*;
import java.util.stream.Collectors;

/**
 * ClassName CompareHelper
 *
 * @author wang
 * Date 2022/4/7 8:54
 */
public class CompareHelper {

    public static final Integer BIG_ACE = 14;

    public static final Integer ONE = 1;

    public static final Integer TWO = 2;

    public static final Integer THREE = 3;

    public static final Integer FOUR = 4;

    /**
     *  同花顺、顺子比较大小
     *  比较最大值，如果最大值相等
     *  注意：
     *  最小 A 2 3 4 5
     *  最大 10 J Q K A
     * @return
     */
    public static int compareSameColorOrStraight(List<PokerData> currList, List<PokerData> nextList) {
        // 先去除A，找到最大值
        List<Integer> curr = currList.stream().map(PokerData::getPoker).collect(Collectors.toList());
        if(curr.contains(BIG_ACE)){
            curr.removeIf(c -> c.equals(BIG_ACE));
        }
        List<Integer> next = nextList.stream().map(PokerData::getPoker).collect(Collectors.toList());
        if(next.contains(BIG_ACE)){
            next.removeIf(n -> n.equals(BIG_ACE));
        }
        return compareHighValue(curr, next);
//        Integer num1 = curr.stream().reduce(Integer::max).orElse(0);
//        Integer num2 = next.stream().reduce(Integer::max).orElse(0);
//        int i = num1.compareTo(num2);
        // 如果是同花 或 同花顺，会出现牌相同，但花色不同，比较花色优先级
//        if (i != 0) {
//            return i;
//        }
//        // 降序
//        currList = currList.stream().sorted(Comparator.comparing(PokerData::getPoker).reversed()).collect(Collectors.toList());
//        nextList = nextList.stream().sorted(Comparator.comparing(PokerData::getPoker).reversed()).collect(Collectors.toList());
//        Integer val1 = PokerColorEnum.map.get(currList.get(0).getPokerColor());
//        Integer val2 = PokerColorEnum.map.get(nextList.get(0).getPokerColor());
//        return val1.compareTo(val2);
    }

    /**
     * 四条比较大小
     *
     * @return
     */
    public static int compareFourKind(List<PokerData> currList, List<PokerData> nextList) {
        return compare(currList, nextList, FOUR, ONE);
    }

    /**
     * 葫芦比较大小
     *
     * @return
     */
    public static int compareFlushHouse(List<PokerData> currList, List<PokerData> nextList) {
        return compare(currList, nextList, THREE, TWO);
    }

    /**
     * 同花比较大小
     *
     * @return
     */
    public static int compareSameColor(List<PokerData> currList, List<PokerData> nextList) {
        List<Integer> curr = currList.stream().map(PokerData::getPoker).collect(Collectors.toList());
        List<Integer> next = nextList.stream().map(PokerData::getPoker).collect(Collectors.toList());
        return compareHighValue(curr, next);
    }


    /**
     * 三条比较大小
     *
     * @return
     */
    public static int compareThreeKind(List<PokerData> currList, List<PokerData> nextList) {
        return compare(currList, nextList, THREE, null);
    }

    /**
     * 两对比较大小
     *
     * @return
     */
    public static int compareTwoPair(List<PokerData> currList, List<PokerData> nextList) {
        Map<Integer, Integer> currMap = PokerHelper.listToMap(currList);
        Map<Integer, Integer> nextMap = PokerHelper.listToMap(nextList);
        // 如果是两对，需要特殊处理
        // {7=1, 2=2, 3=2}
        Integer one1 = 0;
        // 取出只出现一次的牌
        for (Map.Entry<Integer, Integer> integerIntegerEntry : currMap.entrySet()) {
            if(integerIntegerEntry.getValue().equals(ONE)){
                one1 = integerIntegerEntry.getKey();
                currMap.remove(integerIntegerEntry.getKey());
                break;
            }
        }
        Integer one2 = 0;
        // 取出只出现一次的牌
        for (Map.Entry<Integer, Integer> integerIntegerEntry : nextMap.entrySet()) {
            if(integerIntegerEntry.getValue().equals(ONE)){
                one2 = integerIntegerEntry.getKey();
                nextMap.remove(integerIntegerEntry.getKey());
                break;
            }
        }
        Integer num1 = currMap.keySet().stream().reduce(Integer::max).orElse(0);
        Integer num2 = nextMap.keySet().stream().reduce(Integer::max).orElse(0);
        if(!num1.equals(num2)){
            return num1.compareTo(num2);
        }
        // 如果最大的一对相等，比较 小的一对
        Integer num11 = currMap.keySet().stream().reduce(Integer::min).orElse(0);
        Integer num22 = nextMap.keySet().stream().reduce(Integer::min).orElse(0);
        if(!num11.equals(num22)){
            return num11.compareTo(num22);
        }
        // 如果最大、最小的一对都相等，比较 单数
        return one1.compareTo(one2);
    }

    /**
     * 一对比较大小
     *
     * @return
     */
    public static int compareOnePair(List<PokerData> currList, List<PokerData> nextList) {
        return compare(currList, nextList, TWO, null);
    }

    /**
     * 高牌比较大小
     *
     * @return
     */
    public static int compareHighCard(List<PokerData> currList, List<PokerData> nextList) {
        // 降序
        List<Integer> curr = currList.stream().map(PokerData::getPoker).collect(Collectors.toList());
        List<Integer> next = nextList.stream().map(PokerData::getPoker).collect(Collectors.toList());
        return compareHighValue(curr, next);
//        if(i != 0){
//            return i;
//        }
        // 两组牌大小相同，依次比较花色
//        return compareHighValueColor(currList, nextList);
    }

    /**
     * 比较花色
     * @param currList
     * @param nextList
     * @return
     */
    private static int compareHighValueColor(List<PokerData> currList, List<PokerData> nextList) {
        for (int i = 0; i < currList.size(); i++) {
            Integer num1 = PokerColorEnum.map.get(currList.get(i).getPokerColor());
            Integer num2 = PokerColorEnum.map.get(nextList.get(i).getPokerColor());
            if(num1.equals(num2)){
                continue;
            }
            return num1.compareTo(num2);
        }
        return 0;
    }

    /**
     * 相同长度集合 比较大小
     *
     * @return
     */
    private static int compareHighValue(List<Integer> curr, List<Integer> next) {
        // 降序
        curr.sort(Comparator.reverseOrder());
        next.sort(Comparator.reverseOrder());
        for (int i = 0; i < curr.size(); i++) {
            Integer num1 = curr.get(i);
            Integer num2 = next.get(i);
            if(num1.equals(num2)){
                continue;
            }
            return num1.compareTo(num2);
        }
        return 0;
    }

    /**
     * @param currList
     * @param nextList
     * @param val1     出现的次数
     * @param val2     出现的次数
     * @return
     */
    public static int compare(List<PokerData> currList, List<PokerData> nextList, Integer val1, Integer val2) {

        Map<Integer, Integer> currMap = PokerHelper.listToMap(currList);
        Map<Integer, Integer> nextMap = PokerHelper.listToMap(nextList);
        // 如 一对 {5=1, 3=1, 7=1, 6=2} ，对应牌 {6,6,3,5,7}
        Integer num1 = 0;
        for (Map.Entry<Integer, Integer> integerIntegerEntry : currMap.entrySet()) {
            if(integerIntegerEntry.getValue().equals(val1)){
                num1 = integerIntegerEntry.getKey();
                currMap.remove(integerIntegerEntry.getKey());
                break;
            }
        }
        Integer num2 = 0;
        for (Map.Entry<Integer, Integer> integerIntegerEntry : nextMap.entrySet()) {
            if(integerIntegerEntry.getValue().equals(val1)){
                num2 = integerIntegerEntry.getKey();
                nextMap.remove(integerIntegerEntry.getKey());
                break;
            }
        }
        if (!num1.equals(num2)) {
            return num1.compareTo(num2);
        }
        if (Objects.nonNull(val2)) {
            for (Map.Entry<Integer, Integer> integerIntegerEntry : currMap.entrySet()) {
                if(integerIntegerEntry.getValue().equals(val2)){
                    num1 = integerIntegerEntry.getKey();
                    currMap.remove(integerIntegerEntry.getKey());
                    break;
                }
            }
            for (Map.Entry<Integer, Integer> integerIntegerEntry : nextMap.entrySet()) {
                if(integerIntegerEntry.getValue().equals(val2)){
                    num2 = integerIntegerEntry.getKey();
                    nextMap.remove(integerIntegerEntry.getKey());
                    break;
                }
            }
            return num1.compareTo(num2);
        } else {
            // 三条或者一对，比较杂牌大小
            return compareHighValue(new ArrayList<>(currMap.keySet()), new ArrayList<>(nextMap.keySet()));
        }
    }

    public static void main(String[] args) {

        List<PokerData> requestPokerList = new ArrayList<>();
        PokerData item = new PokerData();
        item.setPoker(13);
        item.setPokerColor(PokerColorEnum.BLOCK.toString());
        requestPokerList.add(item);
        item = new PokerData();
        item.setPoker(14);
        item.setPokerColor(PokerColorEnum.BLOCK.toString());
        requestPokerList.add(item);
        item = new PokerData();
        item.setPoker(3);
        item.setPokerColor(PokerColorEnum.BLOCK.toString());
        requestPokerList.add(item);
        item = new PokerData();
        item.setPoker(4);
        item.setPokerColor(PokerColorEnum.BLOCK.toString());
        requestPokerList.add(item);
        item = new PokerData();
        item.setPoker(5);
        item.setPokerColor(PokerColorEnum.BLOCK.toString());
        requestPokerList.add(item);

        List<PokerData> requestPokerList2 = new ArrayList<>();
        item = new PokerData();
        item.setPoker(14);
        item.setPokerColor(PokerColorEnum.SPADE.toString());
        requestPokerList2.add(item);
        item = new PokerData();
        item.setPoker(12);
        item.setPokerColor(PokerColorEnum.SPADE.toString());
        requestPokerList2.add(item);
        item = new PokerData();
        item.setPoker(5);
        item.setPokerColor(PokerColorEnum.SPADE.toString());
        requestPokerList2.add(item);
        item = new PokerData();
        item.setPoker(7);
        item.setPokerColor(PokerColorEnum.SPADE.toString());
        requestPokerList2.add(item);
        item = new PokerData();
        item.setPoker(11);
        item.setPokerColor(PokerColorEnum.SPADE.toString());
        requestPokerList2.add(item);

//        int i = compareSameColorOrStraight(requestPokerList, requestPokerList2);
//        int i = compareFourKind(requestPokerList, requestPokerList2);
//        int i = compareFlushHouse(requestPokerList, requestPokerList2);
//        int i = compareSameColor(requestPokerList, requestPokerList2);
//        int i = compareThreeKind(requestPokerList, requestPokerList2);
//        int i = compareTwoPair(requestPokerList, requestPokerList2);
//        int i = compareOnePair(requestPokerList, requestPokerList2);
        int i = compareHighCard(requestPokerList, requestPokerList2);
        System.out.println(i);
    }


}

其他类

package com.woodare.poker.pojo.data;

import com.woodare.poker.pojo.enums.PokerColorEnum;
import com.woodare.poker.pojo.enums.PokerEnum;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

/**
 * ClassName PositionData
 *
 * @author wang
 * Date 2022/3/21 17:17
 */
@Data
@ApiModel("发牌信息")
public class PokerData {

    @ApiModelProperty(value = "扑克牌", example = "2(2) || 11(J)")
    private Integer poker;

    @ApiModelProperty(value = "扑克花色( SPADE(\"黑桃\", 5), HEARTS(\"红桃\", 4), BLOCK(\"方块\", 3), CLUB(\"梅花\", 2); )", example = "CLUB")
    private String pokerColor;

    @ApiModelProperty(value = "描述")
    private String detail;

    @ApiModelProperty(value = "下标", hidden = true)
    private Integer idx;

}


package com.woodare.poker.pojo.enums;

import lombok.Getter;

import java.util.LinkedHashMap;
import java.util.Map;

/**
 * Classname CardsEnum
 *
 * @author wang
 * Date 2022/3/21 18:56
 */
@Getter
public enum PokerEnum {

    TWO("2", 2),
    THREE("3", 3),
    FOUR("4", 4),
    FIVE("5", 5),
    SIX("6", 6),
    SEVEN("7", 7),
    EIGHT("8", 8),
    NINE("9", 9),
    TEN("10", 10),
    JACK("J", 11),
    QUEEN("Q", 12),
    KING("K", 13),
    ACE("A", 14),
    ;
    private String name;
    private int weight;

    PokerEnum(String name, int weight) {
        this.name = name;
        this.weight = weight;
    }


}


package com.woodare.poker.pojo.enums;

import lombok.Getter;

import java.util.LinkedHashMap;
import java.util.Map;

/**
 * Classname CardColorEnum
 *
 * @author wang
 * Date 2022/3/21 18:53
 */
@Getter
public enum PokerColorEnum {

    //♦♣♥♠
    SPADE("黑桃", 5), HEARTS("红桃", 4), BLOCK("方块", 3), CLUB("梅花", 2);
    private String name;
    private int weight;

    PokerColorEnum(String name, int weight) {
        this.name = name;
        this.weight = weight;
    }

    public static Map<String, Integer> map = new LinkedHashMap<>();

    static {
        for (PokerColorEnum value : PokerColorEnum.values()) {
            map.put(value.toString(), value.getWeight());
        }
    }


}


package com.woodare.poker.pojo.enums;

import lombok.Getter;

import java.util.LinkedHashMap;
import java.util.Map;

/**
 * 扑克等级
 *
 * @author wang
 * Date 2022/3/21 18:56
 */
@Getter
public enum PokerLevelEnum {

    ROYAL_FLUSH("皇家同花顺", "ROYAL_FLUSH", 10),
    STRAIGHT_FLUSH("同花顺", "STRAIGHT_FLUSH", 9),
    FOUR_OF_A_KIND("四条", "FOUR_OF_A_KIND", 8),
    FLUSH_HOUSE("葫芦", "FLUSH_HOUSE", 7),
    FLUSH("同花", "FLUSH", 6),
    STRAIGHT("顺子", "STRAIGHT", 5),
    THREE_OF_A_KIND("三条", "THREE_OF_A_KIND", 4),
    TWO_PAIR("两对", "TWO_PAIR", 3),
    ONE_PAIR("一对", "ONE_PAIR", 2),
    HIGH_CARD("高牌", "HIGH_CARD", 1),
    ;
    private String name;
    private String engName;
    private int weight;

    PokerLevelEnum(String name, String engName, int weight) {
        this.name = name;
        this.engName = engName;
        this.weight = weight;
    }

    public static Map<String, Integer> map = new LinkedHashMap<>();

    static {
        for (PokerLevelEnum value : PokerLevelEnum.values()) {
            map.put(value.getName(), value.getWeight());
        }
    }

}

package com.woodare.poker.pojo.data;

import com.alibaba.fastjson.JSONObject;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import io.swagger.models.auth.In;
import lombok.Data;

import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * ClassName PositionData
 *
 * @author wang
 * Date 2022/3/21 17:17
 */
@Data
@ApiModel("发牌缓存信息")
public class PokerInfoData {

    @ApiModelProperty(value = "扑克集合")
    private JSONObject pokerMap;

}

package com.woodare.poker.pojo.entity;

import com.baomidou.mybatisplus.annotation.TableName;
import com.woodare.poker.base.AbstractEntity;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.experimental.Accessors;

import java.time.LocalDateTime;

/**
 * <p>
 * 
 * </p>
 *
 * @author Wang
 * @since 2022-03-30
 */
@Data
@Accessors(chain = true)
@TableName("game_record")
@ApiModel(value = "游戏记录对象", description = "")
public class GameRecord extends AbstractEntity {

    @ApiModelProperty(value = "玩家游戏状态：  JOINED(1)，PLAYING(2)，ABANDON(3)， FINISHED(4)， CONFIRMED(5)")
    private Integer playerGameStatus;

    @ApiModelProperty(value = "点位置信息")
    private String positionInfo;

    @ApiModelProperty(value = "分数")
    private Integer score;

    @ApiModelProperty(value = "排名")
    private Integer rankNum;

    @ApiModelProperty(value = "扑克级别")
    private Integer pokerLevel;

    @ApiModelProperty(value = "发放扑克信息")
    private String grantPokerInfo;

    @ApiModelProperty(value = "确认扑克信息")
    private String confirmPokerInfo;

    @ApiModelProperty(value = "游戏记录编号")
    private String recordNo;

}