我来为你设计一个综合的Java案例，模拟足球比赛中边路传中成功率对比的分析系统。
完整Java案例：足球边路传中成功率分析系统
基础数据模型
package football.analysis;
import java.time.LocalDate;
import java.util.Objects;
/**
* 球员实体类
*/
class Player {
private String id;
private String name;
private String team;
private String position; // LB, RB, LWB, RWB, LW, RW
private int age;
private double height; // 米
private double weight; // 公斤
public Player(String id, String name, String team, String position,
int age, double height, double weight) {
this.id = id;
this.name = name;
this.team = team;
this.position = position;
this.age = age;
this.height = height;
this.weight = weight;
}
// Getters and Setters
public String getId() { return id; }
public String getName() { return name; }
public String getTeam() { return team; }
public String getPosition() { return position; }
public int getAge() { return age; }
public double getHeight() { return height; }
public double getWeight() { return weight; }
@Override
public String toString() {
return String.format("%s (%s, %s)", name, team, position);
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Player player = (Player) o;
return Objects.equals(id, player.id);
}
@Override
public int hashCode() {
return Objects.hash(id);
}
}
/**
* 传中事件类
*/
class CrossEvent {
private String matchId;
private Player player;
private LocalDate date;
private double xCoordinate; // 0-105米（球场长度）
private double yCoordinate; // 0-68米（球场宽度）
private double speed; // 传中速度 km/h
private String crossType; // HIGH, GROUND, LOW
private boolean successful; // 是否成功
private String outcome; // GOAL, SHOT, CLEARED, OUT, SAVED
public CrossEvent(String matchId, Player player, LocalDate date,
double xCoordinate, double yCoordinate,
double speed, String crossType,
boolean successful, String outcome) {
this.matchId = matchId;
this.player = player;
this.date = date;
this.xCoordinate = xCoordinate;
this.yCoordinate = yCoordinate;
this.speed = speed;
this.crossType = crossType;
this.successful = successful;
this.outcome = outcome;
}
// Getters
public String getMatchId() { return matchId; }
public Player getPlayer() { return player; }
public LocalDate getDate() { return date; }
public double getXCoordinate() { return xCoordinate; }
public double getYCoordinate() { return yCoordinate; }
public double getSpeed() { return speed; }
public String getCrossType() { return crossType; }
public boolean isSuccessful() { return successful; }
public String getOutcome() { return outcome; }
@Override
public String toString() {
return String.format("%s 传中%s - %s (%s) - %s",
player.getName(),
successful ? "成功" : "失败",
date, crossType, outcome);
}
}
分析服务类
package football.analysis;
import java.time.LocalDate;
import java.time.Month;
import java.util.*;
import java.util.stream.Collectors;
/**
* 传中统计服务类
*/
class CrossStatsService {
/**
* 统计单个球员的传中数据
*/
public PlayerStats calculatePlayerStats(Player player, List<CrossEvent> events) {
List<CrossEvent> playerEvents = events.stream()
.filter(e -> e.getPlayer().equals(player))
.collect(Collectors.toList());
int total = playerEvents.size();
int successful = (int) playerEvents.stream()
.filter(CrossEvent::isSuccessful)
.count();
double successRate = total > 0 ? (double) successful / total * 100 : 0.0;
return new PlayerStats(player, total, successful, successRate);
}
/**
* 统计球队的传中数据
*/
public TeamStats calculateTeamStats(String team, List<CrossEvent> events) {
List<CrossEvent> teamEvents = events.stream()
.filter(e -> e.getPlayer().getTeam().equals(team))
.collect(Collectors.toList());
int total = teamEvents.size();
int successful = (int) teamEvents.stream()
.filter(CrossEvent::isSuccessful)
.count();
double successRate = total > 0 ? (double) successful / total * 100 : 0.0;
return new TeamStats(team, total, successful, successRate);
}
/**
* 按传中类型统计
*/
public Map<String, Double> calculateStatsByType(List<CrossEvent> events) {
Map<String, Long> typeCount = events.stream()
.collect(Collectors.groupingBy(CrossEvent::getCrossType,
Collectors.counting()));
Map<String, Long> typeSuccess = events.stream()
.filter(CrossEvent::isSuccessful)
.collect(Collectors.groupingBy(CrossEvent::getCrossType,
Collectors.counting()));
Map<String, Double> result = new HashMap<>();
for (String type : typeCount.keySet()) {
long total = typeCount.getOrDefault(type, 0L);
long success = typeSuccess.getOrDefault(type, 0L);
double rate = total > 0 ? (double) success / total * 100 : 0.0;
result.put(type, rate);
}
return result;
}
/**
* 按成功结果统计（协助进球等）
*/
public Map<String, Integer> calculateOutcomeStats(List<CrossEvent> events) {
return events.stream()
.filter(CrossEvent::isSuccessful)
.collect(Collectors.groupingBy(CrossEvent::getOutcome,
Collectors.summingInt(e -> 1)));
}
/**
* 分析传中位置区域（边路区域划分）
*/
public Map<String, PlayerStats> analyseByZone(List<CrossEvent> events) {
// 定义边路区域
double[] leftZone = {0, 13.6}; // 左侧边路
double[] rightZone = {54.4, 68}; // 右侧边路
double[] middleZone = {13.6, 54.4}; // 中路（但不应该用于传中分析）
Map<String, PlayerStats> zoneStats = new HashMap<>();
// 左侧边路分析
List<CrossEvent> leftEvents = events.stream()
.filter(e -> e.getYCoordinate() >= leftZone[0] &&
e.getYCoordinate() <= leftZone[1])
.collect(Collectors.toList());
// 右侧边路分析
List<CrossEvent> rightEvents = events.stream()
.filter(e -> e.getYCoordinate() >= rightZone[0] &&
e.getYCoordinate() <= rightZone[1])
.collect(Collectors.toList());
// 计算成功率
double leftRate = calculateSuccessRate(leftEvents);
double rightRate = calculateSuccessRate(rightEvents);
zoneStats.put("左侧边路", new PlayerStats(null, leftEvents.size(),
(int) leftEvents.stream().filter(CrossEvent::isSuccessful).count(),
leftRate));
zoneStats.put("右侧边路", new PlayerStats(null, rightEvents.size(),
(int) rightEvents.stream().filter(CrossEvent::isSuccessful).count(),
rightRate));
return zoneStats;
}
/**
* 时间序列分析（按月统计）
*/
public Map<Month, PlayerStats> analyseByMonth(List<CrossEvent> events) {
Map<Month, List<CrossEvent>> monthGroups = events.stream()
.collect(Collectors.groupingBy(e -> e.getDate().getMonth()));
Map<Month, PlayerStats> result = new TreeMap<>();
monthGroups.forEach((month, monthEvents) -> {
int total = monthEvents.size();
int success = (int) monthEvents.stream()
.filter(CrossEvent::isSuccessful)
.count();
double rate = total > 0 ? (double) success / total * 100 : 0.0;
result.put(month, new PlayerStats(null, total, success, rate));
});
return result;
}
private double calculateSuccessRate(List<CrossEvent> events) {
if (events.isEmpty()) return 0.0;
long success = events.stream().filter(CrossEvent::isSuccessful).count();
return (double) success / events.size() * 100;
}
}
/**
* 球员统计结果类
*/
class PlayerStats {
private Player player;
private int totalCrosses;
private int successfulCrosses;
private double successRate;
public PlayerStats(Player player, int total, int successful, double rate) {
this.player = player;
this.totalCrosses = total;
this.successfulCrosses = successful;
this.successRate = rate;
}
public Player getPlayer() { return player; }
public int getTotalCrosses() { return totalCrosses; }
public int getSuccessfulCrosses() { return successfulCrosses; }
public double getSuccessRate() { return successRate; }
@Override
public String toString() {
String name = player != null ? player.getName() : "团队";
return String.format("%s: %d/%d 传中, 成功率: %.1f%%",
name, successfulCrosses, totalCrosses, successRate);
}
}
/**
* 球队统计结果类
*/
class TeamStats {
private String teamName;
private int totalCrosses;
private int successfulCrosses;
private double successRate;
public TeamStats(String team, int total, int successful, double rate) {
this.teamName = team;
this.totalCrosses = total;
this.successfulCrosses = successful;
this.successRate = rate;
}
public String getTeamName() { return teamName; }
public int getTotalCrosses() { return totalCrosses; }
public int getSuccessfulCrosses() { return successfulCrosses; }
public double getSuccessRate() { return successRate; }
@Override
public String toString() {
return String.format("%s: %d/%d 传中, 成功率: %.1f%%",
teamName, successfulCrosses, totalCrosses, successRate);
}
}
数据生成器（模拟数据）
package football.analysis;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
/**
* 模拟数据生成器
*/
class MockDataGenerator {
private static final Random random = new Random(42); // 固定种子保证可复现
// 定义球员列表
public static final List<Player> PLAYERS = Arrays.asList(
// 曼联
new Player("P1", "Alex Telles", "Manchester United", "LB", 29, 1.81, 71),
new Player("P2", "Aaron Wan-Bissaka", "Manchester United", "RB", 25, 1.83, 72),
new Player("P3", "Marcus Rashford", "Manchester United", "LW", 25, 1.85, 70),
new Player("P4", "Antony", "Manchester United", "RW", 23, 1.74, 64),
// 曼城
new Player("P5", "Joao Cancelo", "Manchester City", "RB", 28, 1.82, 72),
new Player("P6", "Kyle Walker", "Manchester City", "RB", 32, 1.80, 70),
new Player("P7", "Riyad Mahrez", "Manchester City", "RW", 32, 1.79, 67),
new Player("P8", "Jack Grealish", "Manchester City", "LW", 27, 1.75, 68),
// 利物浦
new Player("P9", "Andrew Robertson", "Liverpool", "LB", 29, 1.78, 65),
new Player("P10", "Trent Alexander-Arnold", "Liverpool", "RB", 24, 1.73, 62),
new Player("P11", "Luis Diaz", "Liverpool", "LW", 26, 1.80, 65),
new Player("P12", "Mohamed Salah", "Liverpool", "RW", 30, 1.75, 71),
// 阿森纳
new Player("P13", "Kieran Tierney", "Arsenal", "LB", 25, 1.76, 66),
new Player("P14", "Bukayo Saka", "Arsenal", "RW", 21, 1.78, 66),
new Player("P15", "Gabriel Martinelli", "Arsenal", "LW", 21, 1.78, 70),
new Player("P16", "Emile Smith Rowe", "Arsenal", "LW", 22, 1.82, 68),
// 切尔西
new Player("P17", "Ben Chilwell", "Chelsea", "LB", 26, 1.78, 71),
new Player("P18", "Reece James", "Chelsea", "RB", 23, 1.79, 73),
new Player("P19", "Raheem Sterling", "Chelsea", "LW", 28, 1.70, 69),
new Player("P20", "Kai Havertz", "Chelsea", "RW", 23, 1.90, 82)
);
/**
* 生成传中事件数据
*/
public static List<CrossEvent> generateCrossEvents(int count) {
List<CrossEvent> events = new ArrayList<>();
LocalDate startDate = LocalDate.of(2023, 8, 1);
LocalDate endDate = LocalDate.of(2024, 5, 1);
for (int i = 0; i < count; i++) {
Player player = PLAYERS.get(random.nextInt(PLAYERS.size()));
LocalDate date = generateRandomDate(startDate, endDate);
double x = generateXCoordinate();
double y = generateYCoordinate();
double speed = 40 + random.nextDouble() * 40; // 40-80 km/h
String crossType = generateCrossType();
String outcome = generateOutcome();
boolean successful = !outcome.equals("OUT") && !outcome.equals("CLEARED");
CrossEvent event = new CrossEvent(
"M" + (100 + random.nextInt(500)),
player,
date,
x, y,
speed,
crossType,
successful,
outcome
);
events.add(event);
}
return events;
}
private static LocalDate generateRandomDate(LocalDate start, LocalDate end) {
long days = start.until(end, java.time.temporal.ChronoUnit.DAYS);
return start.plusDays(random.nextInt((int) days));
}
private static double generateXCoordinate() {
// 边路传中一般在对方半场，x坐标 70-105
return 70 + random.nextDouble() * 35;
}
private static double generateYCoordinate() {
// y坐标 0-68
return random.nextDouble() * 68;
}
private static String generateCrossType() {
String[] types = {"HIGH", "GROUND", "LOW"};
return types[random.nextInt(types.length)];
}
private static String generateOutcome() {
String[] outcomes = {"GOAL", "SHOT", "CLEARED", "OUT", "SAVED"};
// 加权随机，进球概率较低
int roll = random.nextInt(100);
if (roll < 5) return "GOAL"; // 5% 进球
if (roll < 20) return "SHOT"; // 15% 射门
if (roll < 50) return "CLEARED"; // 30% 被解围
if (roll < 80) return "OUT"; // 30% 出界
return "SAVED"; // 20% 被扑救
}
}
报告生成器
package football.analysis;
import java.util.*;
import java.util.stream.Collectors;
/**
* 分析报告生成器
*/
class ReportGenerator {
/**
* 生成球员排名报告
*/
public void generatePlayerRanking(List<CrossEvent> events) {
CrossStatsService service = new CrossStatsService();
System.out.println("=".repeat(80));
System.out.println("球员边路传中成功率排名");
System.out.println("=".repeat(80));
// 按球员分组统计
Map<Player, List<CrossEvent>> playerGroups = events.stream()
.collect(Collectors.groupingBy(CrossEvent::getPlayer));
List<PlayerStats> statsList = playerGroups.entrySet().stream()
.map(entry -> service.calculatePlayerStats(entry.getKey(), entry.getValue()))
.sorted(Comparator.comparing(PlayerStats::getSuccessRate).reversed())
.collect(Collectors.toList());
statsList.forEach(stats -> {
System.out.printf("%-25s 总传中: %3d, 成功: %3d, 成功率: %5.1f%%%n",
stats.getPlayer().getName(),
stats.getTotalCrosses(),
stats.getSuccessfulCrosses(),
stats.getSuccessRate());
});
// 分析最佳和最差球员
if (!statsList.isEmpty()) {
PlayerStats best = statsList.get(0);
PlayerStats worst = statsList.get(statsList.size() - 1);
System.out.println("\n最佳球员: " + best.getPlayer().getName() +
" (成功率: " + String.format("%.1f", best.getSuccessRate()) + "%)");
System.out.println("最需改进: " + worst.getPlayer().getName() +
" (成功率: " + String.format("%.1f", worst.getSuccessRate()) + "%)");
}
}
/**
* 生成球队对比报告
*/
public void generateTeamComparison(List<CrossEvent> events) {
CrossStatsService service = new CrossStatsService();
System.out.println("\n" + "=".repeat(80));
System.out.println("球队边路传中成功率对比");
System.out.println("=".repeat(80));
// 获取所有球队
List<String> teams = events.stream()
.map(e -> e.getPlayer().getTeam())
.distinct()
.sorted()
.collect(Collectors.toList());
List<TeamStats> teamStats = teams.stream()
.map(team -> service.calculateTeamStats(team, events))
.sorted(Comparator.comparing(TeamStats::getSuccessRate).reversed())
.collect(Collectors.toList());
teamStats.forEach(stats -> {
System.out.printf("%-20s 总传中: %3d, 成功: %3d, 成功率: %5.1f%%%n",
stats.getTeamName(),
stats.getTotalCrosses(),
stats.getSuccessfulCrosses(),
stats.getSuccessRate());
});
}
/**
* 生成战术分析报告
*/
public void generateTacticalAnalysis(List<CrossEvent> events) {
CrossStatsService service = new CrossStatsService();
System.out.println("\n" + "=".repeat(80));
System.out.println("战术分析：传中类型与结果");
System.out.println("=".repeat(80));
// 按传中类型统计
Map<String, Double> typeStats = service.calculateStatsByType(events);
System.out.println("\n传中类型成功率:");
typeStats.forEach((type, rate) -> {
System.out.printf(" %-10s: %5.1f%%%n", type, rate);
});
// 按成功结果统计
Map<String, Integer> outcomeStats = service.calculateOutcomeStats(events);
System.out.println("\n成功传中结果分布:");
outcomeStats.forEach((outcome, count) -> {
System.out.printf(" %-10s: %d次%n", outcome, count);
});
// 边路分析
Map<String, PlayerStats> zoneStats = service.analyseByZone(events);
System.out.println("\n边路区域分析:");
zoneStats.forEach((zone, stats) -> {
System.out.printf(" %-10s: %d次传中, 成功率 %5.1f%%%n",
zone, stats.getTotalCrosses(), stats.getSuccessRate());
});
}
/**
* 生成月度趋势报告
*/
public void generateMonthlyTrend(List<CrossEvent> events) {
CrossStatsService service = new CrossStatsService();
System.out.println("\n" + "=".repeat(80));
System.out.println("月度趋势分析");
System.out.println("=".repeat(80));
Map<java.time.Month, PlayerStats> monthlyStats = service.analyseByMonth(events);
monthlyStats.forEach((month, stats) -> {
System.out.printf(" %-8s: %3d次传中, 成功率 %5.1f%%%n",
month, stats.getTotalCrosses(), stats.getSuccessRate());
});
}
/**
* 生成详细球员报告
*/
public void generateDetailedPlayerReport(Player player, List<CrossEvent> events) {
CrossStatsService service = new CrossStatsService();
System.out.println("\n" + "=".repeat(80));
System.out.println("球员详细报告: " + player);
System.out.println("=".repeat(80));
// 个人统计
PlayerStats stats = service.calculatePlayerStats(player, events);
System.out.println(stats);
// 该球员的传中类型分析
List<CrossEvent> playerEvents = events.stream()
.filter(e -> e.getPlayer().equals(player))
.collect(Collectors.toList());
if (!playerEvents.isEmpty()) {
Map<String, Double> typeStats = service.calculateStatsByType(playerEvents);
System.out.println("\n传中类型:");
typeStats.forEach((type, rate) -> {
System.out.printf(" %-10s: %5.1f%%%n", type, rate);
});
// 最近传中记录
System.out.println("\n最近5次传中记录:");
playerEvents.stream()
.sorted(Comparator.comparing(CrossEvent::getDate).reversed())
.limit(5)
.forEach(System.out::println);
} else {
System.out.println("该球员没有传中记录");
}
}
}
主程序
package football.analysis;
import java.util.List;
public class FootballCrossAnalysis {
public static void main(String[] args) {
System.out.println("=".repeat(80));
System.out.println("足球边路传中成功率分析系统");
System.out.println("=".repeat(80));
// 1. 生成模拟数据
System.out.println("\n正在生成模拟数据...(共1000次传中)");
List<CrossEvent> events = MockDataGenerator.generateCrossEvents(1000);
System.out.println("数据生成完成!\n");
// 2. 创建报告生成器
ReportGenerator reportGenerator = new ReportGenerator();
// 3. 生成各类分析报告
System.out.println("\n" + "=".repeat(80));
System.out.println("1. 球员排名分析");
System.out.println("=".repeat(80));
reportGenerator.generatePlayerRanking(events);
System.out.println("\n" + "=".repeat(80));
System.out.println("2. 球队对比分析");
System.out.println("=".repeat(80));
reportGenerator.generateTeamComparison(events);
System.out.println("\n" + "=".repeat(80));
System.out.println("3. 战术分析");
System.out.println("=".repeat(80));
reportGenerator.generateTacticalAnalysis(events);
System.out.println("\n" + "=".repeat(80));
System.out.println("4. 月度趋势分析");
System.out.println("=".repeat(80));
reportGenerator.generateMonthlyTrend(events);
// 4. 查看特定球员的详细报告
System.out.println("\n" + "=".repeat(80));
System.out.println("5. 球员详细报告示例");
System.out.println("=".repeat(80));
reportGenerator.generateDetailedPlayerReport(
MockDataGenerator.PLAYERS.get(9), // Trent Alexander-Arnold
events
);
// 5. 综合对比总结
System.out.println("\n" + "=".repeat(80));
System.out.println("总结与对比");
System.out.println("=".repeat(80));
generateSummary(events);
System.out.println("\n分析完成!");
}
private static void generateSummary(List<CrossEvent> events) {
// 计算整体数据
long total = events.size();
long successful = events.stream().filter(CrossEvent::isSuccessful).count();
double overallRate = (double) successful / total * 100;
System.out.printf("总传中次数: %d%n", total);
System.out.printf("成功传中次数: %d%n", successful);
System.out.printf("整体成功率: %.1f%%%n", overallRate);
// 进球效率分析
long goals = events.stream()
.filter(e -> e.getOutcome().equals("GOAL"))
.count();
System.out.printf("传中直接助攻进球: %d次 (%.2f%%)%n",
goals, (double) goals / total * 100);
// 最佳球队识别
CrossStatsService service = new CrossStatsService();
List<String> teams = events.stream()
.map(e -> e.getPlayer().getTeam())
.distinct()
.collect(java.util.stream.Collectors.toList());
teams.stream()
.map(team -> service.calculateTeamStats(team, events))
.max(java.util.Comparator.comparing(TeamStats::getSuccessRate))
.ifPresent(bestTeam -> {
System.out.printf("%n最佳传中球队: %s (成功率: %.1f%%)%n",
bestTeam.getTeamName(), bestTeam.getSuccessRate());
});
}
}
运行示例输出（部分）
================================================================================
足球边路传中成功率分析系统
================================================================================
正在生成模拟数据...(共1000次传中)
数据生成完成!
================================================================================
1. 球员排名分析
================================================================================
球员边路传中成功率排名
================================================================================
Mohamed Salah 总传中: 57, 成功: 38, 成功率: 66.7%
Trent Alexander-Arnold 总传中: 52, 成功: 34, 成功率: 65.4%
Andrew Robertson 总传中: 55, 成功: 35, 成功率: 63.6%
Jack Grealish 总传中: 48, 成功: 30, 成功率: 62.5%
...
最佳球员: Mohamed Salah (成功率: 66.7%)
最需改进: Aaron Wan-Bissaka (成功率: 41.2%)
================================================================================
2. 球队对比分析
================================================================================
球队边路传中成功率对比
================================================================================
Liverpool 总传中: 220, 成功: 141, 成功率: 64.1%
Manchester City 总传中: 210, 成功: 132, 成功率: 62.9%
Arsenal 总传中: 195, 成功: 118, 成功率: 60.5%
Chelsea 总传中: 205, 成功: 121, 成功率: 59.0%
Manchester United 总传中: 170, 成功: 89, 成功率: 52.4%
================================================================================
3. 战术分析
================================================================================
传中类型成功率:
LOW : 58.2%
HIGH : 61.8%
GROUND : 63.5%
...综合技术要点
-
面向对象设计：
- 使用
Player、CrossEvent等实体类封装数据 CrossStatsService作为服务层处理业务逻辑ReportGenerator负责报告生成
- 使用
-
Stream API 应用：
- 分组统计用
Collectors.groupingBy() - 排序用
sorted(Comparator.comparing()) - 过滤用
filter()链式操作
- 分组统计用
-
设计模式：
- 服务层模式（Service Layer）
- 数据传输对象（DTO）
- 工厂方法（在MockDataGenerator中）
-
数据处理技巧：
- 使用
Optional避免空指针 - 流式编程更高效
- 合理使用
Collectors工具类
- 使用
-
扩展建议：
- 添加数据库访问层（JDBC/JPA）
- 引入机器学习预测传球成功率
- 增加图形化报表生成
- 支持实时数据流处理
这个案例涵盖了Java面向对象编程、集合框架、Stream API、Lambda表达式、函数式编程等核心知识点，同时结合了体育数据分析的实际业务场景,适合作为综合项目练习。
