java案例统计冲刺跑次数谁更多？

本文目录导读：

1. 方案一：简单版（模拟数据）
2. 方案二：交互版（用户输入数据）
3. 方案三：对象导向完整版
4. 使用方法
5. 功能特点

我来给你设计一个Java程序来统计冲刺跑次数,通过模拟两位运动员的冲刺记录，比较谁跑得更多。

简单版（模拟数据）

import java.util.Random;
public class SprintCountCompare {
    // 运动员类
    static class Athlete {
        private String name;
        private int sprintCount;
        private Random random = new Random();
        public Athlete(String name) {
            this.name = name;
            this.sprintCount = 0;
        }
        // 模拟一次训练
        public void train() {
            // 每次训练随机1-5次冲刺
            int sprints = random.nextInt(5) + 1;
            sprintCount += sprints;
            System.out.println(name + " 完成训练，本次冲刺 " + sprints + " 次");
        }
        public int getSprintCount() {
            return sprintCount;
        }
        public String getName() {
            return name;
        }
    }
    public static void main(String[] args) {
        // 创建两位运动员
        Athlete player1 = new Athlete("小明");
        Athlete player2 = new Athlete("小红");
        // 模拟30天训练
        Random random = new Random();
        System.out.println("===== 30天训练记录 =====");
        for (int day = 1; day <= 30; day++) {
            System.out.println("\n第 " + day + " 天训练：");
            player1.train();
            player2.train();
        }
        // 统计数据
        System.out.println("\n===== 最终统计 =====");
        System.out.println(player1.getName() + " 总冲刺次数：" + player1.getSprintCount());
        System.out.println(player2.getName() + " 总冲刺次数：" + player2.getSprintCount());
        // 比较结果
        compareResult(player1, player2);
    }
    // 比较谁更多
    private static void compareResult(Athlete p1, Athlete p2) {
        int diff = p1.getSprintCount() - p2.getSprintCount();
        if (diff > 0) {
            System.out.println("🏆 " + p1.getName() + " 比 " + p2.getName() + " 多跑了 " + diff + " 次");
        } else if (diff < 0) {
            System.out.println("🏆 " + p2.getName() + " 比 " + p1.getName() + " 多跑了 " + Math.abs(diff) + " 次");
        } else {
            System.out.println("🤝 两人冲刺次数相同！");
        }
        // 按百分比统计
        int total = p1.getSprintCount() + p2.getSprintCount();
        double p1Percent = (double) p1.getSprintCount() / total * 100;
        double p2Percent = (double) p2.getSprintCount() / total * 100;
        System.out.printf("%s 占比: %.1f%%%n", p1.getName(), p1Percent);
        System.out.printf("%s 占比: %.1f%%%n", p2.getName(), p2Percent);
    }
}

