编写一个Java程序，实现纸牌“保皇”游戏的发牌

模拟保皇游戏开始的发牌过程。规则：4副扑克，5个玩家。1）有一个大王标记为皇上。每次发牌时，所发牌中有该大王的玩家是皇上。2）皇帝选择侍卫（也叫保儿、腿子，游戏过程中与皇帝一伙）：作为皇上的玩家从自己的牌中选择一张拥有相同三张（点数和花色都相同）的一张牌（不能是2、3、大小王），其他四个玩家中有这张牌的就是侍卫。例如，皇上有三个红桃5，其他四个玩家中有红桃5的玩家就是侍卫。特殊情况是：1）皇上有一套四张牌相同的点数的牌，皇帝可以自己做侍卫；2）皇帝没有满足要求的牌，无法获得侍卫。程序要求：程序启动后生成5个玩家，并自动给他们发牌。然后输出：1）皇帝和侍卫的名字及其手里的牌（每张牌输出为“花色”+“点数”，如红桃5，牌之间用“，”分割），并按照大王、小王、2、A、K、Q、J、10、9、8、7、6、5、4、3的顺序排列，相同点数但不同花色的牌要把相同花色的牌放在一起；2）那张作为侍卫所特有的牌（“花色”+“点数”）。如果无法得到侍卫，则程序输出相应的提示。例如，程序运行后输出如下的结果：

皇帝是：玩家1

皇帝的牌是：[皇上, 小王, 小王, 小王, 小王, 方片2, 黑桃2, 黑桃A, 黑桃A, 红桃A, 方片K, 梅花K, 黑桃K, 红桃K, 梅花Q, 梅花Q, 黑桃Q, 方片J, 方片J, 方片J, 红桃J, 梅花9, 黑桃9, 黑桃9, 方片8, 梅花8, 红桃8, 梅花7, 黑桃7, 黑桃7, 红桃7, 梅花6, 梅花6, 黑桃6, 黑桃6, 方片5, 梅花5, 黑桃5, 黑桃5, 梅花4, 梅花4, 梅花4, 方片3, 红桃3]

侍卫对应的牌是：方片J

侍卫是：玩家2

侍卫的牌是：[方片2, 黑桃2, 红桃2, 方片A, 方片K, 梅花K, 梅花K, 黑桃K, 红桃K, 红桃K, 黑桃Q, 红桃Q, 方片J, 方片10, 黑桃10, 红桃10, 红桃10, 红桃10, 方片9, 红桃9, 方片8, 梅花8, 梅花8, 黑桃8, 黑桃8, 黑桃8, 红桃8, 红桃8, 方片7, 黑桃7, 黑桃7, 方片6, 黑桃6, 黑桃5, 梅花4, 黑桃4, 红桃4, 红桃4, 方片3, 梅花3, 黑桃3, 红桃3, 红桃3]

import java.util.*;

