Q1: 完成一个“卡牌操作”的类-航电java题目

Q1: 完成一个“卡牌操作”的类

hdu Java练习题

题目要求：
以面向对象方式写一个“卡牌操作”类：CardOperator
具有以下功能（类似扑克的功能，具体解释见后续ppt）：
功能1：初始化卡牌，initialCards（）
功能2：显示卡牌（每13张牌换行） ，showCards（）
功能3：洗牌（将牌打乱），shuffleCards（）
功能4：对所有牌理牌（重新排序，按A-2-3-…-K排序），rankCards（）
功能5：发牌，将已经混排好的牌进行发牌，发指定数量的前N张牌， dealCards（）
功能6：展示所发的牌，将已经发好牌依次显示出来（每13张牌换行）， showDealCards（）
功能7：按斗地主方式对发出的牌理牌（从大到小排序，2最大）， rankCardsDDZ
功能8：按自定义方式对发出的牌理牌（先按花色（黑>红>方>草），再按牌值(相同花色内2最大)），rankCardsUDF（）

写一个主控程序：MainProcess类（包含main函数）
调用CardOperator完成各种卡牌操作
MainProcess类（直接copy下页中的代码即可）
输出结果如下页ppt所示

---

答案：

按如图所示建立java包和类：

1. CardOperator类：

package cn.edu.hdu.test3.problem1;

import java.util.*;

public class CardOperator {
    private int num_per_cards = 52; // 每副卡牌的数量
    private int cards_num; // 一共几副牌
    private int[][] cards; // 卡牌数组，例如3副牌，就是3*52的二维矩阵
    private int deal_cards_num; // 指定发牌的数量
    private int[] deal_cards; // 用于存储发出的牌

    public CardOperator(int user_input_cards_num) {
        // 接受用户指定的"几副牌"初始化成员变量
        this.cards_num = user_input_cards_num;
        this.cards = new int[this.cards_num][this.num_per_cards];
        initialCards();
    }

    public void initialCards() {
        // 每副牌都按照黑桃、红桃、方片、草花，A-K的顺序初始化
        // 即系统认定先是13张黑桃，再13张红桃A-K,再13张方片A-K,最后13张草花A-K
        for (int i = 0; i < cards_num; i++) {
            for (int j = 0; j < num_per_cards; j++) {
                cards[i][j] = j;
            }
        }
    }

    public void showCards() {
        // 依次显示每副牌的牌面
        for (int i = 0; i < cards_num; i++) {
            System.out.println("Deck " + (i + 1) + ":");
            for (int j = 0; j < num_per_cards; j++) {
                System.out.print(getCardType(cards[i][j]) + getCardValue(cards[i][j]) + " ");
            }
            System.out.println();
        }
    }

    public String getCardType(int card_info) {
        // 根据卡牌本身的信息计算花色
        String[] suits = {"♠", "♥", "♦", "♣"};
        return suits[card_info / 13];
    }

