Java扑克牌游戏——猜牌型\凑牌型得分

一、猜牌型

1.定义一个单张扑克类（考虑需要哪些属性），定义一个一副扑克牌类，该类包含一个单张扑克对象的数组（不考虑大小王）。实现一个模拟扑克发牌洗牌的算法；

2.电脑随机发出5张牌，判断是以下哪种类型？

由于牌数太多，将牌数缩短为20张，只有10，J，Q，K，A。

Card类包含数值（int）、花色（String）

考虑以下几点：

由于new出的Card对象返回的是哈希码，所以该类要重写toString方法来返回正确的扑克名

J,Q,K,A对应11,12,13,14，所以在toString方法中利用选择判断语句将其转换

public class Card {
    int rank;
    String suit;
    public Card(String suit,int rank){
        this.rank=rank;
        this.suit=suit;
    }

    @Override
    public String toString() {
        String new_rank="";
        switch (this.rank){
            case 14:{
                new_rank="A";break;
            }
            case 11:{
                new_rank="J";break;
            }
            case 12:{
                new_rank="Q";break;
            }
            case 13:{
                new_rank="K";break;
            }
            default:{
                new_rank=String.valueOf(this.rank);
                break;
            }
        }
        return this.suit+new_rank;
    }
}

Poker类

考虑以下几点：

10张牌，四种花色，生成一副扑克牌

洗牌（随机数，交换）

输出扑克牌

判断牌型

import java.util.*;

public class Poker {
    Card[] cards=new Card[20];
    String[] suits={"红桃","方片","黑桃","草花"};
    public Poker(String[] suits,Card[] cards){
        this.cards=cards;
        this.suits=suits;
    }
    public Poker(){
        int index=0;
        for (int i=0;i<this.suits.length;i++){
            for (int j=10;j<=14;j++){
                Card card=new Card(this.suits[i],j);
                cards[index]=card;
                index++;
            }
        }
    }
    public void shuffle(){
        Random random=new Random();
        for (int i=0;i<20;i++){
            int random_index= random.nextInt(20);
            Card tmp=cards[i];
            cards[i]=cards[random_index];
            cards[random_index]=tmp;
        }
    }
    public List<Card> getOneHand(){
        List<Card> cardList=new ArrayList<>();
        this.shuffle();
        for (int i=0;i<5;i++) cardList.add(cards[i]);
        return cardList;
    }
    public void output(){
        int index=0;
        for (int i=0;i<this.suits.length;i++){
            for (int j=1;j<=5;j++){
                System.out.print(cards[index]);
                index++;
            }
            System.out.println();
        }
    }

    public String getType(List<Card> hand) {
        Set<String> suitSet=new HashSet<>();
        List<Integer> rankList =new ArrayList<>();
        Set<Integer> rankSet=new HashSet<>();
        Map<Integer,Integer> map=new HashMap<>();
        for (Card card:hand){
            suitSet.add(card.suit);
            rankSet.add(card.rank);
            rankList.add(card.rank);

            if (map.containsKey(card.rank)){
                int count=map.get(card.rank);
                count++;
                map.put(card.rank,count);
            }
            else {
                map.put(card.rank,1);
            }
        }
        Collections.sort(rankList);
        boolean isStraight=false;
        boolean isSameColor=false;
        if(rankList.get(4)-rankList.get(0)==4&&rankSet.size()==5){
            isStraight=true;

        }
        if (suitSet.size()==1){
            isSameColor=true;

        }
        if (isStraight&&isSameColor){
            return "同花顺";
        }
        if (isStraight){
            return "顺子";
        }
        if (isSameColor){
            return "同花";
        }
        if (rankSet.size()==4){
            return "一对";
        }
        if (rankSet.size()==5){
            return "无对";
        }
        if (rankSet.size()==2){
            //3带2or4带1
            if (map.containsValue(4)){
                return "四条";
            }else {
                return "满堂红";
            }
        }
        if (rankSet.size()==3){
            //221or311
            if(map.containsValue(3)){
                return "三条";
            }
            else {
                return "两对";
            }
        }
        return "unknown";
    }
    public Card getOneCard(int index){
        return cards[index];
    }
}

主类

调用Poker类，猜测牌型

import java.util.List;

public class Main {
    public static void main(String[] args){
        Card card=new Card("红桃",3);
        //System.out.println(card);

        Poker poker=new Poker();
        poker.shuffle();
        poker.output();

        List<Card> hand =poker.getOneHand();
        //poker.output();
        for (Card card1:hand){
            System.out.print(card1+" ");
        }
        System.out.println();
        String type=poker.getType(hand);
        System.out.println(type);
    }
}

 二、凑牌型得分

• 同花顺——100分
• 四条——25
• 满堂红——10
• 同花——5
• 顺子——4
• 三条——3
• 两对——2
• 一对——0
• 无对——-1

设置倍数：1,2,3,4,5

输入示例：1 2（意为替换1、2位置的牌）

换牌：利用Map，删除相应位置，换成其余的牌

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

public class PokerGame {
    public static void main(String[] args) {

        Map<String,Integer> mapPrize=new HashMap<>();
        mapPrize.put("同花顺",100);
        mapPrize.put("四条",25);
        mapPrize.put("满堂红",10);
        mapPrize.put("同花",5);
        mapPrize.put("顺子",4);
        mapPrize.put("三条",3);
        mapPrize.put("两对",2);
        mapPrize.put("一对",0);
        mapPrize.put("无对",-1);



        int score=100;
        Poker poker=new Poker();
        Scanner scanner = new Scanner(System.in);
        while(score>0)
        {
            System.out.println("please input your bet");
            int times =scanner.nextInt();
            scanner.nextLine();

            score-=times;

            System.out.println("your score now is:"+score);
            List<Card> hand =poker.getOneHand();
            for (Card card:hand){
                System.out.println(card+" ");
            }
            System.out.println("please input card no you want to change(1-5用空格分割)\n,input enter key if you do not want to change any card,input quit to quit");

            String cmd = scanner.nextLine();
            if (cmd.equals("quit")){
                break;
            }
            else if (!cmd.equals("")){
                String[] arr=cmd.split(" ");
                for (int i=0;i< arr.length;i++){
                    int change_index=Integer.parseInt(arr[i]);
                    change_index--;
                    hand.remove(change_index);//删掉不想要的牌
                    Card tmp=poker.getOneCard(i+5);
                    hand.add(change_index,tmp);//该位置换成其余的新牌
                }
            }
            for (Card card:hand){
                System.out.println(card+" ");
            }

            String card_type=poker.getType(hand);
            System.out.println(card_type);
            int prize=mapPrize.get(card_type);
            System.out.println("prize is "+prize*times);
            score+=prize*times;
        }
    }
}