2022年04月03日报告

2022年03月30日讲到了 Set集合,同志们

1. Collection工具类

可以用来操作 List集合, 这样更方便些

下面是 Collections类 里的一些方法:

public class CollectionsDemo {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(1);
        list.add(1);
        list.add(1);
        // 1. reverse()   对已有元素进行倒序排列
        Collections.reverse(list);

        // 2. shuffle()   对已有元素进行随机排列
        Collections.shuffle(list);
        System.out.println("随机排序:" + list);

        // 3. sort()      对已有元素进行升序排列
        Collections.sort(list);
        System.out.println("自然排序:" + list);

        // 4. sort(List list,Comparator comp)      按照指定顺序对已有元素进行排列
        list.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return -(o1.compareTo(o2));
            }
        });
        System.out.println("指定排序:" + list);

        // 5. swap()      将 list集合 中的指定元素交换位置
        Collections.swap(list, 0, 3);
        System.out.println("交换:" + list);

        // 6. rotate()    若 distance为正数,则将集合后的 distance个元素挪到前头,
        //                若 distance为负数, 则将集合前的 distance个元素挪到最后
        Collections.rotate(list,-3);
        System.out.println("挪动:"+list);

        // 7. frequency()     返回集合中 某个元素 出现的次数
        System.out.println(Collections.frequency(list,1));

        // 8. fill()      用一个元素 把集合中所有元素 都替换掉
        Collections.fill(list,10);
        System.out.println(list);

        // 9. replaceAll()    将集合中的 所有指定元素 换成另一个元素
        Collections.replaceAll(list,10,1);
        System.out.println(list);
    }
}

2. 纸牌练习

现在有一副扑克牌(除大小王)， {"♠","♥","♦","♣"}，{"1","2","3","4","5","6","7","8","9","10","J","Q","K"}，有四种花色，13个牌号。

进行一场扑克游戏，玩家数量控制在3-5人之内。为每个人分发5张扑克牌。

按照点数大小进行排序输出 只考虑点数。

最后 按照一个规则 给出玩家的得分

这个规则会写在卡牌管理类里

小编写了四个类 

第一个是卡牌类:

public class Poker {
    // 这里保存着 每张扑克牌的信息
    private String type;        // 卡牌花色
    private String point;       // 卡牌点数
    // 这里的 value 指的是 每张牌对应的 附加分数
    private Integer value;

    public Poker(String type, String point) {
        this.type = type;
        this.point = point;
    }

    // 小编在这里省略了 get和 set方法

    @Override
    public String toString() {
        return type+point;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Poker poker = (Poker) o;
        // 这里的 equals()方法 只会比对 value值
        // 也就是 两张牌 额外分数相等 就算它们一样了
        return Objects.equals(value, poker.value);
    }

    @Override
    public int hashCode() {
        return Objects.hash(value);
    }
}

第二个是玩家类:

public class User {
    //这里保存了玩家的信息
    private String name;        //玩家姓名
    private int point;          //玩家分数
    private List<Poker> pokers=new ArrayList<>();       //玩家持有的牌
   
    // 同样省略了 get和 set方法

    public User(String name) {
        this.name = name;
    }
    // toString() 打印玩家信息
    @Override
    public String toString() {
        return name+"\t"+pokers+"\t";
    }
}

第三个是卡牌管理类:

public class pokerManager {
    // 这个类里定义了 整理扑克牌 所需的方法
    public static void sort(List<Poker> pokers) {
        // 这个方法 用来给扑克牌 排序
        pokers.sort(new Comparator<Poker>() {
            @Override
            public int compare(Poker o1, Poker o2) {
                return o1.getValue().compareTo(o2.getValue());
            }
        });}

    public static boolean fre1(List<Poker> pokers, int fre) {
        // 如果 有一个扑克 出现的次数 等于输入的 fre,返回 true
        // 如果都没有 就返回 false
        for (int i = 0; i < pokers.size(); i++) {
            if (Collections.frequency(pokers, pokers.get(i)) == fre) {
                return true;
            } else if (i == pokers.size() - 1) {
                return false;}}
        return false;}

    public static int fre2(List<Poker> pokers, int fre) {
        // 这个方法 可以查找有多少种扑克 出现次数等于 fre
        int num = 0;
        for (int i = 0; i < pokers.size(); i++) {
            if (Collections.frequency(pokers, pokers.get(i)) == fre) {
                num++;
                if (fre != 1) {
                    i = i + fre;}}}
        return num;}

    public static Poker fre3(List<Poker> pokers, int f) {
        // 这个方法通过 扑克出现的频率 找到扑克对象
        // 并把 相同的扑克 删除
        int num = 0;
        for (int i = 0; i < pokers.size(); i++) {
            if (Collections.frequency(pokers, pokers.get(i)) == f) {
                if (f == 1) {
                    return pokers.remove(i);
                } else {
                    for (int j = i; j <= i + f - 1; j++) {
                        pokers.remove(j);
                        num++;
                        if (num == f - 1) {
                            return pokers.remove(j);
                        }
                        j--;}}}}
        return new Poker("", "");}