public class Main
{
    public static void main(String[] args)
    {
        String[] s={"大王","小王","2","A","K","Q","J","10","9","8","7","6","5","4","3"};//大小
        String[] q={"方片","黑桃","红桃","梅花"};//花色
        Poker[] cards=new Poker[216];//所有纸牌的集合数组

        for(int i=0;i<8;i++)//生成大小王
        {
            if(i<4)
            {
                cards[i]=new Poker();
                cards[i].setValue(s[0]);
                cards[i].setSuit(q[0]);
                if(i==0)
                {
                    cards[i].setSuit("皇帝");//将一个大王设置为皇帝牌
                }
            }
            else
            {
                cards[i]=new Poker();
                cards[i].setValue(s[1]);
                cards[i].setSuit(q[0]);
            }
        }

        int count=8;//生成剩余牌
        for(int i=2;i<15;i++)
        {
            for(int m=0;m<4;m++)
            {
                for(int n=0;n<4;n++)
                {
                    if(count<216)
                    {
                        cards[count]=new Poker();
                        cards[count].setValue(s[i]);
                        cards[count].setSuit(q[m]);
                        count++;
                    }
                    else
                    {
                        break;
                    }
                }
            }
        }

//        System.out.println("--------输出洗牌前的扑克--------");
//        for(int k=0;k<cards.length;k++)
//        {
//            if(k<8)
//            {
//                System.out.print(cards[k].getSuit()+"-"+cards[k].getValue()+"  ");
//            }
//            if(k>=8)
//            {
//                System.out.print(cards[k].getSuit()+"-"+cards[k].getValue()+"  ");
//            }
//
//            if((k-7)%4==0)//换行
//            {
//                System.out.println();
//            }
//        }

        for(int i=0;i<216;i++)//洗牌算法
        {
            int a=(int)(Math.random()*216);
            if(!cards[i].equals(cards[a]))
            {
                Poker temp=cards[i];
                cards[i]=cards[a];
                cards[a]=temp;
            }
        }

//        System.out.println("--------输出洗牌后的扑克--------");
//        for(int k=0;k<cards.length;k++)
//        {
//            System.out.print(cards[k].getSuit()+"-"+cards[k].getValue()+"  ");
//            if((k-7)%4==0)//换行
//            {
//                System.out.println();
//            }
//        }

        Player[] players = new Player[5];//生成5位玩家
        for(int i=0;i<5;i++)
        {
            players[i]=new Player();
        }

        LinkedList<Poker>[] tempList = new LinkedList[5];//生成5个临时链表
        for(int i=0;i<5;i++)
        {
            tempList[i]=new LinkedList<Poker>();
        }

        for(int i=0;i<216;i++)//模拟真实情况发牌
        {
            tempList[i%5].add(cards[i]);
        }

        for(int i=0;i<5;i++)//将临时链表赋值给每位玩家，完成发牌步骤
        {
            players[i].setCards(tempList[i]);
        }

//        for(int i=0;i<5;i++)//输出每位玩家的牌
//        {
//            System.out.println(players[i].getCards());
//            System.out.println(players[i].getCards().size());
//        }

        for(int i=0;i<5;i++)//为每位玩家的牌进行排序
        {
            Collections.sort(players[i].getCards());
        }

//        System.out.println("===========排序分界线==========");
//        for(int i=0;i<5;i++)//输出每位玩家排序后的牌
//        {
//            System.out.println(players[i].getCards());
//            System.out.println(players[i].getCards().size());
//        }

        //查找皇帝玩家
        int kingnum=0;//皇帝玩家编号
        for(int i=0;i<5;i++)
        {
            if(players[i].getCards().contains(new Poker("大王","皇帝")))
            {
                kingnum=i;
            }
        }

        //查找保子牌
        boolean flag = false;//状态变量,没有保子为false
        count = 0;
        Poker p = players[kingnum].getCards().getFirst();//临时扑克对象
        Poker bzPoker = null;//保子牌对象
        for(int i=1;i<players[kingnum].getCards().size();i++)
        {
            if(p.equals(players[kingnum].getCards().get(i)))
            {
                count++;
            }
            else
            {
                count=1;
                p=players[kingnum].getCards().get(i);
            }
            if(count==4)
            {
                players[kingnum].setIdentity("既是皇帝也是保子");//将皇帝身份直接改为既是皇帝也是保子,跳出循环
                count=0;//当保子是皇帝自己时，将count计数器设置为0
                break;
            }
            else if (count==3)
            {
                bzPoker = p;
                flag = true;//必将产生保子，将状态变量设置为true
            }
        }

        //查找保子玩家
        int bznum=0;//保子玩家编号
        if(count!=0&&flag)
        {
            for(int i=0;i<5;i++)
            {
                if(i!=kingnum&&players[i].getCards().contains(bzPoker))
                {
                    bznum=i;
                    players[bznum].setIdentity("保子");
                    break;
                }
            }
        }

        //输出
        System.out.println("皇帝是：玩家"+(kingnum+1)+"\n");
        System.out.println("皇帝的牌是："+players[kingnum].getCards()+"\n");
        if(flag)
        {
            if(count==0)
            {
                System.out.println("侍卫是皇帝自己");
            }
            else
            {
                System.out.println("侍卫对应的牌是：" + bzPoker + "\n");
                System.out.println("侍卫是：玩家" + (bznum+1) + "\n");
                System.out.println("侍卫的牌是：" + players[bznum].getCards() + "\n");
            }
        }
        else
        {
            System.out.println("皇帝没有侍卫");
        }
    }
}


class Poker implements Comparable<Poker>
{
    private String value;
    private String suit;
    String[] s={"大王","小王","2","A","K","Q","J","10","9","8","7","6","5","4","3"};//大小
    String[] q={"皇帝","方片","黑桃","红桃","梅花"};//花色
    public Poker()
    {
        this.value = null;this.suit = null;
    }
    public Poker(String value, String suit)
    {
        this.value = value;
        this.suit = suit;
    }

    @Override
    public String toString()
    {
        if(Objects.equals(this.value, s[0]) || Objects.equals(this.value, s[1]))
        {
            if(Objects.equals(this.suit, q[0]))
            {
                return "皇上";
            }
            else
            {
                return this.value;
            }
        }
        else
        {
            return this.suit+this.value;
        }
    }
    public String getValue()
    {
        return value;
    }
    public void setValue(String value)
    {
         this.value = value;
    }
    public String getSuit()
    {
        return suit;
    }
    public void setSuit(String suit)
    {
        this.suit = suit;
    }

    public int compareTo(Poker o)//重写比较函数
    {
        int thisValueIndex = Arrays.asList(s).indexOf(this.value);
        int otherValueIndex = Arrays.asList(s).indexOf(o.value);
        int thisSuitIndex = Arrays.asList(q).indexOf(this.suit);
        int otherSuitIndex = Arrays.asList(q).indexOf(o.suit);

        if (thisValueIndex != otherValueIndex) // 如果值不同，则按照值的下标顺序排序。
        {
            return thisValueIndex - otherValueIndex;
        }
        else // 如果值相同，则按照花色的下标顺序排序。
        {
            return thisSuitIndex - otherSuitIndex;
        }
    }

    public boolean equals(Object o) //重写等价函数
    {
        if (this == o)
        {
            return true;
        }
        if (!(o instanceof Poker poker))
        {
            return false;
        }
        return Objects.equals(value, poker.value) && Objects.equals(suit, poker.suit);
    }
}

class Player
{
    private String identity;
    private LinkedList<Poker> cards;

    public Player()
    {
        this.identity = "平民";
        this.cards = null;
    }

    public String getIdentity()
    {
        return identity;
    }

    public void setIdentity(String identity)
    {
        this.identity = identity;
    }

    public LinkedList<Poker> getCards()
    {
        return cards;
    }

    public void setCards(LinkedList<Poker> cards)
    {
        this.cards = cards;
    }
}