java案例统计赛季累计数据对比如何？

本文目录导读：

1. 基础数据模型
2. 统计服务类
3. 数据可视化辅助类
4. 主程序示例
5. 进阶功能（可选）
6. 主要功能特点：

我来为您提供一个Java案例，展示赛季累计数据对比的功能实现，这个案例将包含球队/球员赛季数据的统计和对比分析。

基础数据模型

import java.time.LocalDate;
import java.util.*;
import java.util.stream.Collectors;
// 比赛数据模型
class MatchData {
    private LocalDate date;
    private String opponent;
    private int points;
    private int rebounds;
    private int assists;
    private int steals;
    private int blocks;
    private int turnovers;
    private int minutes;
    private boolean isHome;
    private boolean isWin;
    public MatchData(LocalDate date, String opponent, int points, int rebounds, 
                    int assists, int steals, int blocks, int turnovers, 
                    int minutes, boolean isHome, boolean isWin) {
        this.date = date;
        this.opponent = opponent;
        this.points = points;
        this.rebounds = rebounds;
        this.assists = assists;
        this.steals = steals;
        this.blocks = blocks;
        this.turnovers = turnovers;
        this.minutes = minutes;
        this.isHome = isHome;
        this.isWin = isWin;
    }
    // Getters and Setters
    public LocalDate getDate() { return date; }
    public String getOpponent() { return opponent; }
    public int getPoints() { return points; }
    public int getRebounds() { return rebounds; }
    public int getAssists() { return assists; }
    public int getSteals() { return steals; }
    public int getBlocks() { return blocks; }
    public int getTurnovers() { return turnovers; }
    public int getMinutes() { return minutes; }
    public boolean isHome() { return isHome; }
    public boolean isWin() { return isWin; }
}
// 赛季统计汇总类
class SeasonStats {
    private String season;
    private int gamesPlayed;
    private int wins;
    private int losses;
    private double avgPoints;
    private double avgRebounds;
    private double avgAssists;
    private double avgSteals;
    private double avgBlocks;
    private double avgTurnovers;
    private double avgMinutes;
    private double fieldGoalPercentage;
    private double threePointPercentage;
    // 构造函数和getter/setter
    public SeasonStats(String season) {
        this.season = season;
    }
    // Getters and Setters
    public String getSeason() { return season; }
    public int getGamesPlayed() { return gamesPlayed; }
    public int getWins() { return wins; }
    public int getLosses() { return losses; }
    public double getAvgPoints() { return avgPoints; }
    public double getAvgRebounds() { return avgRebounds; }
    public double getAvgAssists() { return avgAssists; }
    public double getAvgSteals() { return avgSteals; }
    public double getAvgBlocks() { return avgBlocks; }
    public double getAvgTurnovers() { return avgTurnovers; }
    public double getAvgMinutes() { return avgMinutes; }
    public double getFieldGoalPercentage() { return fieldGoalPercentage; }
    public double getThreePointPercentage() { return threePointPercentage; }
    public void setGamesPlayed(int gamesPlayed) { this.gamesPlayed = gamesPlayed; }
    public void setWins(int wins) { this.wins = wins; }
    public void setLosses(int losses) { this.losses = losses; }
    public void setAvgPoints(double avgPoints) { this.avgPoints = avgPoints; }
    public void setAvgRebounds(double avgRebounds) { this.avgRebounds = avgRebounds; }
    public void setAvgAssists(double avgAssists) { this.avgAssists = avgAssists; }
    public void setAvgSteals(double avgSteals) { this.avgSteals = avgSteals; }
    public void setAvgBlocks(double avgBlocks) { this.avgBlocks = avgBlocks; }
    public void setAvgTurnovers(double avgTurnovers) { this.avgTurnovers = avgTurnovers; }
    public void setAvgMinutes(double avgMinutes) { this.avgMinutes = avgMinutes; }
    public void setFieldGoalPercentage(double fieldGoalPercentage) { this.fieldGoalPercentage = fieldGoalPercentage; }
    public void setThreePointPercentage(double threePointPercentage) { this.threePointPercentage = threePointPercentage; }
}
// 球员类
class Player {
    private String name;
    private String team;
    private String position;
    private List<MatchData> matches;
    public Player(String name, String team, String position) {
        this.name = name;
        this.team = team;
        this.position = position;
        this.matches = new ArrayList<>();
    }
    public void addMatch(MatchData match) {
        matches.add(match);
    }
    public List<MatchData> getMatches() { return matches; }
    public String getName() { return name; }
    public String getTeam() { return team; }
    public String getPosition() { return position; }
}

