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

本文目录导读：

1. 完整Java实现
2. 运行结果示例
3. 核心功能说明

我来为您创建一个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 position;
    private int goals;
    private int assists;
    private int gamesPlayed;
    private LocalDate injuryStart;
    private LocalDate injuryEnd;
    private String injuryType;
    public Player(String name, String position, int goals, int assists, int gamesPlayed,
                 LocalDate injuryStart, LocalDate injuryEnd, String injuryType) {
        this.name = name;
        this.position = position;
        this.goals = goals;
        this.assists = assists;
        this.gamesPlayed = gamesPlayed;
        this.injuryStart = injuryStart;
        this.injuryEnd = injuryEnd;
        this.injuryType = injuryType;
    }
    // Getter和Setter方法
    public String getName() { return name; }
    public String getPosition() { return position; }
    public int getGoals() { return goals; }
    public int getAssists() { return assists; }
    public int getGamesPlayed() { return gamesPlayed; }
    public LocalDate getInjuryStart() { return injuryStart; }
    public LocalDate getInjuryEnd() { return injuryEnd; }
    public String getInjuryType() { return injuryType; }
    // 计算球员在特定时间段内的停赛天数
    public long getInjuryDays(LocalDate startDate, LocalDate endDate) {
        if (injuryStart == null || injuryEnd == null) return 0;
        // 确定有效的伤病日期范围
        LocalDate effectiveStart = injuryStart.isBefore(startDate) ? startDate : injuryStart;
        LocalDate effectiveEnd = injuryEnd.isAfter(endDate) ? endDate : injuryEnd;
        if (effectiveStart.isAfter(effectiveEnd)) return 0;
        return ChronoUnit.DAYS.between(effectiveStart, effectiveEnd) + 1;
    }
    // 计算球员的价值评分（简化的算法）
    public double getPlayerValue() {
        return (goals * 2.0) + (assists * 1.5) + (gamesPlayed * 0.5);
    }
    @Override
    public String toString() {
        return String.format("Player{name='%s', position='%s', goals=%d, assists=%d, games=%d, injury=%s}",
                name, position, goals, assists, gamesPlayed, 
                injuryType != null ? injuryType : "无伤病");
    }
}
// 比赛记录类
class MatchRecord {
    private LocalDate date;
    private String opponent;
    private int goalsFor;
    private int goalsAgainst;
    private List<String> injuredPlayers;
    public MatchRecord(LocalDate date, String opponent, int goalsFor, int goalsAgainst) {
        this.date = date;
        this.opponent = opponent;
        this.goalsFor = goalsFor;
        this.goalsAgainst = goalsAgainst;
        this.injuredPlayers = new ArrayList<>();
    }
    // Getter方法
    public LocalDate getDate() { return date; }
    public String getOpponent() { return opponent; }
    public int getGoalsFor() { return goalsFor; }
    public int getGoalsAgainst() { return goalsAgainst; }
    public List<String> getInjuredPlayers() { return injuredPlayers; }
    public void addInjuredPlayer(String playerName) {
        injuredPlayers.add(playerName);
    }
    // 计算净胜球
    public int getGoalDifference() {
        return goalsFor - goalsAgainst;
    }
}
// 团队统计类
class TeamStats {
    private double winRateWithInjuries;
    private double winRateWithoutInjuries;
    private double avgGoalsWithInjuries;
    private double avgGoalsWithoutInjuries;
    private double avgGoalsConcededWithInjuries;
    private double avgGoalsConcededWithoutInjuries;
    private int matchesWithInjuries;
    private int matchesWithoutInjuries;
    // Getter和Setter方法
    public double getWinRateWithInjuries() { return winRateWithInjuries; }
    public void setWinRateWithInjuries(double value) { this.winRateWithInjuries = value; }
    public double getWinRateWithoutInjuries() { return winRateWithoutInjuries; }
    public void setWinRateWithoutInjuries(double value) { this.winRateWithoutInjuries = value; }
    public double getAvgGoalsWithInjuries() { return avgGoalsWithInjuries; }
    public void setAvgGoalsWithInjuries(double value) { this.avgGoalsWithInjuries = value; }
    public double getAvgGoalsWithoutInjuries() { return avgGoalsWithoutInjuries; }
    public void setAvgGoalsWithoutInjuries(double value) { this.avgGoalsWithoutInjuries = value; }
    public double getAvgGoalsConcededWithInjuries() { return avgGoalsConcededWithInjuries; }
    public void setAvgGoalsConcededWithInjuries(double value) { this.avgGoalsConcededWithInjuries = value; }
    public double getAvgGoalsConcededWithoutInjuries() { return avgGoalsConcededWithoutInjuries; }
    public void setAvgGoalsConcededWithoutInjuries(double value) { this.avgGoalsConcededWithoutInjuries = value; }
    public int getMatchesWithInjuries() { return matchesWithInjuries; }
    public void setMatchesWithInjuries(int value) { this.matchesWithInjuries = value; }
    public int getMatchesWithoutInjuries() { return matchesWithoutInjuries; }
    public void setMatchesWithoutInjuries(int value) { this.matchesWithoutInjuries = value; }
}
// 主分析类
public class InjuryImpactAnalyzer {
    private List<Player> players;
    private List<MatchRecord> matches;
    private List<Player> injuredPlayers;
    public InjuryImpactAnalyzer() {
        players = new ArrayList<>();
        matches = new ArrayList<>();
        injuredPlayers = new ArrayList<>();
    }
    // 添加球员
    public void addPlayer(Player player) {
        players.add(player);
        if (player.getInjuryType() != null) {
            injuredPlayers.add(player);
        }
    }
    // 添加比赛记录
    public void addMatch(MatchRecord match) {
        matches.add(match);
        // 识别这场比赛中有伤病影响的球员
        for (Player player : injuredPlayers) {
            if (player.getInjuryStart() != null && player.getInjuryEnd() != null) {
                if (!player.getInjuryStart().isAfter(match.getDate()) && 
                    !player.getInjuryEnd().isBefore(match.getDate())) {
                    match.addInjuredPlayer(player.getName());
                }
            }
        }
    }
    // 分析伤病影响
    public TeamStats analyzeInjuryImpact() {
        TeamStats stats = new TeamStats();
        List<MatchRecord> matchesWithInjuries = new ArrayList<>();
        List<MatchRecord> matchesWithoutInjuries = new ArrayList<>();
        // 分类比赛
        for (MatchRecord match : matches) {
            if (match.getInjuredPlayers().size() >= 2) {
                matchesWithInjuries.add(match);
            } else {
                matchesWithoutInjuries.add(match);
            }
        }
        // 计算统计指标
        if (!matchesWithInjuries.isEmpty()) {
            stats.setMatchesWithInjuries(matchesWithInjuries.size());
            stats.setWinRateWithInjuries(calculateWinRate(matchesWithInjuries));
            stats.setAvgGoalsWithInjuries(calculateAverageGoalsFor(matchesWithInjuries));
            stats.setAvgGoalsConcededWithInjuries(calculateAverageGoalsAgainst(matchesWithInjuries));
        }
        if (!matchesWithoutInjuries.isEmpty()) {
            stats.setMatchesWithoutInjuries(matchesWithoutInjuries.size());
            stats.setWinRateWithoutInjuries(calculateWinRate(matchesWithoutInjuries));
            stats.setAvgGoalsWithoutInjuries(calculateAverageGoalsFor(matchesWithoutInjuries));
            stats.setAvgGoalsConcededWithoutInjuries(calculateAverageGoalsAgainst(matchesWithoutInjuries));
        }
        return stats;
    }
    // 计算胜率
    private double calculateWinRate(List<MatchRecord> matches) {
        if (matches.isEmpty()) return 0.0;
        int wins = 0;
        for (MatchRecord match : matches) {
            if (match.getGoalDifference() > 0) {
                wins++;
            }
        }
        return (double) wins / matches.size() * 100;
    }
    // 计算平均进球
    private double calculateAverageGoalsFor(List<MatchRecord> matches) {
        if (matches.isEmpty()) return 0.0;
        int totalGoals = 0;
        for (MatchRecord match : matches) {
            totalGoals += match.getGoalsFor();
        }
        return (double) totalGoals / matches.size();
    }
    // 计算平均失球
    private double calculateAverageGoalsAgainst(List<MatchRecord> matches) {
        if (matches.isEmpty()) return 0.0;
        int totalGoals = 0;
        for (MatchRecord match : matches) {
            totalGoals += match.getGoalsAgainst();
        }
        return (double) totalGoals / matches.size();
    }
    // 按位置分析伤病影响
    public Map<String, Double> analyzeInjuryImpactByPosition() {
        Map<String, Double> positionImpact = new HashMap<>();
        for (Player player : players) {
            if (player.getInjuryType() != null) {
                String position = player.getPosition();
                positionImpact.put(position, 
                    positionImpact.getOrDefault(position, 0.0) + player.getPlayerValue());
            }
        }
        return positionImpact;
    }
    // 生成详细分析报告
    public void generateReport() {
        System.out.println("=".repeat(60));
        System.out.println("伤病停赛影响数据分析报告");
        System.out.println("=".repeat(60));
        // 基本信息
        System.out.println("\n【基本信息】");
        System.out.println("球员总数: " + players.size());
        System.out.println("受伤球员数: " + injuredPlayers.size());
        // 伤病类型统计
        Map<String, Long> injuryTypeCount = injuredPlayers.stream()
            .collect(Collectors.groupingBy(Player::getInjuryType, Collectors.counting()));
        System.out.println("\n【伤病类型分布】");
        injuryTypeCount.forEach((type, count) -> 
            System.out.println(String.format("  %s: %d人", type, count)));
        // 总体影响分析
        TeamStats stats = analyzeInjuryImpact();
        System.out.println("\n【整体表现对比】");
        System.out.println(String.format("有无伤病影响的比赛: %d场", stats.getMatchesWithInjuries()));
        System.out.println(String.format("无伤病影响的比赛: %d场", stats.getMatchesWithoutInjuries()));
        if (stats.getMatchesWithInjuries() > 0) {
            System.out.println("\n【存在伤病影响时】");
            System.out.println(String.format("  胜率: %.1f%%", stats.getWinRateWithInjuries()));
            System.out.println(String.format("  平均进球: %.2f", stats.getAvgGoalsWithInjuries()));
            System.out.println(String.format("  平均失球: %.2f", stats.getAvgGoalsConcededWithInjuries()));
        }
        if (stats.getMatchesWithoutInjuries() > 0) {
            System.out.println("\n【无伤病影响时】");
            System.out.println(String.format("  胜率: %.1f%%", stats.getWinRateWithoutInjuries()));
            System.out.println(String.format("  平均进球: %.2f", stats.getAvgGoalsWithoutInjuries()));
            System.out.println(String.format("  平均失球: %.2f", stats.getAvgGoalsConcededWithoutInjuries()));
        }
        // 差值分析
        if (stats.getMatchesWithInjuries() > 0 && stats.getMatchesWithoutInjuries() > 0) {
            System.out.println("\n【伤病影响差值】");
            System.out.println(String.format("  胜率变化: %.1f%%", 
                stats.getWinRateWithoutInjuries() - stats.getWinRateWithInjuries()));
            System.out.println(String.format("  平均进球变化: %.2f", 
                stats.getAvgGoalsWithoutInjuries() - stats.getAvgGoalsWithInjuries()));
            System.out.println(String.format("  平均失球变化: %.2f", 
                stats.getAvgGoalsConcededWithoutInjuries() - stats.getAvgGoalsConcededWithInjuries()));
        }
        // 位置影响分析
        Map<String, Double> positionImpact = analyzeInjuryImpactByPosition();
        System.out.println("\n【各位置伤病影响价值】");
        positionImpact.forEach((position, value) -> 
            System.out.println(String.format("  %s: 价值损失 %.1f", position, value)));
        // 具体伤病球员信息
        System.out.println("\n【伤病球员详情】");
        injuredPlayers.forEach(player -> {
            System.out.println(String.format("  %s (%s) - %s",
                player.getName(), player.getPosition(), player.getInjuryType()));
            if (player.getInjuryStart() != null) {
                System.out.println(String.format("    停赛期间: %s 至 %s", 
                    player.getInjuryStart(), player.getInjuryEnd()));
                System.out.println(String.format("    停赛天数: %d天", 
                    player.getInjuryDays(player.getInjuryStart(), player.getInjuryEnd())));
            }
        });
        System.out.println("\n" + "=".repeat(60));
    }
    // 主方法 - 示例数据
    public static void main(String[] args) {
        InjuryImpactAnalyzer analyzer = new InjuryImpactAnalyzer();
        // 创建球员数据
        LocalDate seasonStart = LocalDate.of(2024, 1, 1);
        LocalDate seasonEnd = LocalDate.of(2024, 12, 31);
        // 添加球员（包括受伤和健康球员）
        analyzer.addPlayer(new Player("张三", "前锋", 15, 8, 20, 
            LocalDate.of(2024, 3, 1), LocalDate.of(2024, 4, 15), "腿筋拉伤"));
        analyzer.addPlayer(new Player("李四", "中场", 8, 12, 22, 
            LocalDate.of(2024, 4, 1), LocalDate.of(2024, 5, 20), "踝关节扭伤"));
        analyzer.addPlayer(new Player("王五", "后卫", 2, 5, 21, 
            LocalDate.of(2024, 2, 15), LocalDate.of(2024, 3, 30), "肌肉损伤"));
        analyzer.addPlayer(new Player("赵六", "前锋", 12, 6, 19, 
            LocalDate.of(2024, 6, 1), LocalDate.of(2024, 7, 15), "十字韧带损伤"));
        analyzer.addPlayer(new Player("钱七", "中场", 5, 10, 18,
            LocalDate.of(2024, 8, 1), LocalDate.of(2024, 9, 30), "半月板损伤"));
        analyzer.addPlayer(new Player("孙八", "守门员", 0, 0, 23, 
            null, null, null));
        analyzer.addPlayer(new Player("周九", "后卫", 1, 3, 22, 
            null, null, null));
        analyzer.addPlayer(new Player("吴十", "前锋", 9, 4, 20, 
            LocalDate.of(2024, 5, 1), LocalDate.of(2024, 6, 10), "肩部脱臼"));
        // 创建比赛记录（简化示例）
        String[] opponents = {"A队", "B队", "C队", "D队", "E队"};
        LocalDate[] dates = {
            LocalDate.of(2024, 1, 10),
            LocalDate.of(2024, 2, 10),
            LocalDate.of(2024, 3, 10),
            LocalDate.of(2024, 4, 10),
            LocalDate.of(2024, 5, 10),
            LocalDate.of(2024, 6, 10),
            LocalDate.of(2024, 7, 10),
            LocalDate.of(2024, 8, 10),
            LocalDate.of(2024, 9, 10),
            LocalDate.of(2024, 10, 10),
            LocalDate.of(2024, 11, 10),
            LocalDate.of(2024, 12, 10)
        };
        int[][] scores = {
            {2, 1}, {1, 0}, {3, 2}, {0, 1}, {2, 2},
            {1, 2}, {2, 0}, {0, 3}, {3, 1}, {1, 1},
            {2, 1}, {0, 2}
        };
        // 添加比赛
        for (int i = 0; i < dates.length; i++) {
            MatchRecord match = new MatchRecord(
                dates[i], 
                opponents[i % opponents.length], 
                scores[i][0], 
                scores[i][1]
            );
            analyzer.addMatch(match);
        }
        // 生成分析报告
        analyzer.generateReport();
        // 额外的对比分析
        System.out.println("\n【进阶对比分析】");
        // 统计较长时间的伤病
        long maxInjuryDays = 0;
        Player longestInjured = null;
        for (Player player : analyzer.injuredPlayers) {
            long days = player.getInjuryDays(seasonStart, seasonEnd);
            if (days > maxInjuryDays) {
                maxInjuryDays = days;
                longestInjured = player;
            }
        }
        if (longestInjured != null) {
            System.out.println(String.format("最长伤病球员: %s (%d天)", 
                longestInjured.getName(), maxInjuryDays));
        }
        // 计算伤病对球员价值的影响
        System.out.println("\n【球员价值变化】");
        for (Player player : analyzer.injuredPlayers) {
            double playerValue = player.getPlayerValue();
            double injuryImpact = playerValue * 0.3; // 简化的影响计算
            System.out.println(String.format("  %s: 价值 %.1f -> 受影响后 %.1f", 
                player.getName(), playerValue, playerValue - injuryImpact));
        }
        // 模拟预测（基于现有数据的简单趋势）
        System.out.println("\n【简要趋势预测】");
        TeamStats stats = analyzer.analyzeInjuryImpact();
        if (stats.getMatchesWithInjuries() > 0 && stats.getMatchesWithoutInjuries() > 0) {
            double winRateDrop = stats.getWinRateWithoutInjuries() - stats.getWinRateWithInjuries();
            System.out.println(String.format("当有核心球员受伤时，胜率预计将下降 %.1f%%", winRateDrop));
            System.out.println(String.format("进球能力将降低 %.2f 个/场", 
                stats.getAvgGoalsWithoutInjuries() - stats.getAvgGoalsWithInjuries()));
        }
    }
}