    public static boolean isQueue(List<Poker> pokers) {
        // 这个方法用来判断是否为顺子    1 2 3 4 5
        for (int i = 0; i < pokers.size() - 1; i++) {
            if (pokers.get(i).getValue() + 10 != pokers.get(i + 1).getValue()) {
                return false;
            } else if (i == pokers.size() - 2) {
                return true;}}
        return false;}

    public static int calculateScore(List<Poker> p) {
        // 这个方法 用来计算总分
        // 下面是判断 是否为顺子
        if (isQueue(p)) {
            return 10000;
        }
        // 下面是     1 1 1 1 4   ---   2 3 3 3 3    (一个四,一个单)
        if (fre1(p, 4)) {
            return 9000 + extraScore(fre3(p, 4), 4) + extraScore(fre3(p, 1), 1);
        }// 下面是    1 1 2 2 2   ---  1 1 1 2 2     (一个仨,一个对)
        else if (fre1(p, 3) && fre1(p, 2)) {
            return 8000 + fre3(p, 3).getValue() * 3 + fre3(p, 2).getValue() * 2;
        }// 下面是    1 1 1 2 3   ---   1 2 2 2 3  ---  1 2 3 3 3       (一个仨,两个单)
        else if (fre1(p, 3) && fre2(p, 1) == 2) {
            return 7000 + extraScore(fre3(p, 3), 3, fre3(p, 1), 1, fre3(p, 1), 1);
        }// 下面是    1 1 2 2 3   ---   1 2 2 3 3  ---  1 1 2 3 3        (两个对,一个单)
        else if (fre2(p, 2) == 2) {
            return 6000 + extraScore(fre3(p, 2), 2, fre3(p, 2), 2, fre3(p, 1), 1);
        }// 下面是    1 1 2 3 4   ---   1 2 2 3 4  ---  1 2 3 3 4  ---  1 2 3 4 4      (一个对,三个单)
        else if (fre2(p, 2) == 1 && fre2(p, 1) == 3) {
            return 5000 + extraScore(fre3(p, 2), 2, fre3(p, 1), 1, fre3(p, 1), 1, fre3(p, 1), 1);
        } else {
            return 4000;}}

    // 这些方法是 用来计算 额外分数的
    public static int extraScore(Poker poker, int fre) {
        return poker.getValue() * fre;
    }

    public static int extraScore(Poker p1, int f1, Poker p2, int f2, Poker p3, int f3) {
        return p1.getValue() * f1 + p2.getValue() * f2 + p3.getValue() * f3;
    }

    public static int extraScore(Poker p1, int f1, Poker p2, int f2, Poker p3, int f3, Poker p4, int f4) {
        return p1.getValue() * f1 + p2.getValue() * f2 + p3.getValue() * f3 + p4.getValue() * f4;}}

第四个是执行类:

public class run {
        // 这个类 用于最终的执行
    public static void main(String[] args) {
        // 创建 扑克牌集合
        List<Poker> pokers = new ArrayList<>(60);
        // 创建 玩家集合
        List<User> users = new ArrayList<>(10);

        String[] type = {"♠", "♥", "♦", "♣"};
        String[] point = {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"};
        // 将 扑克牌 放入集合中
        for (String element : type) {
            for (String s : point) {
                Poker poker = new Poker(element, s);
                // 为每张扑克牌 设置附加分数
                switch (poker.getPoint()) {
                    case "A":
                        poker.setValue(10);
                        break;
                    case "J":
                        poker.setValue(110);
                        break;
                    case "Q":
                        poker.setValue(120);
                        break;
                    case "K":
                        poker.setValue(130);
                        break;
                    default:
                        poker.setValue(Integer.parseInt(poker.getPoint()) * 10);
                        break;
                }
                pokers.add(poker);
            }
        }
        // 这里进行洗牌
        Collections.shuffle(pokers);
        // 将玩家们 放入集合
        User user1 = new User("杜老师");
        User user2 = new User("苏坡");
        User user3 = new User("小源");
        User user4 = new User("麦丝平方");
        User user5 = new User("酷爱ZERO");
        users.add(user1);
        users.add(user2);
        users.add(user3);
        users.add(user4);
        users.add(user5);
        // 给玩家发牌
        int num = 0;
        for (User item : users) {
            List<Poker> pokers1 = new ArrayList<>();
            for (int i = num; i < num + 5; i++) {
                pokers1.add(pokers.get(i));
            }
            item.setPokers(pokers1);
            num = num + 5;
        }
        // 将 玩家手中的牌 排好顺序
        for (User value : users) {
            pokerManager.sort(value.getPokers());
        }
        // 最后的打印输出
        for (User user : users) {
            // 这里 计算分数的方法 要放在打印信息的后面
            System.out.print(user + "\t");
            user.setPoint(pokerManager.calculateScore(user.getPokers()));
            System.out.println(user.getPoint());
        }
        System.out.println();
    }
}

最终的输出:

THE EHD≯(๑° . °๑)≮