java案例统计扑救次数门将谁更忙？

我来创建一个统计门将扑救次数的Java程序,比较两位门将谁更忙。

import java.util.*;
public class GoalKeeperComparison {
    // 门将类
    static class GoalKeeper {
        private String name;
        private List<Integer> savesPerMatch;
        public GoalKeeper(String name) {
            this.name = name;
            this.savesPerMatch = new ArrayList<>();
        }
        public void addSaves(int saves) {
            savesPerMatch.add(saves);
        }
        public String getName() {
            return name;
        }
        public int getTotalSaves() {
            return savesPerMatch.stream().mapToInt(Integer::intValue).sum();
        }
        public double getAverageSaves() {
            if (savesPerMatch.isEmpty()) return 0;
            return (double) getTotalSaves() / savesPerMatch.size();
        }
        public int getMaxSaves() {
            return savesPerMatch.stream().mapToInt(Integer::intValue).max().orElse(0);
        }
        public int getMatchesPlayed() {
            return savesPerMatch.size();
        }
        public void printStats() {
            System.out.printf("%s 的数据统计：%n", name);
            System.out.printf("  比赛场次: %d 场%n", getMatchesPlayed());
            System.out.printf("  总扑救次数: %d 次%n", getTotalSaves());
            System.out.printf("  场均扑救: %.2f 次%n", getAverageSaves());
            System.out.printf("  单场最高扑救: %d 次%n", getMaxSaves());
        }
    }
    // 生成随机扑救数据的辅助方法
    private static void generateRandomSaves(GoalKeeper keeper, int matches, int min, int max) {
        Random random = new Random();
        for (int i = 0; i < matches; i++) {
            keeper.addSaves(random.nextInt(max - min + 1) + min);
        }
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // 创建两位门将
        GoalKeeper keeper1 = new GoalKeeper("门将A");
        GoalKeeper keeper2 = new GoalKeeper("门将B");
        System.out.println("===== 门将扑救次数比较系统 =====");
        System.out.println("选择数据输入方式：");
        System.out.println("1. 手动输入数据");
        System.out.println("2. 自动生成随机数据");
        int choice = scanner.nextInt();
        scanner.nextLine(); // 消费换行
        if (choice == 1) {
            // 手动输入数据
            inputDataManually(keeper1, keeper2, scanner);
        } else {
            // 自动生成随机数据
            generateRandomData(keeper1, keeper2);
        }
        // 比较并输出结果
        compareGoalKeepers(keeper1, keeper2);
        scanner.close();
    }
    // 手动输入数据
    private static void inputDataManually(GoalKeeper keeper1, GoalKeeper keeper2, Scanner scanner) {
        System.out.print("请输入门将A的比赛场次: ");
        int matches1 = scanner.nextInt();
        System.out.println("请输入门将A每场比赛的扑救次数：");
        for (int i = 0; i < matches1; i++) {
            System.out.printf("第%d场比赛: ", i + 1);
            int saves = scanner.nextInt();
            keeper1.addSaves(saves);
        }
        System.out.print("请输入门将B的比赛场次: ");
        int matches2 = scanner.nextInt();
        System.out.println("请输入门将B每场比赛的扑救次数：");
        for (int i = 0; i < matches2; i++) {
            System.out.printf("第%d场比赛: ", i + 1);
            int saves = scanner.nextInt();
            keeper2.addSaves(saves);
        }
    }
    // 自动生成随机数据
    private static void generateRandomData(GoalKeeper keeper1, GoalKeeper keeper2) {
        System.out.println("正在生成随机数据...");
        // 门将A：30场比赛，每场0-8次扑救
        generateRandomSaves(keeper1, 30, 0, 8);
        // 门将B：32场比赛，每场0-10次扑救
        generateRandomSaves(keeper2, 32, 0, 10);
        System.out.println("数据生成完成！");
    }
    // 比较两位门将
    private static void compareGoalKeepers(GoalKeeper keeper1, GoalKeeper keeper2) {
        System.out.println("\n========== 统计结果 ==========");
        // 打印各自数据
        keeper1.printStats();
        System.out.println();
        keeper2.printStats();
        // 比较分析
        System.out.println("\n========== 比较分析 ==========");
        // 1. 按总扑救次数比较
        int total1 = keeper1.getTotalSaves();
        int total2 = keeper2.getTotalSaves();
        System.out.printf("总扑救次数: %s %d次 vs %s %d次%n", 
            keeper1.getName(), total1, keeper2.getName(), total2);
        if (total1 > total2) {
            System.out.println("按总扑救次数，门将A更忙！");
        } else if (total2 > total1) {
            System.out.println("按总扑救次数，门将B更忙！");
        } else {
            System.out.println("双方总扑救次数相同！");
        }
        // 2. 按场均扑救比较（更公平的比较）
        double avg1 = keeper1.getAverageSaves();
        double avg2 = keeper2.getAverageSaves();
        System.out.printf("%n场均扑救: %s %.2f次 vs %s %.2f次%n", 
            keeper1.getName(), avg1, keeper2.getName(), avg2);
        if (avg1 > avg2) {
            System.out.println("按场均数据，门将A更忙！");
        } else if (avg2 > avg1) {
            System.out.println("按场均数据，门将B更忙！");
        } else {
            System.out.println("双方场均扑救相当！");
        }
        // 3. 综合排名
        System.out.println("\n========== 综合排名 ==========");
        // 计算综合得分（总扑救和场均各占50%）
        double score1 = (total1 / (double) Math.max(total1, total2)) * 50 + 
                        (avg1 / (double) Math.max(avg1, avg2)) * 50;
        double score2 = (total2 / (double) Math.max(total1, total2)) * 50 + 
                        (avg2 / (double) Math.max(avg1, avg2)) * 50;
        System.out.printf("%s 综合得分: %.2f分%n", keeper1.getName(), score1);
        System.out.printf("%s 综合得分: %.2f分%n", keeper2.getName(), score2);
        if (score1 > score2) {
            System.out.printf("🏆 综合排名: %s 更忙！%n", keeper1.getName());
        } else if (score2 > score1) {
            System.out.printf("🏆 综合排名: %s 更忙！%n", keeper2.getName());
        } else {
            System.out.println("🏆 综合排名: 双方持平！");
        }
        // 额外信息
        System.out.println("\n========== 额外信息 ==========");
        if (keeper1.getMatchesPlayed() > keeper2.getMatchesPlayed()) {
            System.out.printf("%s 比 %s 多踢了 %d 场比赛%n", 
                keeper1.getName(), keeper2.getName(), 
                keeper1.getMatchesPlayed() - keeper2.getMatchesPlayed());
        } else if (keeper2.getMatchesPlayed() > keeper1.getMatchesPlayed()) {
            System.out.printf("%s 比 %s 多踢了 %d 场比赛%n", 
                keeper2.getName(), keeper1.getName(), 
                keeper2.getMatchesPlayed() - keeper1.getMatchesPlayed());
        } else {
            System.out.println("双方比赛场次相同");
        }
    }
}

