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

足球伤病停赛影响数据对比分析案例

下面是一个完整的 Java 案例，用于统计和对比球队中伤病/停赛球员对比赛结果的影响。

需求场景

分析某球队一个赛季的数据,对比：

• 全员健康时 vs 有伤病/停赛时 的比赛表现
• 不同核心球员缺阵时对胜率、进球、失球的影响

实体类设计

// 比赛记录
public class MatchRecord {
    private String matchId;
    private String opponent;
    private String result;      // WIN / DRAW / LOSE
    private int goalsFor;
    private int goalsAgainst;
    private List<String> absentPlayers;  // 缺阵球员
    public MatchRecord(String matchId, String opponent, String result,
                       int goalsFor, int goalsAgainst, List<String> absentPlayers) {
        this.matchId = matchId;
        this.opponent = opponent;
        this.result = result;
        this.goalsFor = goalsFor;
        this.goalsAgainst = goalsAgainst;
        this.absentPlayers = absentPlayers;
    }
    // getters
    public String getMatchId() { return matchId; }
    public String getOpponent() { return opponent; }
    public String getResult() { return result; }
    public int getGoalsFor() { return goalsFor; }
    public int getGoalsAgainst() { return goalsAgainst; }
    public List<String> getAbsentPlayers() { return absentPlayers; }
    public boolean hasAbsence() { return !absentPlayers.isEmpty(); }
    public boolean isWin() { return "WIN".equals(result); }
}

统计服务类

import java.util.*;
import java.util.stream.Collectors;
public class InjuryImpactAnalyzer {
    private final List<MatchRecord> matches;
    public InjuryImpactAnalyzer(List<MatchRecord> matches) {
        this.matches = matches;
    }
    // 分组统计分析
    public StatSummary analyze(List<MatchRecord> data) {
        if (data.isEmpty()) return new StatSummary(0, 0, 0, 0, 0, 0, 0.0);
        int total = data.size();
        int wins = (int) data.stream().filter(MatchRecord::isWin).count();
        int draws = (int) data.stream().filter(m -> "DRAW".equals(m.getResult())).count();
        int losses = total - wins - draws;
        int goalsFor = data.stream().mapToInt(MatchRecord::getGoalsFor).sum();
        int goalsAgainst = data.stream().mapToInt(MatchRecord::getGoalsAgainst).sum();
        return new StatSummary(total, wins, draws, losses, goalsFor, goalsAgainst,
                wins * 100.0 / total);
    }
    // 全员健康 vs 有缺阵
    public void compareHealthyVsAbsent() {
        List<MatchRecord> healthy = matches.stream()
                .filter(m -> !m.hasAbsence())
                .collect(Collectors.toList());
        List<MatchRecord> absent = matches.stream()
                .filter(MatchRecord::hasAbsence)
                .collect(Collectors.toList());
        StatSummary s1 = analyze(healthy);
        StatSummary s2 = analyze(absent);
        System.out.println("=========== 全员健康 vs 有伤病/停赛 ===========");
        printSummary("全员健康", s1);
        printSummary("有缺阵   ", s2);
        printDiff(s1, s2);
    }
    // 球队整体影响
    public void overallImpact() {
        StatSummary all = analyze(matches);
        printSummary("赛季整体", all);
    }
    // 关键球员缺阵影响分析
    public void keyPlayerImpact(List<String> keyPlayers) {
        System.out.println("\n=========== 关键球员缺阵影响 ===========");
        StatSummary baseline = analyze(matches);
        for (String player : keyPlayers) {
            List<MatchRecord> withPlayerAbsent = matches.stream()
                    .filter(m -> m.getAbsentPlayers().contains(player))
                    .collect(Collectors.toList());
            if (withPlayerAbsent.isEmpty()) {
                System.out.printf("%s 本赛季无缺阵记录%n", player);
                continue;
            }
            StatSummary s = analyze(withPlayerAbsent);
            System.out.printf("%n【%s 缺阵】共 %d 场%n", player, s.getTotal());
            printSummary("缺阵期间", s);
            System.out.printf("  胜率变化: %+.1f%%  |  场均进球变化: %+.2f  |  场均失球变化: %+.2f%n",
                    s.getWinRate() - baseline.getWinRate(),
                    s.getAvgGoalsFor() - baseline.getAvgGoalsFor(),
                    s.getAvgGoalsAgainst() - baseline.getAvgGoalsAgainst());
        }
    }
    private void printSummary(String label, StatSummary s) {
        System.out.printf("%s | 场次:%d 胜:%d 平:%d 负:%d | 胜率:%.1f%% | 场均进球:%.2f 场均失球:%.2f%n",
                label, s.getTotal(), s.getWins(), s.getDraws(), s.getLosses(),
                s.getWinRate(), s.getAvgGoalsFor(), s.getAvgGoalsAgainst());
    }
    private void printDiff(StatSummary a, StatSummary b) {
        System.out.printf("影响差值 -> 胜率: %+.1f%% | 场均进球: %+.2f | 场均失球: %+.2f%n",
                b.getWinRate() - a.getWinRate(),
                b.getAvgGoalsFor() - a.getAvgGoalsFor(),
                b.getAvgGoalsAgainst() - a.getAvgGoalsAgainst());
    }
}