统计服务类

// 统计服务类
class SeasonStatsService {
    // 计算赛季累计数据
    public SeasonStats calculateSeasonStats(List<MatchData> matches, String season) {
        SeasonStats stats = new SeasonStats(season);
        if (matches.isEmpty()) {
            return stats;
        }
        int totalPoints = 0;
        int totalRebounds = 0;
        int totalAssists = 0;
        int totalSteals = 0;
        int totalBlocks = 0;
        int totalTurnovers = 0;
        int totalMinutes = 0;
        int wins = 0;
        for (MatchData match : matches) {
            totalPoints += match.getPoints();
            totalRebounds += match.getRebounds();
            totalAssists += match.getAssists();
            totalSteals += match.getSteals();
            totalBlocks += match.getBlocks();
            totalTurnovers += match.getTurnovers();
            totalMinutes += match.getMinutes();
            if (match.isWin()) {
                wins++;
            }
        }
        int games = matches.size();
        stats.setGamesPlayed(games);
        stats.setWins(wins);
        stats.setLosses(games - wins);
        stats.setAvgPoints(roundToTwo(totalPoints / (double) games));
        stats.setAvgRebounds(roundToTwo(totalRebounds / (double) games));
        stats.setAvgAssists(roundToTwo(totalAssists / (double) games));
        stats.setAvgSteals(roundToTwo(totalSteals / (double) games));
        stats.setAvgBlocks(roundToTwo(totalBlocks / (double) games));
        stats.setAvgTurnovers(roundToTwo(totalTurnovers / (double) games));
        stats.setAvgMinutes(roundToTwo(totalMinutes / (double) games));
        return stats;
    }
    // 对比两个赛季的数据
    public Map<String, Double> compareSeasons(SeasonStats season1, SeasonStats season2) {
        Map<String, Double> differences = new HashMap<>();
        differences.put("gamesPlayedDiff", (double)(season2.getGamesPlayed() - season1.getGamesPlayed()));
        differences.put("winsDiff", (double)(season2.getWins() - season1.getWins()));
        differences.put("lossesDiff", (double)(season2.getLosses() - season1.getLosses()));
        differences.put("avgPointsDiff", roundToTwo(season2.getAvgPoints() - season1.getAvgPoints()));
        differences.put("avgReboundsDiff", roundToTwo(season2.getAvgRebounds() - season1.getAvgRebounds()));
        differences.put("avgAssistsDiff", roundToTwo(season2.getAvgAssists() - season1.getAvgAssists()));
        differences.put("avgStealsDiff", roundToTwo(season2.getAvgSteals() - season1.getAvgSteals()));
        differences.put("avgBlocksDiff", roundToTwo(season2.getAvgBlocks() - season1.getAvgBlocks()));
        differences.put("avgTurnoversDiff", roundToTwo(season2.getAvgTurnovers() - season1.getAvgTurnovers()));
        differences.put("avgMinutesDiff", roundToTwo(season2.getAvgMinutes() - season1.getAvgMinutes()));
        return differences;
    }
    // 生成对比报告
    public String generateComparisonReport(SeasonStats season1, SeasonStats season2) {
        StringBuilder report = new StringBuilder();
        report.append("========== 赛季数据对比报告 ==========\n\n");
        report.append(String.format("%-15s %-15s %-15s %-15s\n", "指标", season1.getSeason(), season2.getSeason(), "变化"));
        report.append("----------------------------------------\n");
        appendRow(report, "出场场次", season1.getGamesPlayed(), season2.getGamesPlayed());
        appendRow(report, "胜场", season1.getWins(), season2.getWins());
        appendRow(report, "负场", season1.getLosses(), season2.getLosses());
        appendRow(report, "场均得分", season1.getAvgPoints(), season2.getAvgPoints());
        appendRow(report, "场均篮板", season1.getAvgRebounds(), season2.getAvgRebounds());
        appendRow(report, "场均助攻", season1.getAvgAssists(), season2.getAvgAssists());
        appendRow(report, "场均抢断", season1.getAvgSteals(), season2.getAvgSteals());
        appendRow(report, "场均盖帽", season1.getAvgBlocks(), season2.getAvgBlocks());
        appendRow(report, "场均失误", season1.getAvgTurnovers(), season2.getAvgTurnovers());
        appendRow(report, "场均上场时间", season1.getAvgMinutes(), season2.getAvgMinutes());
        return report.toString();
    }
    private void appendRow(StringBuilder sb, String label, double value1, double value2) {
        double diff = roundToTwo(value2 - value1);
        String arrow = diff > 0 ? "↑" : (diff < 0 ? "↓" : "→");
        sb.append(String.format("%-15s %-15.2f %-15.2f %-15.2f %s\n", 
                label, value1, value2, Math.abs(diff), arrow));
    }
    // 按月份统计月度表现
    public Map<String, SeasonStats> calculateMonthlyStats(List<MatchData> matches, String season) {
        Map<String, List<MatchData>> monthlyMatches = matches.stream()
            .collect(Collectors.groupingBy(m -> m.getDate().getMonth().toString()));
        Map<String, SeasonStats> monthlyStats = new HashMap<>();
        for (Map.Entry<String, List<MatchData>> entry : monthlyMatches.entrySet()) {
            String month = entry.getKey();
            List<MatchData> monthMatches = entry.getValue();
            monthlyStats.put(month, calculateSeasonStats(monthMatches, season + "-" + month));
        }
        return monthlyStats;
    }
    // 分析趋势
    public String analyzeTrend(List<MatchData> matches, String season) {
        StringBuilder trend = new StringBuilder();
        trend.append("赛季趋势分析 (").append(season).append("):\n");
        // 按月份分析得分趋势
        Map<String, List<MatchData>> monthlyMatches = matches.stream()
            .collect(Collectors.groupingBy(m -> m.getDate().getMonth().toString()));
        double previousAvg = 0;
        boolean first = true;
        for (Map.Entry<String, List<MatchData>> entry : monthlyMatches.entrySet()) {
            SeasonStats stats = calculateSeasonStats(entry.getValue(), entry.getKey());
            double avgPoints = stats.getAvgPoints();
            if (!first) {
                double change = avgPoints - previousAvg;
                String trendArrow = change > 0 ? "上升" : (change < 0 ? "下降" : "持平");
                trend.append(String.format("%s: 场均%.1f分 (%s%+.1f分)\n", 
                        entry.getKey(), avgPoints, trendArrow, change));
            } else {
                trend.append(String.format("%s: 场均%.1f分 (基准)\n", entry.getKey(), avgPoints));
                first = false;
            }
            previousAvg = avgPoints;
        }
        return trend.toString();
    }
    private double roundToTwo(double value) {
        return Math.round(value * 100.0) / 100.0;
    }
}