    public String getCardValue(int card_info) {
        // 根据卡牌本身的信息计算牌值
        String[] values = {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"};
        return values[card_info % 13];
    }

    public void shuffleCards() {
        // 对每副牌都打乱100次顺序
        Random rand = new Random();
        for (int i = 0; i < cards_num; i++) {
            for (int j = 0; j < 100; j++) {
                int idx1 = rand.nextInt(num_per_cards);
                int idx2 = rand.nextInt(num_per_cards);
                int temp = cards[i][idx1];
                cards[i][idx1] = cards[i][idx2];
                cards[i][idx2] = temp;
            }
        }
    }

    public void rankCards() {
        // 对每副牌进行一次快速排序，回到初始状态，即黑桃A-K,红桃A-K,方片A-K,草花A-K
        for (int i = 0; i < cards_num; i++) {
            quick_sort(cards[i], 0, num_per_cards - 1);
        }
    }

    public void dealCards(int user_input_deal_cards_num) {
        // 将牌发至deal_cards中
        this.deal_cards_num = user_input_deal_cards_num;
        this.deal_cards = new int[deal_cards_num];
        int dealt = 0;
        for (int i = 0; i < cards_num && dealt < deal_cards_num; i++) {
            for (int j = 0; j < num_per_cards && dealt < deal_cards_num; j++) {
                deal_cards[dealt++] = cards[i][j];
            }
        }
    }

    public void rankCardsDDZ() {
        // 按斗地主模式理牌，从大到小排序，2最大，A其次，K-Q-J-10-9-8-7-6-5-4-3
        Integer[] dealCardsWrapper = Arrays.stream(deal_cards).boxed().toArray(Integer[]::new);
        Arrays.sort(dealCardsWrapper, new Comparator<Integer>() {
            @Override
            public int compare(Integer card1, Integer card2) {
                int value1 = card1 % 13;
                int value2 = card2 % 13;
                // 2最大，A其次，其他按顺序
                if (value1 == 0) value1 = 13; // A
                else if (value1 == 1) value1 = 14; // 2
                if (value2 == 0) value2 = 13; // A
                else if (value2 == 1) value2 = 14; // 2
                return value2 - value1; // 从大到小排序
            }
        });
        deal_cards = Arrays.stream(dealCardsWrapper).mapToInt(Integer::intValue).toArray();
    }

    public void rankCardsUDF() {
        // 按自定义模式理牌，先按花色（黑>红>方>草），再按牌值(相同花色内2最大)
        Integer[] dealCardsWrapper = Arrays.stream(deal_cards).boxed().toArray(Integer[]::new);
        Arrays.sort(dealCardsWrapper, new Comparator<Integer>() {
            @Override
            public int compare(Integer card1, Integer card2) {
                int suit1 = card1 / 13;
                int suit2 = card2 / 13;
                if (suit1 != suit2) {
                    return suit1 - suit2; // 黑>红>方>草, suit1和suit2小的排前面
                } else {
                    int value1 = card1 % 13;
                    int value2 = card2 % 13;
                    // 2最大，A其次，其他按顺序
                    if (value1 == 0) value1 = 13; // A
                    else if (value1 == 1) value1 = 14; // 2
                    if (value2 == 0) value2 = 13; // A
                    else if (value2 == 1) value2 = 14; // 2
                    return value2 - value1; // 从大到小排序
                }
            }
        });
        deal_cards = Arrays.stream(dealCardsWrapper).mapToInt(Integer::intValue).toArray();
    }

    public void quick_sort(int[] array, int l, int r) {
        // 对牌面进行快速排序
        if (l < r) {
            int pivot = partition(array, l, r);
            quick_sort(array, l, pivot - 1);
            quick_sort(array, pivot + 1, r);
        }
    }

    private int partition(int[] array, int l, int r) {
        int pivot = array[l];
        int i = l, j = r;
        while (i < j) {
            while (i < j && array[j] >= pivot) j--;
            array[i] = array[j];
            while (i < j && array[i] <= pivot) i++;
            array[j] = array[i];
        }
        array[i] = pivot;
        return i;
    }

    public void showDealCards() {
        // 依次显示已发牌的牌面
        for (int i = 0; i < deal_cards_num; i++) {
            System.out.print(getCardType(deal_cards[i]) + getCardValue(deal_cards[i]) + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        CardOperator co = new CardOperator(3); // 3副牌
        co.showCards(); // 显示初始化的牌
        co.shuffleCards(); // 洗牌
        co.showCards(); // 显示洗牌后的牌
        co.dealCards(10); // 发10张牌
        co.showDealCards(); // 显示发出的牌
    }
}

2. MainProcess类：

package cn.edu.hdu.test3.problem1;

public class MainProcess {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        CardOperator co = new CardOperator(2); // 指定"1副牌"
        co.initialCards();

        System.out.println("卡牌初始化：");
        co.showCards();

        co.shuffleCards();
        System.out.println("卡牌洗牌后：");
        co.showCards();

        co.dealCards(26); // 指定发26张牌
        System.out.println("发牌后：");
        co.showDealCards();

        co.rankCardsDDZ();
        System.out.println("卡牌按斗地主模式理牌后：");
        co.showDealCards();

        co.rankCardsUDF();
        System.out.println("卡牌按自定义模式理牌后：");
        co.showDealCards();

        co.rankCards();
        System.out.println("所有卡牌理牌后：");
        co.showCards();
    }
}

运行截图：

博主是专业Java辅导，解决Java实验难题，Java大作业，靠谱细致，欢迎私信询问。