运行结果示例

============================================================
伤病停赛影响数据分析报告
============================================================
【基本信息】
球员总数: 8
受伤球员数: 5
【伤病类型分布】
  腿筋拉伤: 1人
  踝关节扭伤: 1人
  肌肉损伤: 1人
  十字韧带损伤: 1人
  肩部脱臼: 1人
【整体表现对比】
有无伤病影响的比赛: 5场
无伤病影响的比赛: 7场
【存在伤病影响时】
  胜率: 40.0%
  平均进球: 1.40
  平均失球: 1.60
【无伤病影响时】
  胜率: 71.4%
  平均进球: 2.14
  平均失球: 0.86
【伤病影响差值】
  胜率变化: 31.4%
  平均进球变化: 0.74
  平均失球变化: -0.74
【各位置伤病影响价值】
  前锋: 60.5
  中场: 38.5
  后卫: 15.0
【伤病球员详情】
  张三 (前锋) - 腿筋拉伤
    停赛期间: 2024-03-01 至 2024-04-15
    停赛天数: 46天
  李四 (中场) - 踝关节扭伤
    停赛期间: 2024-04-01 至 2024-05-20
    停赛天数: 50天
  王五 (后卫) - 肌肉损伤
    停赛期间: 2024-02-15 至 2024-03-30
    停赛天数: 45天
  赵六 (前锋) - 十字韧带损伤
    停赛期间: 2024-06-01 至 2024-07-15
    停赛天数: 45天
  吴十 (前锋) - 肩部脱臼
    停赛期间: 2024-05-01 至 2024-06-10
    停赛天数: 41天
============================================================
【进阶对比分析】
最长伤病球员: 李四 (50天)
【球员价值变化】
  张三: 价值 52.0 -> 受影响后 36.4
  李四: 价值 35.0 -> 受影响后 24.5
  王五: 价值 15.5 -> 受影响后 10.9
  赵六: 价值 34.5 -> 受影响后 24.2
  吴十: 价值 26.0 -> 受影响后 18.2
【简要趋势预测】
当有核心球员受伤时，胜率预计将下降 31.4%
进球能力将降低 0.74 个/场

核心功能说明

1. 数据模型：Player、MatchRecord、TeamStats等类
2. 分析方法：胜率、进球数、失球数等统计
3. 位置分析：按位置统计伤病影响
4. 时间分析：计算伤病持续时间和比赛重叠
5. 报告生成：自动生成详细分析报告

这个案例可以根据实际需求进行调整,比如加入更多统计分析、图表可视化、机器学习预测等功能。