数据可视化辅助类

// 可视化辅助类
class StatsVisualizer {
    // 生成简单的ASCII柱状图
    public void printBarChart(Map<String, Double> data, String title) {
        System.out.println(title);
        System.out.println("----------------------");
        double maxValue = data.values().stream().max(Double::compare).orElse(1.0);
        int maxBarLength = 50;
        for (Map.Entry<String, Double> entry : data.entrySet()) {
            int barLength = (int)((entry.getValue() / maxValue) * maxBarLength);
            String bar = "█".repeat(barLength);
            System.out.printf("%-20s %s %.2f\n", entry.getKey(), bar, entry.getValue());
        }
        System.out.println();
    }
    // 打印赛季对比表格
    public void printComparisonTable(Player player) {
        SeasonStatsService service = new SeasonStatsService();
        // 假设有多个赛季的数据
        Map<String, List<MatchData>> seasonMatches = getSeasonMatches(player);
        System.out.println("\n🏀 " + player.getName() + " - 赛季表现对比");
        System.out.println("位置: " + player.getPosition() + " | 球队: " + player.getTeam());
        // 为示例创建一个简单的表格
        String[] metrics = {"得分", "篮板", "助攻", "抢断", "盖帽"};
        System.out.printf("%-10s", "赛季");
        for (String metric : metrics) {
            System.out.printf("%12s", metric);
        }
        System.out.println();
        System.out.println("-".repeat(70));
        for (Map.Entry<String, List<MatchData>> entry : seasonMatches.entrySet()) {
            SeasonStats stats = service.calculateSeasonStats(entry.getValue(), entry.getKey());
            System.out.printf("%-10s", entry.getKey());
            System.out.printf("%12.1f", stats.getAvgPoints());
            System.out.printf("%12.1f", stats.getAvgRebounds());
            System.out.printf("%12.1f", stats.getAvgAssists());
            System.out.printf("%12.1f", stats.getAvgSteals());
            System.out.printf("%12.1f", stats.getAvgBlocks());
            System.out.println();
        }
    }
    // 获取赛季比赛数据（模拟数据）
    private Map<String, List<MatchData>> getSeasonMatches(Player player) {
        // 这里是模拟数据，实际应用中需要从数据库或其他数据源获取
        return new HashMap<>();
    }
}