交互版（用户输入数据）

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class SprintCompareInteractive {
    // 运动员数据类
    static class SprintRecord {
        private String athleteName;
        private List<Integer> sprintPerDay = new ArrayList<>();
        public SprintRecord(String name) {
            this.athleteName = name;
        }
        public void addSprints(int count) {
            sprintPerDay.add(count);
        }
        public int getTotalSprints() {
            return sprintPerDay.stream().mapToInt(Integer::intValue).sum();
        }
        public int getMaxSprintDay() {
            int max = 0;
            for (int count : sprintPerDay) {
                if (count > max) max = count;
            }
            return max;
        }
        public String getName() {
            return athleteName;
        }
        public List<Integer> getSprintPerDay() {
            return sprintPerDay;
        }
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("===== 冲刺跑次数统计系统 =====");
        System.out.print("请输入运动员A的姓名: ");
        String nameA = scanner.nextLine();
        System.out.print("请输入运动员B的姓名: ");
        String nameB = scanner.nextLine();
        SprintRecord playerA = new SprintRecord(nameA);
        SprintRecord playerB = new SprintRecord(nameB);
        System.out.print("请输入统计天数: ");
        int days = scanner.nextInt();
        // 输入每天的数据
        for (int day = 1; day <= days; day++) {
            System.out.println("\n第 " + day + " 天");
            System.out.print(nameA + " 冲刺次数: ");
            int countA = scanner.nextInt();
            System.out.print(nameB + " 冲刺次数: ");
            int countB = scanner.nextInt();
            playerA.addSprints(countA);
            playerB.addSprints(countB);
        }
        // 输出统计数据
        displayStatistics(playerA, playerB);
        scanner.close();
    }
    private static void displayStatistics(SprintRecord a, SprintRecord b) {
        System.out.println("\n========== 统计数据 ==========");
        // 每日次数对比
        System.out.println("\n每日冲刺次数对比:");
        System.out.println("日期\t" + a.getName() + "\t" + b.getName() + "\t领先者");
        List<Integer> daysA = a.getSprintPerDay();
        List<Integer> daysB = b.getSprintPerDay();
        for (int i = 0; i < daysA.size(); i++) {
            String leader;
            if (daysA.get(i) > daysB.get(i)) {
                leader = a.getName();
            } else if (daysA.get(i) < daysB.get(i)) {
                leader = b.getName();
            } else {
                leader = "平局";
            }
            System.out.println((i+1) + "\t" + daysA.get(i) + "\t" + daysB.get(i) + "\t" + leader);
        }
        // 总数据
        int totalA = a.getTotalSprints();
        int totalB = b.getTotalSprints();
        System.out.println("\n========== ==========");
        System.out.println(a.getName() + " 总冲刺次数: " + totalA);
        System.out.println(b.getName() + " 总冲刺次数: " + totalB);
        System.out.println(a.getName() + " 单日最高: " + a.getMaxSprintDay() + " 次");
        System.out.println(b.getName() + " 单日最高: " + b.getMaxSprintDay() + " 次");
        // 胜负判定
        int diff = totalA - totalB;
        if (diff > 0) {
            System.out.println("\n🏆 冠军: " + a.getName() + " (多 " + diff + " 次)");
        } else if (diff < 0) {
            System.out.println("\n🏆 冠军: " + b.getName() + " (多 " + Math.abs(diff) + " 次)");
        } else {
            System.out.println("\n🤝 双方平局!");
        }
        // 胜率统计
        System.out.println("\n获胜率分析:");
        int aWinDays = 0, bWinDays = 0, drawDays = 0;
        for (int i = 0; i < daysA.size(); i++) {
            if (daysA.get(i) > daysB.get(i)) aWinDays++;
            else if (daysA.get(i) < daysB.get(i)) bWinDays++;
            else drawDays++;
        }
        System.out.println(a.getName() + " 获胜天数: " + aWinDays + " 天");
        System.out.println(b.getName() + " 获胜天数: " + bWinDays + " 天");
        System.out.println("平局天数: " + drawDays + " 天");
    }
}

对象导向完整版

