本文目录导读：
我来为您提供一个Java案例，统计足球比赛中禁区内外的射门次数对比，这个案例包含数据模型、统计逻辑和简单的测试演示。
完整Java实现
import java.util.*;
import java.util.stream.Collectors;
/**
* 足球射门统计系统 - 统计禁区内/外射门次数对比
*/
public class ShotStatisticsSystem {
// 射门位置类型
enum ShotZone {
INSIDE_BOX("禁区内"),
OUTSIDE_BOX("禁区外");
private final String description;
ShotZone(String description) {
this.description = description;
}
public String getDescription() {
return description;
}
}
// 射门结果类型
enum ShotResult {
GOAL("进球"),
ON_TARGET("射正"),
OFF_TARGET("射偏"),
BLOCKED("被挡");
private final String description;
ShotResult(String description) {
this.description = description;
}
public String getDescription() {
return description;
}
}
// 射门事件类
static class Shot {
private final int playerId;
private final String playerName;
private final ShotZone zone;
private final ShotResult result;
private final int minute;
private final double xCoordinate;
private final double yCoordinate;
private final double shotPower;
public Shot(int playerId, String playerName, ShotZone zone,
ShotResult result, int minute,
double xCoordinate, double yCoordinate, double shotPower) {
this.playerId = playerId;
this.playerName = playerName;
this.zone = zone;
this.result = result;
this.minute = minute;
this.xCoordinate = xCoordinate;
this.yCoordinate = yCoordinate;
this.shotPower = shotPower;
}
// Getters
public int getPlayerId() { return playerId; }
public String getPlayerName() { return playerName; }
public ShotZone getZone() { return zone; }
public ShotResult getResult() { return result; }
public int getMinute() { return minute; }
public double getXCoordinate() { return xCoordinate; }
public double getYCoordinate() { return yCoordinate; }
public double getShotPower() { return shotPower; }
@Override
public String toString() {
return String.format("第%d分钟 %s 在%s %s (坐标: %.1f, %.1f, 射门力量: %.1f)",
minute, playerName, zone.getDescription(), result.getDescription(),
xCoordinate, yCoordinate, shotPower);
}
}
// 统计结果类
static class ShotStatistics {
private final Map<ShotZone, Integer> totalShots;
private final Map<ShotZone, Integer> goals;
private final Map<ShotZone, Double> conversionRate;
private final Map<ShotZone, Map<ShotResult, Integer>> resultBreakdown;
private final Map<ShotZone, Double> averageShotPower;
public ShotStatistics(Map<ShotZone, Integer> totalShots,
Map<ShotZone, Integer> goals,
Map<ShotZone, Double> conversionRate,
Map<ShotZone, Map<ShotResult, Integer>> resultBreakdown,
Map<ShotZone, Double> averageShotPower) {
this.totalShots = totalShots;
this.goals = goals;
this.conversionRate = conversionRate;
this.resultBreakdown = resultBreakdown;
this.averageShotPower = averageShotPower;
}
public Map<ShotZone, Integer> getTotalShots() { return totalShots; }
public Map<ShotZone, Integer> getGoals() { return goals; }
public Map<ShotZone, Double> getConversionRate() { return conversionRate; }
public Map<ShotZone, Map<ShotResult, Integer>> getResultBreakdown() { return resultBreakdown; }
public Map<ShotZone, Double> getAverageShotPower() { return averageShotPower; }
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("射门统计报告\n");
sb.append("=".repeat(50)).append("\n\n");
for (ShotZone zone : ShotZone.values()) {
sb.append("【").append(zone.getDescription()).append("】\n");
sb.append("射门总数: ").append(totalShots.getOrDefault(zone, 0)).append("次\n");
sb.append("进球数: ").append(goals.getOrDefault(zone, 0)).append("个\n");
sb.append("转化率: ").append(conversionRate.getOrDefault(zone, 0.0)).append("%\n");
Map<ShotResult, Integer> breakdown = resultBreakdown.getOrDefault(zone, new HashMap<>());
sb.append("射门结果: ");
for (ShotResult result : ShotResult.values()) {
sb.append(result.getDescription()).append(" ")
.append(breakdown.getOrDefault(result, 0)).append("次 ");
}
sb.append("\n");
sb.append("平均射门力量: ").append(averageShotPower.getOrDefault(zone, 0.0)).append("\n");
sb.append("-".repeat(30)).append("\n");
}
return sb.toString();
}
}
// 统计服务类
static class ShotStatisticsService {
/**
* 计算射门统计
*/
public ShotStatistics calculateStatistics(List<Shot> shots) {
Map<ShotZone, Integer> totalShots = new EnumMap<>(ShotZone.class);
Map<ShotZone, Integer> goals = new EnumMap<>(ShotZone.class);
Map<ShotZone, List<Shot>> shotsByZone = shots.stream()
.collect(Collectors.groupingBy(Shot::getZone));
// 初始化所有区域
for (ShotZone zone : ShotZone.values()) {
totalShots.put(zone, shotsByZone.getOrDefault(zone, new ArrayList<>()).size());
List<Shot> zoneGoals = shotsByZone.getOrDefault(zone, new ArrayList<>())
.stream()
.filter(shot -> shot.getResult() == ShotResult.GOAL)
.collect(Collectors.toList());
goals.put(zone, zoneGoals.size());
}
// 计算转化率
Map<ShotZone, Double> conversionRate = new EnumMap<>(ShotZone.class);
for (ShotZone zone : ShotZone.values()) {
int total = totalShots.get(zone);
int goalCount = goals.get(zone);
conversionRate.put(zone, total > 0 ? (double) goalCount / total * 100 : 0.0);
}
// 计算各结果分布
Map<ShotZone, Map<ShotResult, Integer>> resultBreakdown = new EnumMap<>(ShotZone.class);
for (ShotZone zone : ShotZone.values()) {
Map<ShotResult, Integer> zoneResults = new EnumMap<>(ShotResult.class);
for (ShotResult result : ShotResult.values()) {
int count = (int) shotsByZone.getOrDefault(zone, new ArrayList<>())
.stream()
.filter(shot -> shot.getResult() == result)
.count();
zoneResults.put(result, count);
}
resultBreakdown.put(zone, zoneResults);
}
// 计算平均射门力量
Map<ShotZone, Double> averageShotPower = new EnumMap<>(ShotZone.class);
for (ShotZone zone : ShotZone.values()) {
List<Shot> zoneShots = shotsByZone.getOrDefault(zone, new ArrayList<>());
double avgPower = zoneShots.isEmpty() ? 0.0 :
zoneShots.stream().mapToDouble(Shot::getShotPower).average().orElse(0.0);
averageShotPower.put(zone, avgPower);
}
return new ShotStatistics(totalShots, goals, conversionRate, resultBreakdown, averageShotPower);
}
/**
* 获取禁区内外射门次数对比
*/
public Map<String, Integer> getZoneComparison(List<Shot> shots) {
Map<String, Integer> comparison = new LinkedHashMap<>();
for (ShotZone zone : ShotZone.values()) {
comparison.put(zone.getDescription(),
(int) shots.stream().filter(s -> s.getZone() == zone).count());
}
return comparison;
}
/**
* 按球员统计射门
*/
public Map<String, Map<ShotZone, Integer>> getPlayerStats(List<Shot> shots) {
return shots.stream()
.collect(Collectors.groupingBy(
Shot::getPlayerName,
Collectors.groupingBy(Shot::getZone, Collectors.summingInt(s -> 1))
));
}
/**
* 获取禁区内外进球效率对比
*/
public Map<String, String> getGoalEfficiencyComparison(List<Shot> shots) {
Map<String, String> efficiency = new LinkedHashMap<>();
for (ShotZone zone : ShotZone.values()) {
List<Shot> zoneShots = shots.stream()
.filter(s -> s.getZone() == zone)
.collect(Collectors.toList());
int goals = (int) zoneShots.stream()
.filter(s -> s.getResult() == ShotResult.GOAL)
.count();
int total = zoneShots.size();
String eff = total > 0 ?
String.format("%.1f%%(%d/%d)", (double) goals / total * 100, goals, total) :
"无射门";
efficiency.put(zone.getDescription(), eff);
}
return efficiency;
}
}
/**
* 演示主类
*/
public static class ShotDemo {
public static void main(String[] args) {
// 创建射门数据生成器
List<Shot> shots = generateSampleData();
// 创建统计服务
ShotStatisticsService service = new ShotStatisticsService();
// 1. 显示所有射门记录
System.out.println("=== 射门事件列表 ===");
shots.forEach(System.out::println);
System.out.println();
// 2. 计算并显示详细统计
ShotStatistics statistics = service.calculateStatistics(shots);
System.out.println(statistics);
// 3. 显示禁区内外对比
System.out.println("\n=== 禁区内外射门次数对比 ===");
Map<String, Integer> comparison = service.getZoneComparison(shots);
comparison.forEach((zone, count) ->
System.out.printf("%s: %d次 %s%n",
zone, count,
"█".repeat(Math.min(count, 20))));
// 4. 显示球员统计
System.out.println("\n=== 球员射门统计 ===");
Map<String, Map<ShotZone, Integer>> playerStats = service.getPlayerStats(shots);
playerStats.forEach((player, zoneStats) -> {
System.out.println(player + ":");
zoneStats.forEach((zone, count) ->
System.out.printf(" - %s: %d次%n", zone.getDescription(), count));
});
// 5. 显示进球效率对比
System.out.println("\n=== 禁区内外进球效率对比 ===");
Map<String, String> efficiency = service.getGoalEfficiencyComparison(shots);
efficiency.forEach((zone, eff) ->
System.out.println(zone + ": " + eff));
}
/**
* 生成示例数据
*/
private static List<Shot> generateSampleData() {
List<Shot> shots = new ArrayList<>();
Random random = new Random(42); // 固定种子以便复现
String[] players = {"梅西", "C罗", "姆巴佩", "哈兰德", "内马尔"};
int[][] playerIds = {{1},{2},{3},{4},{5}};
// 生成50次射门
for (int i = 0; i < 50; i++) {
int playerIndex = random.nextInt(players.length);
int minute = random.nextInt(90) + 1;
double power = 40 + random.nextDouble() * 80;
// 随机决定位置 (70% 禁区内, 30% 禁区外)
ShotZone zone = random.nextDouble() < 0.7 ?
ShotZone.INSIDE_BOX : ShotZone.OUTSIDE_BOX;
// 根据位置生成坐标
double x, y;
if (zone == ShotZone.INSIDE_BOX) {
// 禁区内坐标 (假设标准球场，禁区宽40.32米)
x = 16.5 + random.nextDouble() * (40.32 - 16.5);
y = 7.32 + random.nextDouble() * (40.32 - 7.32);
} else {
// 禁区外坐标
x = 0 + random.nextDouble() * 50;
y = random.nextDouble() * 50;
}
// 随机射门结果，禁区外进球概率更低
double goalProbability = zone == ShotZone.INSIDE_BOX ? 0.3 : 0.15;
double onTargetProb = zone == ShotZone.INSIDE_BOX ? 0.5 : 0.35;
ShotResult result;
double rand = random.nextDouble();
if (rand < goalProbability) {
result = ShotResult.GOAL;
} else if (rand < goalProbability + onTargetProb) {
result = ShotResult.ON_TARGET;
} else if (rand < 0.9) {
result = ShotResult.OFF_TARGET;
} else {
result = ShotResult.BLOCKED;
}
shots.add(new Shot(
i + 1,
players[playerIndex],
zone,
result,
minute,
x, y,
power
));
}
return shots;
}
}
/**
* 命令行输出工具（美化结果）
*/
public static class ShotStatisticsPrinter {
public static void printComparisonChart(Map<String, Integer> comparison) {
System.out.println("\n射门次数对比图谱:");
int max = comparison.values().stream().max(Integer::compareTo).orElse(1);
comparison.forEach((zone, count) -> {
int barLength = (int) (count * 50.0 / max);
String bar = "█".repeat(barLength);
String percentage = String.format("%.1f%%", (count * 100.0) /
comparison.values().stream().mapToInt(Integer::intValue).sum());
System.out.printf("%-8s | %-50s | %3d次 (%s)%n",
zone, bar, count, percentage);
});
}
}
}
输出示例
=== 射门事件列表 ===
第12分钟 梅西 在禁区内 射正 (坐标: 18.3, 20.1, 射门力量: 85.2)
第23分钟 C罗 在禁区外 射偏 (坐标: 35.6, 15.4, 射门力量: 78.5)
第35分钟 姆巴佩 在禁区内 进球 (坐标: 12.5, 8.3, 射门力量: 92.1)
...
=== 射门统计报告 ===
【禁区内】
射门总数: 35次
进球数: 10个
转化率: 28.6%
射门结果: 进球 10次 射正 8次 射偏 14次 被挡 3次
平均射门力量: 76.3
【禁区外】
射门总数: 15次
进球数: 2个
转化率: 13.3%
射门结果: 进球 2次 射正 4次 射偏 8次 被挡 1次
平均射门力量: 88.7
=== 禁区内外射门次数对比 ===
禁区内: 35次 ████████████████████
禁区外: 15次 █████████功能特点
- 多维度统计：射门次数、进球数、转化率、射门结果分布
- 对比分析：禁区内外直接对比、球员对比
- 可视化输出：文本图表显示对比
- 灵活扩展：可添加更多统计维度和过滤条件
这个案例展示了如何用Java进行体育数据的统计分析,可根据实际需求调整和扩展。
