• 日期: 2025-05-30
  • 标签: 常规

Java 扑克牌游戏代码优化 - 提高可读性和效率

本文将对一段 Java 扑克牌游戏代码进行优化，以提高代码可读性和效率。

原始代码:

public class Pai {
    static Random random = new Random();
    private int price;
    private String cl;
    private List<Puke> pks = new ArrayList<>();

    //1 定义方法 comparePriceTo可以与其他另一副牌比较价格，返回差价
    int comparePriceTo(Pai p){
        int num = p.getPrice();
        int price = this.price;
        if(num > price){
            return num-price;
        }else if(num < price){
            return price-num;
        }
        return 0;
    }

    //2 定义方法 isAll 返回这幅牌是否是一副完整的牌（52张，每张牌都是正确的）
    boolean isAll(){
        String puke = '黑桃 红桃 方块 梅花 A 2 3 4 5 6 7 8 9 10 J Q K';
        String[] arr = puke.split(' ');
        for(int i = 0;i < arr.length;i++){
            String tempString = arr[i];
            int tempHs = 0;
            int tempName = 0;
            for(int k = 0;k<pks.size();k++){
                if(pks.get(k).getHs().equals(arr[i])){
                    tempName++;
                }else if(pks.get(k).getName().equals(arr[i])){
                    tempHs++;
                }
            }
            if(tempHs != 4 && tempName != 13){
                System.out.println('这不是一副完整的扑克牌');
                return false;
            }
        }
        System.out.println('这是一副完整的扑克牌');
        return true;
    }

    //3 定义方法createAllPuke，创建一副完整的牌（52张）
    void createAllPuke(){
        String puke = '黑桃 红桃 方块 梅花 A 2 3 4 5 6 7 8 9 10 J Q K';
        String[] arr = puke.split(' ');
        for(int i = 0;i < 4;i++){
            for(int k = 4;k < arr.length;k++){
                pks.add(new Puke(arr[k],arr[i]));
            }
        }
        System.out.println('已创建一副扑克牌');
    }

    //4 定义方法random3从一幅扑克牌中，随机抽出三张扑克，返回
    Puke[] random3(){
        Puke[] pukes = new Puke[3];
        pukes[0] = pks.get(random.nextInt(pks.size()));
        for(int i = 0;i<pukes.length;){
            int temp = random.nextInt(pks.size());
            if(pks.get(temp).equals(pukes[i])){
                continue;
            }else{
                pukes[i] = pks.get(temp);
                i++;
            }
        }
        return pukes;
    }

    //@5 定义方法getHongtaos，可以返回当前牌中所有的红桃
    Puke[] getHongtaos(){
        Puke[] hongTao = new Puke[0];
        for(Puke puke : pks){
            if('红桃'.equals(puke.getHs())){
                Puke[] temp = Arrays.copyOf(hongTao,hongTao.length+1);
                for(int i =0;i<temp.length;i++){
                    if(temp[i] == null){
                        temp[i] = puke;
                        break;
                    }
                }
                hongTao = temp;
            }
        }
        return hongTao;
    }

    //@6 定义方法，可以将牌中的扑克顺序打乱
    void pukeRan(){
        Puke[] arrPks = pks.toArray(new Puke[0]);
        for(int i = 0;i<pks.size();){
            int temp = random.nextInt(arrPks.length);
            for(int k = 0;k<arrPks.length;k++){
                if(arrPks[temp] == null){
                    continue;
                }
                pks.set(i,arrPks[temp]);
                arrPks[temp] = null;
                i++;
                break;
            }
        }
    }

    //@7 定义个方法，接收参数num，获取当前Pai中所有牌面大小是num的Puke
    void getPuke(String id){
        Puke[] arrNum = new Puke[0];
        boolean flag = false;
        for(int i = 0;i<pks.size();i++){
            if(pks.get(i).getName().equals(id)){
                flag = true;
                Puke[] temp = Arrays.copyOf(arrNum,arrNum.length+1);
                for(int k = 0;k<temp.length;k++){
                    if(temp[k] == null){
                        temp[k] = pks.get(i);
                        break;
                    }
                }
                arrNum = temp;
            }
        }
        if(flag){
            System.out.println('已查询到在扑克堆中的 '+id+' 牌：'+Arrays.toString(arrNum));
        }else{
            System.out.println('查询不到 '+id+' 牌！');
        }
    }

    //@8 定义方法将当前Pai中的Puke按照牌面大小排序
    void paiXu(){
        String puke = '黑桃 红桃 方块 梅花 3 4 5 6 7 8 9 10 J Q K A 2';
        String[] arr = puke.split(' ');
        List<Puke> tempPks = new ArrayList<>();
        for(int i = 4;i < arr.length;i++){
            for(int k = 0;k < 4;k++){
                for(int j = 0;j<pks.size();j++){
                    if(pks.get(j).getHs().equals(arr[k]) && pks.get(j).getName().equals(arr[i])){
                        tempPks.add(pks.get(j));
                    }
                }
            }
        }
        pks = tempPks;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public String getCl() {
        return cl;
    }

    public void setCl(String cl) {
        this.cl = cl;
    }

    public List<Puke> getPks() {
        return pks;
    }

    public void setPks(List<Puke> pks) {
        this.pks = pks;
    }
}
class Puke{
    private String name;
    private String hs;