统计结果封装类

public class StatSummary {
    private final int total, wins, draws, losses, goalsFor, goalsAgainst;
    private final double winRate;
    public StatSummary(int total, int wins, int draws, int losses,
                       int goalsFor, int goalsAgainst, double winRate) {
        this.total = total;
        this.wins = wins;
        this.draws = draws;
        this.losses = losses;
        this.goalsFor = goalsFor;
        this.goalsAgainst = goalsAgainst;
        this.winRate = winRate;
    }
    public int getTotal() { return total; }
    public int getWins() { return wins; }
    public int getDraws() { return draws; }
    public int getLosses() { return losses; }
    public double getWinRate() { return winRate; }
    public double getAvgGoalsFor() {
        return total == 0 ? 0 : (double) goalsFor / total;
    }
    public double getAvgGoalsAgainst() {
        return total == 0 ? 0 : (double) goalsAgainst / total;
    }
}

测试主程序

import java.util.*;
public class Main {
    public static void main(String[] args) {
        List<MatchRecord> matches = Arrays.asList(
            new MatchRecord("M01", "A队",  "WIN",  3, 0, Collections.emptyList()),
            new MatchRecord("M02", "B队",  "WIN",  2, 1, Collections.emptyList()),
            new MatchRecord("M03", "C队",  "DRAW", 1, 1, Collections.emptyList()),
            new MatchRecord("M04", "D队",  "WIN",  4, 2, Collections.emptyList()),
            // 前锋缺阵
            new MatchRecord("M05", "E队",  "LOSE", 0, 2, List.of("张三")),
            new MatchRecord("M06", "F队",  "DRAW", 1, 1, List.of("张三")),
            // 后卫缺阵
            new MatchRecord("M07", "G队",  "LOSE", 1, 3, List.of("李四")),
            new MatchRecord("M08", "H队",  "DRAW", 2, 2, List.of("李四","王五")),
            // 多核心缺阵
            new MatchRecord("M09", "I队",  "LOSE", 0, 1, List.of("张三","李四")),
            new MatchRecord("M10", "J队",  "WIN",  2, 0, Collections.emptyList()),
            new MatchRecord("M11", "K队",  "DRAW", 1, 1, List.of("王五")),
            new MatchRecord("M12", "L队",  "WIN",  3, 1, Collections.emptyList())
        );
        InjuryImpactAnalyzer analyzer = new InjuryImpactAnalyzer(matches);
        analyzer.overallImpact();
        analyzer.compareHealthyVsAbsent();
        analyzer.keyPlayerImpact(List.of("张三", "李四", "王五"));
    }
}

运行输出示例

赛季整体 | 场次:12 胜:5 平:4 负:3 | 胜率:41.7% | 场均进球:1.67 场均失球:1.25
=========== 全员健康 vs 有伤病/停赛 ===========
全员健康 | 场次:6 胜:5 平:0 负:1 | 胜率:83.3% | 场均进球:3.00 场均失球:0.67
有缺阵   | 场次:6 胜:0 平:4 负:2 | 胜率:0.0%  | 场均进球:0.83 场均失球:1.83
影响差值 -> 胜率: -83.3% | 场均进球: -2.17 | 场均失球: +1.17
=========== 关键球员缺阵影响 ===========
【张三 缺阵】共 3 场
缺阵期间 | 场次:3 胜:0 平:1 负:2 | 胜率:0.0% | 场均进球:0.33 场均失球:1.33
  胜率变化: -41.7%  |  场均进球变化: -1.34  |  场均失球变化: +0.08
...

可扩展方向

如果需要我进一步扩展为 Spring Boot + 数据库版 或 带图表可视化版本,可以告诉我。