简易打扑克牌（原创）

package com.imooc;

/**
 * 扑克牌类 一张扑克牌由前缀和后缀组成，如：红桃K，则前缀：红桃，后缀：K 前缀和后缀都设置成整型类型，它们的值分别映射成两个String类型的数组
 * 方便比较两张牌的大小
 * 
 * @author jiuhu
 *
 */
public class Poker implements Comparable<Poker> {
    private int prefixId; // 前缀
    private int postfixId; // 后缀
    static final String[] prefixName = { "方块", "梅花", "红桃", "黑桃" };
    static final String[] postfixName = { "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A" };

    // 构造方法（有参）
    public Poker(int prefixId, int postfixId) {
        super();
        this.prefixId = prefixId;
        this.postfixId = postfixId;
    }

    // 获取前缀ID
    public int getPrefixId() {
        return prefixId;
    }

    // 获取后缀ID
    public int getPostfixId() {
        return postfixId;
    }

    // 覆写toString方法，返回一张扑克牌（字符串）
    @Override
    public String toString() {
        return prefixName[this.prefixId] + postfixName[this.postfixId];
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + postfixId;
        result = prime * result + prefixId;
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (!(obj instanceof Poker))
            return false;
        Poker other = (Poker) obj;
        if (postfixId != other.postfixId)
            return false;
        if (prefixId != other.prefixId)
            return false;
        return true;
    }

    @Override
    public int compareTo(Poker o) {
        // TODO Auto-generated method stub
        // 比较后缀
        if (this.getPostfixId() > o.getPostfixId()) {
            return 1;
        } else if (this.getPostfixId() < o.getPostfixId()) {
            return -1;
        } else {
            // 后缀一样，比较前缀
            if (this.getPrefixId() > o.getPrefixId()) {
                return 1;
            } else if (this.getPrefixId() < o.getPrefixId()) {
                return -1;
            } else {
                return 0;
            }
        }
    }

}

package com.imooc;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * 玩家：这里定义一个玩家具有的属性和功能
 * 
 * @author jiuhu
 *
 */
public class Player {
    private String id; // 玩家ID
    private String name; // 玩家姓名
    private List<Poker> pokersOfPlayer; // 玩家的手牌；
    // 构造方法

    public Player(String id, String name) {
        super();
        this.id = id;
        this.name = name;
        this.pokersOfPlayer = new ArrayList<>();
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<Poker> getPokerOfPlayer() {
        return pokersOfPlayer;
    }

    public void setPokerOfPlayer(List<Poker> pokerOfPlayer) {
        this.pokersOfPlayer = pokerOfPlayer;
    }

    // 玩家添加一张扑克牌
    public void add(Poker e) {
        this.pokersOfPlayer.add(e);
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((id == null) ? 0 : id.hashCode());
        return result;
    }

    @Override // 覆写equals方法，只判断玩家ID不能重复
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (!(obj instanceof Player))
            return false;
        Player other = (Player) obj;
        if (id == null) {
            if (other.id != null)
                return false;
        } else if (!id.equals(other.id))
            return false;
        return true;
    }

    @Override
    public String toString() {
        return  name + "[" + id + "]";
    }

    //对玩家的手牌进行排序
    public void sort(){
        Collections.sort(this.pokersOfPlayer); //自动调用Poker类中的compareTo方法
    }
}

package com.imooc;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.Scanner;

/**
 * 玩牌： 1.
 * 
 * @author jiuhu
 *
 */
public class PalyPoker {

    private List<Poker> producePokers; // 创建一副扑克牌
    private List<Player> players; // 所有玩家
    private static int playersCount;// 玩家人数
    private static int pokersCountOfPlayer;// 每位玩家的手牌数量
    private List<Poker> pokers; // 一副洗好的扑克牌
    // 构造方法

    public PalyPoker() {
        super();
        this.pokers = new ArrayList<Poker>();

        // 声明游戏规则
        this.rules();
        // 1.邀请玩家
        this.addPlayers();

        // 2.创建一副扑克牌，即要玩牌，首先得有牌
        this.producePokers();

        // 3.洗牌
        this.shuffle();

        // 显示洗牌后的扑克牌
        // this.show();

        // 4.发牌
        this.deal();

        // 5.显示赢家
        this.result();

        // 6.显示玩家的手牌
        this.showPokerOfPlayer();
    }

    // 游戏规则
    public void rules() {
        System.out.println("------------游戏规则------------");
        System.out.println("1.比较N名玩家手中的扑克牌，取各玩家手中点数");
        System.out.println("  最大的牌进行比较，点数大的赢.");
        System.out.println("2.若玩家手中点数最大的牌一样，则再按花色比较.");
        System.out.println("-------------------------------");
    }

