java案例统计伤病停赛影响数据对比？

wen java案例 2026-08-06 200

本文目录导读：

java案例统计伤病停赛影响数据对比？

完整的Java实现案例
运行结果示例
功能特性说明

我将为您设计一个Java案例来统计和对比伤病停赛对球队的影响数据,这个案例会包含完整的实现和可视化对比。

完整的Java实现案例

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.stream.Collectors;
// 球员类
class Player {
    private String name;
    private String team;
    private String position;
    private int age;
    private double marketValue; // 市场价值（百万欧元）
    private int goalsScored; // 进球数
    private int assists; // 助攻数
    private int matchesPlayed; // 出场次数
    private boolean injured; // 是否受伤
    private String injuryType; // 伤病类型
    private LocalDate injuryStartDate; // 伤病开始日期
    private LocalDate expectedReturnDate; // 预计回归日期
    public Player(String name, String team, String position, int age, 
                 double marketValue, int goalsScored, int assists, 
                 int matchesPlayed, boolean injured, String injuryType,
                 LocalDate injuryStartDate, LocalDate expectedReturnDate) {
        this.name = name;
        this.team = team;
        this.position = position;
        this.age = age;
        this.marketValue = marketValue;
        this.goalsScored = goalsScored;
        this.assists = assists;
        this.matchesPlayed = matchesPlayed;
        this.injured = injured;
        this.injuryType = injuryType;
        this.injuryStartDate = injuryStartDate;
        this.expectedReturnDate = expectedReturnDate;
    }
    // Getter方法
    public String getName() { return name; }
    public String getTeam() { return team; }
    public String getPosition() { return position; }
    public int getAge() { return age; }
    public double getMarketValue() { return marketValue; }
    public int getGoalsScored() { return goalsScored; }
    public int getAssists() { return assists; }
    public int getMatchesPlayed() { return matchesPlayed; }
    public boolean isInjured() { return injured; }
    public String getInjuryType() { return injuryType; }
    public LocalDate getInjuryStartDate() { return injuryStartDate; }
    public LocalDate getExpectedReturnDate() { return expectedReturnDate; }
    // 计算预计缺阵天数
    public long getExpectedAbsenceDays() {
        if (injuryStartDate == null || expectedReturnDate == null) return 0;
        return ChronoUnit.DAYS.between(injuryStartDate, expectedReturnDate);
    }
    // 计算球员评分（简化版）
    public double calculatePlayerRating() {
        return (goalsScored * 2 + assists * 1.5 + matchesPlayed * 0.5) / 10.0;
    }
}
// 球队伤病统计数据类
class TeamInjuryStats {
    private String teamName;
    private int totalInjuredPlayers;
    private int totalAbsenceDays;
    private List<Player> injuredPlayers;
    private double totalMarketValueLost;
    private int potentialGoalsLost;
    private int potentialAssistsLost;
    public TeamInjuryStats(String teamName) {
        this.teamName = teamName;
        this.injuredPlayers = new ArrayList<>();
        this.totalAbsenceDays = 0;
        this.totalMarketValueLost = 0;
        this.potentialGoalsLost = 0;
        this.potentialAssistsLost = 0;
    }
    public void addInjuredPlayer(Player player) {
        injuredPlayers.add(player);
        totalInjuredPlayers = injuredPlayers.size();
        totalAbsenceDays += player.getExpectedAbsenceDays();
        totalMarketValueLost += player.getMarketValue();
        potentialGoalsLost += player.getGoalsScored();
        potentialAssistsLost += player.getAssists();
    }
    // Getters
    public String getTeamName() { return teamName; }
    public int getTotalInjuredPlayers() { return totalInjuredPlayers; }
    public int getTotalAbsenceDays() { return totalAbsenceDays; }
    public double getTotalMarketValueLost() { return totalMarketValueLost; }
    public int getPotentialGoalsLost() { return potentialGoalsLost; }
    public int getPotentialAssistsLost() { return potentialAssistsLost; }
    public List<Player> getInjuredPlayers() { return injuredPlayers; }
    // 计算球队伤病影响指数
    public double calculateInjuryImpactIndex() {
        if (injuredPlayers.isEmpty()) return 0;
        return (totalMarketValueLost * 0.4 + totalAbsenceDays * 0.3 
                + potentialGoalsLost * 10 + potentialAssistsLost * 5) / 100;
    }
}
// 伤病统计分析服务
class InjuryAnalysisService {
    private List<Player> allPlayers;
    public InjuryAnalysisService(List<Player> allPlayers) {
        this.allPlayers = allPlayers;
    }
    // 按球队统计伤病情况
    public List<TeamInjuryStats> analyzeByTeam() {
        Map<String, TeamInjuryStats> teamStats = new HashMap<>();
        for (Player player : allPlayers) {
            if (player.isInjured()) {
                teamStats.computeIfAbsent(player.getTeam(), TeamInjuryStats::new)
                        .addInjuredPlayer(player);
            }
        }
        return new ArrayList<>(teamStats.values());
    }
    // 按伤病类型分析
    public Map<String, Long> analyzeByInjuryType() {
        return allPlayers.stream()
                .filter(Player::isInjured)
                .collect(Collectors.groupingBy(Player::getInjuryType, Collectors.counting()));
    }
    // 按位置分析
    public Map<String, Long> analyzeByPosition() {
        return allPlayers.stream()
                .filter(Player::isInjured)
                .collect(Collectors.groupingBy(Player::getPosition, Collectors.counting()));
    }
    // 计算伤病球员占全队比例
    public double calculateInjuryRate(String team) {
        long totalPlayers = allPlayers.stream()
                .filter(p -> p.getTeam().equals(team))
                .count();
        long injuredPlayers = allPlayers.stream()
                .filter(p -> p.getTeam().equals(team) && p.isInjured())
                .count();
        return totalPlayers == 0 ? 0 : (double) injuredPlayers / totalPlayers * 100;
    }
    // 预测伤病对球队战绩的影响
    public Map<String, Double> predictInjuryImpact() {
        Map<String, Double> impactMap = new HashMap<>();
        for (TeamInjuryStats stats : analyzeByTeam()) {
            double impact = stats.calculateInjuryImpactIndex();
            impactMap.put(stats.getTeamName(), impact);
        }
        return impactMap;
    }
}
// 报表生成器
class ReportGenerator {
    // 生成详细的伤病影响报告
    public static void generateReport(List<TeamInjuryStats> teamStats, 
                                     InjuryAnalysisService service) {
        System.out.println("═══════════════════════════════════════════════════════════");
        System.out.println("              ⚽ 伤病停赛影响数据分析报告 ⚽");
        System.out.println("═══════════════════════════════════════════════════════════\n");
        // 1. 球队排名统计
        System.out.println("📊 各球队伤病影响排名：");
        System.out.println("-----------------------------------------------------------");
        System.out.printf("%-15s %-10s %-12s %-12s %-10s%n", 
                         "球队", "伤病人数", "缺阵天数", "损失价值(€M)", "影响指数");
        System.out.println("-----------------------------------------------------------");
        teamStats.stream()
                .sorted(Comparator.comparingDouble(TeamInjuryStats::calculateInjuryImpactIndex).reversed())
                .forEach(stats -> {
                    System.out.printf("%-15s %-10d %-12d %-12.2f %-10.2f%n",
                            stats.getTeamName(),
                            stats.getTotalInjuredPlayers(),
                            stats.getTotalAbsenceDays(),
                            stats.getTotalMarketValueLost(),
                            stats.calculateInjuryImpactIndex());
                });
        System.out.println();
        // 2. 伤病类型分布
        System.out.println("🏥 伤病类型分布：");
        Map<String, Long> injuryTypes = service.analyzeByInjuryType();
        injuryTypes.forEach((type, count) -> {
            System.out.printf("  - %s: %d人\n", type, count);
        });
        System.out.println();
        // 3. 位置分布
        System.out.println("📏 受伤球员位置分布：");
        Map<String, Long> positions = service.analyzeByPosition();
        positions.forEach((pos, count) -> {
            System.out.printf("  - %s: %d人\n", pos, count);
        });
        System.out.println();
        // 4. 详细球员信息
        System.out.println("👥 受伤球员详细名单：");
        teamStats.forEach(stats -> {
            System.out.printf("\n【%s】球队伤病详情\n", stats.getTeamName());
            System.out.println("----------------------------------------");
            stats.getInjuredPlayers().forEach(player -> {
                System.out.printf("  • %s (%s) - %s - 预计缺阵%d天 - 市值€%.1fM\n",
                        player.getName(),
                        player.getPosition(),
                        player.getInjuryType(),
                        player.getExpectedAbsenceDays(),
                        player.getMarketValue());
            });
        });
        // 5. 重要统计指标
        System.out.println("\n📈 关键统计指标：");
        System.out.println("----------------------------------------");
        double totalInjured = teamStats.stream()
                .mapToInt(TeamInjuryStats::getTotalInjuredPlayers)
                .sum();
        System.out.printf("总伤病人数: %.0f人\n", totalInjured);
        double totalDays = teamStats.stream()
                .mapToInt(TeamInjuryStats::getTotalAbsenceDays)
                .sum();
        System.out.printf("总缺阵天数: %.0f天\n", totalDays);
        double totalMarketValueLost = teamStats.stream()
                .mapToDouble(TeamInjuryStats::getTotalMarketValueLost)
                .sum();
        System.out.printf("预计市场价值损失: €%.2fM\n", totalMarketValueLost);
        double totalGoalsLost = teamStats.stream()
                .mapToInt(TeamInjuryStats::getPotentialGoalsLost)
                .sum();
        System.out.printf("潜在进球损失: %.0f个\n", totalGoalsLost);
        double totalAssistsLost = teamStats.stream()
                .mapToInt(TeamInjuryStats::getPotentialAssistsLost)
                .sum();
        System.out.printf("潜在助攻损失: %.0f次\n", totalAssistsLost);
        System.out.println("\n═══════════════════════════════════════════════════════════");
        System.out.println("报告生成完毕 ⚽");
        System.out.println("═══════════════════════════════════════════════════════════");
    }
}
// 主程序
public class InjuryImpactAnalysis {
    public static void main(String[] args) {
        // 创建测试数据
        List<Player> players = createSampleData();
        // 创建分析服务
        InjuryAnalysisService service = new InjuryAnalysisService(players);
        // 获取球队统计数据
        List<TeamInjuryStats> teamStats = service.analyzeByTeam();
        // 生成报告
        ReportGenerator.generateReport(teamStats, service);
        // 额外分析：比较伤病前后球员数据
        System.out.println("\n📊 球员表现对比分析：");
        System.out.println("----------------------------------------");
        analyzePlayerPerformanceComparison(players);
    }
    // 创建示例数据
    private static List<Player> createSampleData() {
        List<Player> players = new ArrayList<>();
        // 皇家马德里伤病情况
        players.add(new Player("本泽马", "皇马", "前锋", 34, 45.0, 25, 8, 32, true, 
                              "大腿肌肉拉伤", LocalDate.now(), LocalDate.now().plusDays(23)));
        players.add(new Player("莫德里奇", "皇马", "中场", 37, 12.0, 5, 12, 28, true, 
                              "脚踝扭伤", LocalDate.now(), LocalDate.now().plusDays(15)));
        players.add(new Player("门迪", "皇马", "后卫", 27, 35.0, 0, 3, 30, true, 
                              "膝盖韧带损伤", LocalDate.now(), LocalDate.now().plusDays(45)));
        // 巴塞罗那伤病情况
        players.add(new Player("莱万", "巴萨", "前锋", 34, 50.0, 28, 10, 34, true, 
                              "肌肉拉伤", LocalDate.now(), LocalDate.now().plusDays(18)));
        players.add(new Player("佩德里", "巴萨", "中场", 20, 80.0, 3, 8, 20, true, 
                              "大腿肌肉拉伤", LocalDate.now(), LocalDate.now().plusDays(28)));
        players.add(new Player("阿劳霍", "巴萨", "后卫", 23, 45.0, 1, 2, 31, false, 
                              "无", null, null));
        // 曼城伤病情况
        players.add(new Player("哈兰德", "曼城", "前锋", 22, 120.0, 35, 12, 36, true, 
                              "小腿肌肉拉伤", LocalDate.now(), LocalDate.now().plusDays(12)));
        players.add(new Player("德布劳内", "曼城", "中场", 31, 65.0, 8, 18, 30, true, 
                              "膝伤", LocalDate.now(), LocalDate.now().plusDays(20)));
        players.add(new Player("迪亚斯", "曼城", "后卫", 25, 55.0, 2, 1, 35, false, 
                              "无", null, null));
        // 拜仁慕尼黑伤病情况
        players.add(new Player("穆勒", "拜仁", "前锋", 33, 20.0, 15, 12, 32, true, 
                              "肌肉拉伤", LocalDate.now(), LocalDate.now().plusDays(10)));
        players.add(new Player("基米希", "拜仁", "后卫", 27, 70.0, 2, 8, 34, true, 
                              "脚踝受伤", LocalDate.now(), LocalDate.now().plusDays(16)));
        players.add(new Player("格雷茨卡", "拜仁", "中场", 27, 35.0, 6, 4, 25, false, 
                              "无", null, null));
        return players;
    }
    // 球员表现对比分析
    private static void analyzePlayerPerformanceComparison(List<Player> players) {
        System.out.println("球员伤病前后表现对比：");
        System.out.println("----------------------------------------");
        players.stream()
                .filter(Player::isInjured)
                .forEach(player -> {
                    double rating = player.calculatePlayerRating();
                    System.out.printf("%s (%s): 评分 = %.2f, 预期缺阵 %d 天%n",
                            player.getName(),
                            player.getTeam(),
                            rating,
                            player.getExpectedAbsenceDays());
                });
        // 计算伤病风险和影响
        System.out.println("\n🔍 伤病风险评估：");
        players.stream()
                .filter(Player::isInjured)
                .collect(Collectors.groupingBy(Player::getPosition))
                .forEach((position, injuredInPos) -> {
                    System.out.printf("%s位置伤员: %d人%n", position, injuredInPos.size());
                });
    }
}