主程序示例

public class SeasonStatsComparisonDemo {
    public static void main(String[] args) {
        // 创建示例球员
        Player player = new Player("张三", "北京队", "后卫");
        // 模拟2023-24赛季数据（示例）
        List<MatchData> season1Matches = createMockData(2023);
        // 模拟2024-25赛季数据（示例）
        List<MatchData> season2Matches = createMockData(2024);
        // 添加比赛数据
        season1Matches.forEach(player::addMatch);
        season2Matches.forEach(player::addMatch);
        // 统计服务
        SeasonStatsService statsService = new SeasonStatsService();
        // 计算赛季统计
        SeasonStats season1Stats = statsService.calculateSeasonStats(season1Matches, "23-24");
        SeasonStats season2Stats = statsService.calculateSeasonStats(season2Matches, "24-25");
        // 生成对比报告
        String report = statsService.generateComparisonReport(season1Stats, season2Stats);
        System.out.println(report);
        // 分析趋势
        System.out.println(statsService.analyzeTrend(season2Matches, "24-25"));
        // 可视化
        StatsVisualizer visualizer = new StatsVisualizer();
        // 柱状图示例
        Map<String, Double> metrics1 = new HashMap<>();
        metrics1.put("得分", season1Stats.getAvgPoints());
        metrics1.put("篮板", season1Stats.getAvgRebounds());
        metrics1.put("助攻", season1Stats.getAvgAssists());
        metrics1.put("抢断", season1Stats.getAvgSteals());
        metrics1.put("盖帽", season1Stats.getAvgBlocks());
        visualizer.printBarChart(metrics1, "23-24赛季球员表现");
        Map<String, Double> metrics2 = new HashMap<>();
        metrics2.put("得分", season2Stats.getAvgPoints());
        metrics2.put("篮板", season2Stats.getAvgRebounds());
        metrics2.put("助攻", season2Stats.getAvgAssists());
        metrics2.put("抢断", season2Stats.getAvgSteals());
        metrics2.put("盖帽", season2Stats.getAvgBlocks());
        visualizer.printBarChart(metrics2, "24-25赛季球员表现");
    }
    // 创建模拟数据
    private static List<MatchData> createMockData(int year) {
        List<MatchData> matches = new ArrayList<>();
        Random random = new Random();
        String[] opponents = {"上海队", "广州队", "深圳队", "四川队", "湖北队"};
        for (int month = 10; month <= 12; month++) {
            for (int day = 1; day <= 28; day += 3) {
                if (matches.size() >= 20) break;
                LocalDate date = LocalDate.of(year, month, Math.min(day, 28));
                String opponent = opponents[random.nextInt(opponents.length)];
                int points = 15 + random.nextInt(15);
                int rebounds = 3 + random.nextInt(8);
                int assists = 2 + random.nextInt(7);
                int steals = random.nextInt(3);
                int blocks = random.nextInt(3);
                int turnovers = 1 + random.nextInt(4);
                int minutes = 20 + random.nextInt(20);
                boolean isHome = random.nextBoolean();
                boolean isWin = random.nextBoolean();
                matches.add(new MatchData(date, opponent, points, rebounds, 
                        assists, steals, blocks, turnovers, minutes, isHome, isWin));
            }
        }
        return matches;
    }
}