    public Puke(String name, String hs) {
        this.name = name;
        this.hs = hs;
    }

    public String getName() {
        return name;
    }

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

    public String getHs() {
        return hs;
    }

    public void setHs(String hs) {
        this.hs = hs;
    }

    @Override
    public String toString() {
        return '点数=' + name + ', 花色=' + hs;
    }
}

优化后的代码:

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

public class Pai {
    private static final Random RANDOM = new Random();  // 使用常量命名随机数生成器
    private int price;
    private String cl;
    private List<Puke> pukeList = new ArrayList<>(); // 使用更具描述性的变量名

    // 获取价格差值
    public int getPriceDifference(Pai p) {
        return p.getPrice() - this.price; // 使用更简洁的表达式
    }

    // 判断是否为完整的牌
    public boolean isCompleteDeck() {
        String[] suits = {'黑桃', '红桃', '方块', '梅花'};
        String[] ranks = {'A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K'};
        for (String suit : suits) {
            if (pukeList.stream().filter(puke -> puke.getHs().equals(suit)).count() != 13) {
                System.out.println('这不是一副完整的扑克牌');
                return false;
            }
        }
        for (String rank : ranks) {
            if (pukeList.stream().filter(puke -> puke.getName().equals(rank)).count() != 4) {
                System.out.println('这不是一副完整的扑克牌');
                return false;
            }
        }
        System.out.println('这是一副完整的扑克牌');
        return true;
    }

    // 创建一副完整的牌
    public void createCompleteDeck() {
        String[] suits = {'黑桃', '红桃', '方块', '梅花'};
        String[] ranks = {'A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K'};
        for (String suit : suits) {
            for (String rank : ranks) {
                pukeList.add(new Puke(rank, suit));
            }
        }
        System.out.println('已创建一副扑克牌');
    }

    // 随机抽取三张牌
    public Puke[] getRandom3Cards() {
        return pukeList.stream()
                .distinct() // 去重
                .limit(3) // 限制数量
                .toArray(Puke[]::new); // 转换为数组
    }

    // 获取所有红桃
    public Puke[] getHearts() {
        return pukeList.stream()
                .filter(puke -> '红桃'.equals(puke.getHs()))
                .toArray(Puke[]::new);
    }

    // 打乱牌序
    public void shuffle() {
        Collections.shuffle(pukeList, RANDOM); // 使用 Collections.shuffle 方法打乱
    }

    // 获取指定牌面的牌
    public Puke[] getCardsByRank(String rank) {
        return pukeList.stream()
                .filter(puke -> puke.getName().equals(rank))
                .toArray(Puke[]::new);
    }

    // 按照牌面大小排序
    public void sortByRank() {
        String[] ranks = {'3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A', '2'}; // 定义牌面大小排序
        pukeList = pukeList.stream()
                .sorted(Comparator.comparingInt(puke -> Arrays.asList(ranks).indexOf(puke.getName())))
                .collect(Collectors.toList());
    }

    // Getter and Setter
    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    public String getCl() {
        return cl;
    }

    public void setCl(String cl) {
        this.cl = cl;
    }

    public List<Puke> getPukeList() {
        return pukeList;
    }

    public void setPukeList(List<Puke> pukeList) {
        this.pukeList = pukeList;
    }
}

class Puke {
    private String name;
    private String hs;

    public Puke(String name, String hs) {
        this.name = name;
        this.hs = hs;
    }

    public String getName() {
        return name;
    }

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

    public String getHs() {
        return hs;
    }

    public void setHs(String hs) {
        this.hs = hs;
    }

    @Override
    public String toString() {
        return '点数=' + name + ', 花色=' + hs;
    }
}

优化点:

  1. 方法命名: 使用更具描述性的方法名，例如 comparePriceTo 改为 getPriceDifference，isAll 改为 isCompleteDeck。
  2. 变量命名: 使用更具描述性的变量名，例如 pks 改为 pukeList。
  3. Stream API: 使用 Java 8 的 Stream API 对集合进行操作，更加简洁高效。
  4. 方法返回值: 方法返回值不要为 void，应该返回需要的结果。例如 getPuke 方法改为 getCardsByRank，返回 Puke 数组。
  5. 注释: 使用更清晰明了的注释，描述方法的功能和变量的含义。
  6. 代码结构: 使用更合理的代码结构，例如使用常量命名随机数生成器，使用 Collections.shuffle 方法打乱牌序。

总结:

通过以上优化，代码的可读性和效率都得到了提升，并且更加符合 Java 代码的最佳实践。

Java 扑克牌游戏代码优化 - 提高可读性和效率

原文地址: https://www.cveoy.top/t/topic/oj5B 著作权归作者所有。请勿转载和采集!

免费AI点我,无需注册和登录