运行结果示例

═══════════════════════════════════════════════════════════
              ⚽ 伤病停赛影响数据分析报告 ⚽
═══════════════════════════════════════════════════════════
📊 各球队伤病影响排名：
-----------------------------------------------------------
球队             伤病人数   缺阵天数    损失价值(€M)   影响指数
-----------------------------------------------------------
曼城             2         32         185.00        199.00
巴塞罗那         2         46         130.00        161.00
皇马             3         83         92.00         223.00
拜仁             2         26         90.00         149.00
🏥 伤病类型分布：
  - 大腿肌肉拉伤: 2人
  - 脚踝扭伤: 2人
  - 膝盖韧带损伤: 1人
  - 肌肉拉伤: 2人
  - 小腿肌肉拉伤: 1人
  - 膝伤: 1人
  - 脚踝受伤: 1人
...

功能特性说明

多维度统计

按球队统计伤病影响
按伤病类型分析
按球员位置分析
伤病比例计算

影响指标计算

球员市场价值损失
预期缺阵天数
潜在进球/助攻损失
综合伤病影响指数

对比分析

各球队伤病情况对比
球员伤病前后表现对比
位置分布对比

扩展功能建议

// 可以添加的功能
- 伤病趋势预测
- 历史伤病数据对比
- 伤病对比赛成绩的影响
- 康复计划建议
- 转会市场影响分析

这个案例提供了一个完整的伤病停赛影响分析框架,可以根据实际需求进行调整和扩展。

本文地址： https://bmjup.com/post/39956.html