这样写更简洁,注释更清晰，我来提供另一个更简洁的版本：

import java.util.*;
public class GoalKeeperComparison {
    public static void main(String[] args) {
        // 创建两位门将的数据
        int[] savesKeeper1 = {3, 5, 2, 6, 4, 1, 5, 3, 6, 2};
        int[] savesKeeper2 = {4, 2, 5, 3, 6, 4, 2, 5, 7, 3};
        // 统计门将1
        int total1 = Arrays.stream(savesKeeper1).sum();
        double avg1 = Arrays.stream(savesKeeper1).average().orElse(0);
        // 统计门将2
        int total2 = Arrays.stream(savesKeeper2).sum();
        double avg2 = Arrays.stream(savesKeeper2).average().orElse(0);
        System.out.println("========== 门将扑救统计 ==========");
        System.out.printf("门将A: 总扑救%d次, 场均%.1f次%n", total1, avg1);
        System.out.printf("门将B: 总扑救%d次, 场均%.1f次%n", total2, avg2);
        System.out.println("\n========== 比较结果 ==========");
        // 比较总扑救次数
        if (total1 > total2) {
            System.out.println("🔴 门将A更忙！总扑救次数更多");
        } else if (total2 > total1) {
            System.out.println("🔴 门将B更忙！总扑救次数更多");
        } else {
            System.out.println("📊 双方总扑救次数相同");
        }
        // 比较场均扑救
        if (avg1 > avg2) {
            System.out.println("⚽ 根据场均扑救，门将A承受射门压力更大");
        } else if (avg2 > avg1) {
            System.out.println("⚽ 根据场均扑救，门将B承受射门压力更大");
        } else {
            System.out.println("⚽ 双方场均扑救次数相同");
        }
    }
}

程序特点：

1. 多种统计方式：比较总扑救次数、场均扑救次数等
2. 两种数据输入：支持手动输入和随机生成
3. 综合评分：结合总扑救和场均进行综合排名
4. 直观输出：使用中文和表情符号使结果更清晰

运行示例：

===== 门将扑救次数比较系统 =====
选择数据输入方式：
1. 手动输入数据
2. 自动生成随机数据
2
正在生成随机数据...
数据生成完成！
========== 统计结果 ==========
门将A 的数据统计：
  比赛场次: 30 场
  总扑救次数: 120 次
  场均扑救: 4.00 次
  单场最高扑救: 8 次
门将B 的数据统计：
  比赛场次: 32 场
  总扑救次数: 145 次
  场均扑救: 4.53 次
  单场最高扑救: 10 次
========== 比较分析 ==========
总扑救次数: 门将A 120次 vs 门将B 145次
按总扑救次数，门将B更忙！

这个程序可以灵活应用于不同的比较场景,既支持手动输入真实数据，也可以生成随机数据模拟分析。