本文目录导读：
我来为您提供一个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);
}
}
主要功能特点：
- 数据统计: 计算场均得分、篮板、助攻等核心指标
- 多赛季对比: 实现赛季间的数据对比分析
- 趋势分析: 按月份分析球员表现趋势
- 数据可视化: ASCII柱状图展示数据
- 报告生成: 生成详细的对比报告
- 数据导出: 支持CSV和JSON格式导出
这个案例可以根据实际需求进行扩展，比如添加更多的统计指标、接入真实的比赛数据源、支持多球员对比等。