import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;
public class SprintChampionship {
    // 冲刺记录类
    static class SprintData {
        private int totalSprints;
        private int maxSprintsPerDay;
        private Map<Integer, Integer> dailyRecords = new TreeMap<>();
        public void addDailySprints(int day, int count) {
            totalSprints += count;
            dailyRecords.put(day, count);
            if (count > maxSprintsPerDay) {
                maxSprintsPerDay = count;
            }
        }
        public int getTotalSprints() { return totalSprints; }
        public int getMaxSprintsPerDay() { return maxSprintsPerDay; }
        public Map<Integer, Integer> getDailyRecords() { return dailyRecords; }
    }
    // 比赛结果类
    static class MatchResult {
        private String winner;
        private String loser;
        private int difference;
        private boolean isTie;
        public MatchResult(String winner, String loser, int difference, boolean isTie) {
            this.winner = winner;
            this.loser = loser;
            this.difference = difference;
            this.isTie = isTie;
        }
        public void display() {
            if (isTie) {
                System.out.println("🤝 平局！双方冲刺次数相同");
            } else {
                System.out.printf("🏆 %s 以 %d 次优势战胜 %s%n", winner, difference, loser);
            }
        }
    }
    public static void main(String[] args) {
        // 模拟数据
        Map<String, SprintData> athletes = new HashMap<>();
        athletes.put("运动员甲", new SprintData());
        athletes.put("运动员乙", new SprintData());
        // 模拟7天数据
        int[][] sampleData = {
            {10, 12},  // 第1天
            {15, 8},   // 第2天
            {12, 14},  // 第3天
            {8, 10},   // 第4天
            {18, 16},  // 第5天
            {20, 12},  // 第6天
            {15, 18}   // 第7天
        };
        // 填写数据
        for (int day = 0; day < sampleData.length; day++) {
            athletes.get("运动员甲").addDailySprints(day+1, sampleData[day][0]);
            athletes.get("运动员乙").addDailySprints(day+1, sampleData[day][1]);
        }
        // 统计对比
        System.out.println("========== 冲刺次数比赛数据分析 ==========\n");
        SprintData athleteA = athletes.get("运动员甲");
        SprintData athleteB = athletes.get("运动员乙");
        // 显示每日记录
        System.out.println("每日冲刺记录:");
        System.out.printf("%-6s %-12s %-12s %s%n", "日期", "运动员甲", "运动员乙", "领先者");
        Map<Integer, Integer> dayA = athleteA.getDailyRecords();
        Map<Integer, Integer> dayB = athleteB.getDailyRecords();
        int aWin = 0, bWin = 0, draw = 0;
        for (int day : dayA.keySet()) {
            int aCount = dayA.get(day);
            int bCount = dayB.get(day);
            String leader = aCount > bCount ? "甲" : (aCount < bCount ? "乙" : "平局");
            if (aCount > bCount) aWin++;
            else if (aCount < bCount) bWin++;
            else draw++;
            System.out.printf("%-6d %-12d %-12d %s%n", day, aCount, bCount, leader);
        }
        // 汇总数据
        int totalA = athleteA.getTotalSprints();
        int totalB = athleteB.getTotalSprints();
        System.out.println("\n========== 最终统计 ==========");
        System.out.printf("%-10s %-15s %-15s%n", "指标", "运动员甲", "运动员乙");
        System.out.printf("%-10s %-15d %-15d%n", "总次数", totalA, totalB);
        System.out.printf("%-10s %-15d %-15d%n", "单日最高", athleteA.getMaxSprintsPerDay(), athleteB.getMaxSprintsPerDay());
        System.out.printf("%-10s %-15d %-15d%n", "获胜天数", aWin, bWin);
        // 判定胜负
        System.out.println("\n========== 比赛结果 ==========");
        int difference = Math.abs(totalA - totalB);
        boolean isTie = totalA == totalB;
        MatchResult result;
        if (totalA > totalB) {
            result = new MatchResult("运动员甲", "运动员乙", difference, false);
        } else if (totalA < totalB) {
            result = new MatchResult("运动员乙", "运动员甲", difference, false);
        } else {
            result = new MatchResult("", "", 0, true);
        }
        result.display();
        // 统计效率
        System.out.println("\n========== 效率分析 ==========");
        double avgA = totalA / 7.0;
        double avgB = totalB / 7.0;
        System.out.printf("运动员甲平均每天: %.1f 次%n", avgA);
        System.out.printf("运动员乙平均每天: %.1f 次%n", avgB);
        System.out.printf("甲占总数比例: %.1f%%%n", (double)totalA/(totalA+totalB)*100);
        System.out.printf("乙占总数比例: %.1f%%%n", (double)totalB/(totalA+totalB)*100);
    }
}

使用方法

1. 方案一：直接运行，自动生成随机数据对比
2. 方案二：交互式输入，适合手动记录数据
3. 方案三：模拟数据演示，包含完整统计分析

功能特点

✅ 每日冲刺次数记录
✅ 总次数统计对比
✅ 单日最高纪录
✅ 每日胜负情况
✅ 获胜天数统计
✅ 百分比分析
✅ 结果可视化展示

选择适合你需要的版本,直接复制代码运行即可！