进阶功能（可选）

// 数据导入导出功能
class DataService {
    // 将统计数据导出为CSV格式
    public String exportToCSV(SeasonStats stats) {
        StringBuilder csv = new StringBuilder();
        csv.append("赛季,场次,胜,负,场均得分,场均篮板,场均助攻,场均抢断,场均盖帽,场均失误,场均上场时间\n");
        csv.append(String.format("%s,%d,%d,%d,%.2f,%.2f,%.2f,%.2f,%.2f,%.2f,%.2f\n",
                stats.getSeason(),
                stats.getGamesPlayed(),
                stats.getWins(),
                stats.getLosses(),
                stats.getAvgPoints(),
                stats.getAvgRebounds(),
                stats.getAvgAssists(),
                stats.getAvgSteals(),
                stats.getAvgBlocks(),
                stats.getAvgTurnovers(),
                stats.getAvgMinutes()));
        return csv.toString();
    }
    // 生成JSON格式数据
    public String exportToJSON(SeasonStats stats) {
        return String.format(
            "{\"season\":\"%s\",\"gamesPlayed\":%d,\"wins\":%d,\"losses\":%d," +
            "\"avgPoints\":%.2f,\"avgRebounds\":%.2f,\"avgAssists\":%.2f," +
            "\"avgSteals\":%.2f,\"avgBlocks\":%.2f,\"avgTurnovers\":%.2f,\"avgMinutes\":%.2f}",
            stats.getSeason(),
            stats.getGamesPlayed(),
            stats.getWins(),
            stats.getLosses(),
            stats.getAvgPoints(),
            stats.getAvgRebounds(),
            stats.getAvgAssists(),
            stats.getAvgSteals(),
            stats.getAvgBlocks(),
            stats.getAvgTurnovers(),
            stats.getAvgMinutes()
        );
    }
}
// 性能优化和缓存
class StatsCache {
    private Map<String, SeasonStats> cache = new HashMap<>();
    public SeasonStats getSeasonStats(String season) {
        return cache.get(season);
    }
    public void cacheSeasonStats(String season, SeasonStats stats) {
        cache.put(season, stats);
    }
}

主要功能特点：

1. 数据统计: 计算场均得分、篮板、助攻等核心指标
2. 多赛季对比: 实现赛季间的数据对比分析
3. 趋势分析: 按月份分析球员表现趋势
4. 数据可视化: ASCII柱状图展示数据
5. 报告生成: 生成详细的对比报告
6. 数据导出: 支持CSV和JSON格式导出

这个案例可以根据实际需求进行扩展，比如添加更多的统计指标、接入真实的比赛数据源、支持多球员对比等。