    // 1.邀请玩家
    public void addPlayers() {
        Scanner input = new Scanner(System.in);
        String playerId; // 玩家ID
        String playerName;// 玩家姓名
        boolean flag = false;// 玩家ID是否存在的标识 false表示不存在ID true表示已存在ID
        int pokersSizes = Poker.prefixName.length * Poker.postfixName.length;// 一副扑克牌的数量
        this.players = new ArrayList<Player>(); // 初始化
        while (true) {
            System.out.println("请问有多少玩家参考打牌？");
            playersCount = input.nextInt();
            // 至少有两个玩家,最多有一副扑克牌数量的玩家
            if ((playersCount < 2) || (playersCount > pokersSizes)) {
                System.out.println("玩家不可以少于2人，且不可以多于" + pokersSizes + "人！");
                continue;
            } else {
                break;
            }
        }

        while (true) {
            // 致少每个玩家有一张牌，且玩家数*每个玩家的手牌不能大于一副扑克牌的数量
            System.out.println("请问每个玩家有多少手牌？");
            pokersCountOfPlayer = input.nextInt();
            if ((pokersCountOfPlayer < playersCount) || (pokersCountOfPlayer * playersCount > pokersSizes)) {
                System.out.println("每个玩家至少有一张手牌，且不可以多于" + pokersSizes + "张手牌！");
                continue;
            } else {
                break;
            }
        }

        for (int i = 0; i < playersCount; i++) {
            while (true) {
                System.out.print("请输入第" + (i + 1) + "玩家的ID：");
                playerId = input.next();
                for (Player player : players) {
                    if (player.getId().equals(playerId)) {
                        flag = true;
                        break;
                    }
                }
                if (flag) {// ID存在，继续输入ID
                    flag = false; // 标识重置
                    System.out.println("ID='" + playerId + "'的玩家已存在！请重新输入！！！");
                    continue;
                } else {
                    break; // ID不存在，退出while循环，继续输入玩家姓名
                }
            }
            System.out.print("请输入第" + (i + 1) + "玩家的姓名：");
            playerName = input.next();
            // 创建一个玩家
            Player player = new Player(playerId, playerName);
            this.players.add(player);// 添加玩家
            System.out.println("玩家：" + playerId + " " + playerName + "已添加！");
        }
        input.close();
    }

    // 2.创建一副扑克牌，即要玩牌，首先得有牌
    public void producePokers() {
        this.producePokers = new ArrayList<Poker>();
        int postfixSize = Poker.postfixName.length; // 后缀大小
        int prefixSize = Poker.prefixName.length; // 前缀大小
        // 产生一副扑克牌,有序，未打乱，相当于买了一副新的扑克牌
        for (int i = 0; i < prefixSize; i++) {
            for (int j = 0; j < postfixSize; j++) {
                this.producePokers.add(new Poker(i, j));
            }
        }
    }

    // 3.洗牌
    public void shuffle() {
        System.out.println("--------开始洗牌--------");
        Random random = new Random(); // 用于产生一个随机数
        // 遍历
        for (int i = 0; i < producePokers.size(); i++) {
            while (true) {
                int index = random.nextInt(producePokers.size()); // 随机数用于获取指定索引的一张扑克牌
                Poker newPoker = producePokers.get(index);
                if (this.pokers.contains(newPoker)) {
                    continue;
                } else {
                    this.pokers.add(newPoker);
                    break;
                }
            }
        }
        System.out.println("--------结束洗牌--------");
    }

    // 显示洗牌后的扑克牌情况
    public void show() {
        for (Poker other : pokers) {
            System.out.println(other.toString());
        }
    }

    // 4.发牌
    public void deal() {
        int k = 0;// 计算发牌数
        System.out.println("--------开始发牌--------");
        // 每位玩家的手牌数量
        for (int i = 0; i < pokersCountOfPlayer; i++) {
            // 玩家人数
            for (int j = 0; j < playersCount; j++) {
                // 玩家拿牌
                this.players.get(j).add(this.pokers.get(k));
                k++;
            }
        }
        System.out.println("--------结束发牌--------");

    }

    // 5.显示赢家
    public void result() {
        Poker maxPoker = new Poker(0, 0); // 最大的扑克牌 默认最小扑克牌
        Player winner = null;// 赢家

        // 找玩家最大的牌
        for (Player player : this.players) {
            // 对玩家的手牌进行排序
            player.sort();

            // 当前玩家的牌比maxPoker大
            if (player.getPokerOfPlayer().get(pokersCountOfPlayer - 1).compareTo(maxPoker) == 1) {
                maxPoker = player.getPokerOfPlayer().get(pokersCountOfPlayer - 1);
                winner = player;
            }
        }
        System.out.println("赢家：" + winner.toString() + " 最大的牌：" + maxPoker.toString());
    }

    // 6.显示玩家的手牌
    public void showPokerOfPlayer() {
        for (Player player : this.players) {
            System.out.print("玩家的手牌：" + player.toString() + " [");

            // 显示玩家的手牌
            for (Poker poker : player.getPokerOfPlayer()) {
                System.out.print(poker.toString() + " ");

            }
            System.out.println("]");
        }
    }

}

package com.imooc;

/*
 * 游戏规则：比较N名玩家手中的扑克牌，取各玩家手中点数最大的牌进行比较，点数大的赢；
 * 若玩家手中点数最大的牌相等，则再按花色比较。
 * 设计思路：Poker.java一张扑克牌 -> Player.java一位玩家 -> PlayPoker.java打牌 ->Test.java 测试效果
 * PlayPoker.java打牌的流程：
 * 1.邀请玩家，即创建玩家的序列
 * 2.创建一副扑克牌，即要玩牌，首先得有牌
 * 3.洗牌
 * 4.发牌
 * 5.显示赢家
 * 6.显示玩家的手牌
 * 注意：
 * 1.创建一张扑克牌Poker类,并重写compareTo方法，用于比较扑克牌的大小
 * 2.每个玩家都有牌，即玩家类具有一个扑克牌的集合属性pokersOfPlayer以及玩家添加扑克牌的方法add()
 * 
 */
public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        new PalyPoker();

    }

}

运行效果：