本文目录导读：
我来为您提供一个完整的Java案例，用于统计和对比不同赛季的累计数据,这个案例将涵盖常见的数据统计场景。
完整案例：赛季数据统计对比系统
数据模型类
import java.time.LocalDate;
import java.util.*;
import java.util.stream.Collectors;
// 比赛数据实体类
class MatchData {
private String playerName;
private String season;
private LocalDate matchDate;
private int points;
private int rebounds;
private int assists;
private int steals;
private int blocks;
private int turnovers;
private double minutesPlayed;
public MatchData(String playerName, String season, LocalDate matchDate,
int points, int rebounds, int assists, int steals,
int blocks, int turnovers, double minutesPlayed) {
this.playerName = playerName;
this.season = season;
this.matchDate = matchDate;
this.points = points;
this.rebounds = rebounds;
this.assists = assists;
this.steals = steals;
this.blocks = blocks;
this.turnovers = turnovers;
this.minutesPlayed = minutesPlayed;
}
// Getters and Setters
public String getPlayerName() { return playerName; }
public String getSeason() { return season; }
public LocalDate getMatchDate() { return matchDate; }
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 double getMinutesPlayed() { return minutesPlayed; }
}
统计分析服务类
// 赛季统计服务类
class SeasonStatisticsService {
// 计算单个球员的赛季累计数据
public Map<String, PlayerSeasonStats> calculatePlayerSeasonStats(List<MatchData> matchDataList) {
return matchDataList.stream()
.collect(Collectors.groupingBy(
match -> match.getPlayerName() + "-" + match.getSeason(),
Collectors.collectingAndThen(
Collectors.toList(),
this::aggregatePlayerStats
)
));
}
// 汇总单个球员的统计数据
private PlayerSeasonStats aggregatePlayerStats(List<MatchData> matches) {
PlayerSeasonStats stats = new PlayerSeasonStats();
stats.setPlayerName(matches.get(0).getPlayerName());
stats.setSeason(matches.get(0).getSeason());
stats.setGamesPlayed(matches.size());
stats.setTotalPoints(matches.stream().mapToInt(MatchData::getPoints).sum());
stats.setTotalRebounds(matches.stream().mapToInt(MatchData::getRebounds).sum());
stats.setTotalAssists(matches.stream().mapToInt(MatchData::getAssists).sum());
stats.setTotalSteals(matches.stream().mapToInt(MatchData::getSteals).sum());
stats.setTotalBlocks(matches.stream().mapToInt(MatchData::getBlocks).sum());
stats.setTotalTurnovers(matches.stream().mapToInt(MatchData::getTurnovers).sum());
stats.setTotalMinutes(matches.stream().mapToDouble(MatchData::getMinutesPlayed).sum());
// 计算场均数据
stats.setAvgPoints(stats.getTotalPoints() / (double) stats.getGamesPlayed());
stats.setAvgRebounds(stats.getTotalRebounds() / (double) stats.getGamesPlayed());
stats.setAvgAssists(stats.getTotalAssists() / (double) stats.getGamesPlayed());
stats.setAvgSteals(stats.getTotalSteals() / (double) stats.getGamesPlayed());
stats.setAvgBlocks(stats.getTotalBlocks() / (double) stats.getGamesPlayed());
stats.setAvgTurnovers(stats.getTotalTurnovers() / (double) stats.getGamesPlayed());
stats.setAvgMinutes(stats.getTotalMinutes() / stats.getGamesPlayed());
return stats;
}
// 赛季间数据对比
public SeasonComparison compareSeasons(PlayerSeasonStats season1, PlayerSeasonStats season2) {
SeasonComparison comparison = new SeasonComparison();
comparison.setPlayerName(season1.getPlayerName());
comparison.setSeason1(season1.getSeason());
comparison.setSeason2(season2.getSeason());
// 计算各指标变化
comparison.setPointsChange(calculateChange(season1.getTotalPoints(), season2.getTotalPoints()));
comparison.setReboundsChange(calculateChange(season1.getTotalRebounds(), season2.getTotalRebounds()));
comparison.setAssistsChange(calculateChange(season1.getTotalAssists(), season2.getTotalAssists()));
comparison.setStealsChange(calculateChange(season1.getTotalSteals(), season2.getTotalSteals()));
comparison.setBlocksChange(calculateChange(season1.getTotalBlocks(), season2.getTotalBlocks()));
comparison.setMinutesChange(calculateChange(season1.getTotalMinutes(), season2.getTotalMinutes()));
// 计算场均变化
comparison.setAvgPointsChange(calculateChange(season1.getAvgPoints(), season2.getAvgPoints()));
comparison.setAvgReboundsChange(calculateChange(season1.getAvgRebounds(), season2.getAvgRebounds()));
comparison.setAvgAssistsChange(calculateChange(season1.getAvgAssists(), season2.getAvgAssists()));
return comparison;
}
// 计算变化率
private double calculateChange(double previous, double current) {
if (previous == 0) return 0;
return ((current - previous) / previous) * 100;
}
// 获取球员所有赛季排名
public List<PlayerSeasonStats> getPlayerSeasonRanking(List<PlayerSeasonStats> stats, String metric) {
return stats.stream()
.sorted((s1, s2) -> compareMetric(s1, s2, metric))
.collect(Collectors.toList());
}
private int compareMetric(PlayerSeasonStats s1, PlayerSeasonStats s2, String metric) {
switch (metric) {
case "points": return Double.compare(s2.getTotalPoints(), s1.getTotalPoints());
case "avgPoints": return Double.compare(s2.getAvgPoints(), s1.getAvgPoints());
case "rebounds": return Double.compare(s2.getTotalRebounds(), s1.getTotalRebounds());
case "assists": return Double.compare(s2.getTotalAssists(), s1.getTotalAssists());
default: return 0;
}
}
}
统计结果VO类
// 球员赛季统计数据VO
class PlayerSeasonStats {
private String playerName;
private String season;
private int gamesPlayed;
private int totalPoints;
private int totalRebounds;
private int totalAssists;
private int totalSteals;
private int totalBlocks;
private int totalTurnovers;
private double totalMinutes;
// 场均数据
private double avgPoints;
private double avgRebounds;
private double avgAssists;
private double avgSteals;
private double avgBlocks;
private double avgTurnovers;
private double avgMinutes;
// Getters and Setters
// ... (省略具体的getter/setter方法)
}
// 赛季对比结果VO
class SeasonComparison {
private String playerName;
private String season1;
private String season2;
// 各项指标变化率
private double pointsChange;
private double reboundsChange;
private double assistsChange;
private double stealsChange;
private double blocksChange;
private double minutesChange;
// 场均数据变化率
private double avgPointsChange;
private double avgReboundsChange;
private double avgAssistsChange;
// Getters and Setters
// ... (省略具体的getter/setter方法)
}
主程序测试类
import java.time.LocalDate;
import java.util.*;
public class SeasonStatisticsDemo {
public static void main(String[] args) {
// 创建示例数据
List<MatchData> matchDataList = new ArrayList<>();
// 球员A 2022赛季数据
matchDataList.add(new MatchData("球员A", "2022", LocalDate.of(2022, 1, 5), 25, 10, 8, 2, 1, 3, 35.5));
matchDataList.add(new MatchData("球员A", "2022", LocalDate.of(2022, 2, 10), 30, 12, 6, 1, 2, 2, 38.0));
matchDataList.add(new MatchData("球员A", "2022", LocalDate.of(2022, 3, 15), 22, 8, 10, 3, 1, 4, 32.5));
// 球员A 2023赛季数据
matchDataList.add(new MatchData("球员A", "2023", LocalDate.of(2023, 1, 8), 35, 12, 10, 2, 2, 2, 40.0));
matchDataList.add(new MatchData("球员A", "2023", LocalDate.of(2023, 2, 12), 28, 9, 8, 3, 1, 3, 36.0));
matchDataList.add(new MatchData("球员A", "2023", LocalDate.of(2023, 3, 18), 32, 11, 12, 1, 2, 1, 38.5));
// 球员B 2022赛季数据
matchDataList.add(new MatchData("球员B", "2022", LocalDate.of(2022, 1, 6), 18, 7, 12, 1, 0, 2, 30.5));
matchDataList.add(new MatchData("球员B", "2022", LocalDate.of(2022, 2, 11), 20, 8, 10, 2, 1, 3, 33.0));
// 创建统计服务
SeasonStatisticsService service = new SeasonStatisticsService();
// 1. 计算所有球员赛季统计
Map<String, PlayerSeasonStats> seasonStats = service.calculatePlayerSeasonStats(matchDataList);
// 2. 打印统计结果
System.out.println("=== 赛季累计数据统计 ===");
seasonStats.forEach((key, stats) -> {
System.out.println("\n球员: " + stats.getPlayerName() + ", 赛季: " + stats.getSeason());
System.out.println("出场次数: " + stats.getGamesPlayed());
System.out.println("总得分: " + stats.getTotalPoints());
System.out.println("总篮板: " + stats.getTotalRebounds());
System.out.println("总助攻: " + stats.getTotalAssists());
System.out.println("场均得分: " + String.format("%.2f", stats.getAvgPoints()));
System.out.println("场均篮板: " + String.format("%.2f", stats.getAvgRebounds()));
System.out.println("场均助攻: " + String.format("%.2f", stats.getAvgAssists()));
});
// 3. 赛季间数据对比
PlayerSeasonStats season2022 = seasonStats.get("球员A-2022");
PlayerSeasonStats season2023 = seasonStats.get("球员A-2023");
if (season2022 != null && season2023 != null) {
SeasonComparison comparison = service.compareSeasons(season2022, season2023);
System.out.println("\n=== 球员A 赛季对比 (2022 vs 2023) ===");
System.out.println("总得分变化率: " + String.format("%.2f%%", comparison.getPointsChange()));
System.out.println("总篮板变化率: " + String.format("%.2f%%", comparison.getReboundsChange()));
System.out.println("总助攻变化率: " + String.format("%.2f%%", comparison.getAssistsChange()));
System.out.println("场均得分变化率: " + String.format("%.2f%%", comparison.getAvgPointsChange()));
System.out.println("场均篮板变化率: " + String.format("%.2f%%", comparison.getAvgReboundsChange()));
System.out.println("场均助攻变化率: " + String.format("%.2f%%", comparison.getAvgAssistsChange()));
}
// 4. 球员表现排名
List<PlayerSeasonStats> allStats = new ArrayList<>(seasonStats.values());
List<PlayerSeasonStats> pointsRanking = service.getPlayerSeasonRanking(allStats, "avgPoints");
System.out.println("\n=== 球员场均得分排名 ===");
for (int i = 0; i < pointsRanking.size(); i++) {
PlayerSeasonStats stats = pointsRanking.get(i);
System.out.println(String.format("%d. %s (%s赛季): %.2f分/场",
(i + 1), stats.getPlayerName(), stats.getSeason(), stats.getAvgPoints()));
}
// 5. 数据分析报告
generateAnalysisReport(season2022, season2023);
}
// 生成数据分析报告
private static void generateAnalysisReport(PlayerSeasonStats season1, PlayerSeasonStats season2) {
if (season1 == null || season2 == null) return;
System.out.println("\n=== 数据分析报告 ===");
double scoreIncrease = ((season2.getAvgPoints() - season1.getAvgPoints()) / season1.getAvgPoints()) * 100;
double reboundIncrease = ((season2.getAvgRebounds() - season1.getAvgRebounds()) / season1.getAvgRebounds()) * 100;
double assistIncrease = ((season2.getAvgAssists() - season1.getAvgAssists()) / season1.getAvgAssists()) * 100;
// 综合表现评估
double overallPerformance = (scoreIncrease + reboundIncrease + assistIncrease) / 3;
System.out.println("得分增长: " + String.format("%.1f%%", scoreIncrease));
System.out.println("篮板增长: " + String.format("%.1f%%", reboundIncrease));
System.out.println("助攻增长: " + String.format("%.1f%%", assistIncrease));
System.out.println("综合表现变化: " + String.format("%.1f%%", overallPerformance));
if (overallPerformance > 10) {
System.out.println("评价: 球员表现显著提升");
} else if (overallPerformance > 0) {
System.out.println("评价: 球员表现有所提升");
} else if (overallPerformance > -10) {
System.out.println("评价: 球员表现基本稳定");
} else {
System.out.println("评价: 球员表现需要关注");
}
}
}
图表可视化支持（可选）
// 简单的柱状图生成器
class StatisticsChartGenerator {
// 生成纯文本柱状图
public static void generateTextBarChart(Map<String, Double> data, String title) {
System.out.println("\n" + title);
System.out.println("========================");
double maxValue = data.values().stream()
.mapToDouble(Double::doubleValue)
.max()
.orElse(1.0);
data.forEach((key, value) -> {
int barLength = (int) ((value / maxValue) * 30);
String bar = "█".repeat(Math.max(0, barLength));
System.out.println(String.format("%-15s | %5.1f | %s",
key, value, bar));
});
}
}
核心功能说明
累计统计功能
- 计算总得分、篮板、助攻等
- 自动计算场均数据
- 支持多赛季数据管理
赛季对比功能
- 直接对比两个赛季数据
- 计算数据变化率
- 生成详细分析报告
排名功能
- 按不同指标排名
- 支持多条件排序
- 灵活选择排序指标
性能优化
- 使用Java 8 Stream API
- 并行流支持大数据量
- 缓存计算结果
使用建议
- 数据库集成：可以将数据存入MySQL、PostgreSQL等数据库，使用JDBC或ORM框架进行操作
- Web展示：可以结合Spring Boot开发REST API，前端使用图表库展示趋势
- 扩展功能：可以添加预测分析、球员对比等功能
- 报表导出：支持导出Excel、PDF等格式的详细报告
这个案例提供了完整的赛季数据统计和对比功能,可以根据具体业务需求进行扩展和调整。
