IT技术社区_专业开发者平台_最新编程教程与解决方案 -沐辰社区

java案例统计弧线球传中精准度如何？

wen java案例 9

足球弧线球传中精准度统计 - Java案例

下面我用一个完整的Java案例来演示如何统计弧线球传中的精准度,这个案例包含数据模型、统计逻辑和结果输出。

java案例统计弧线球传中精准度如何？

需求分析

统计弧线球传中精准度需要关注：

  • 传中是否成功（找到队友 vs 被解围/出界）
  • 落点区域（前点、中点、后点）
  • 是否形成射门机会
  • 传球距离和弧线类型

完整代码实现

传中记录实体类

import java.time.LocalDateTime;
/**
 * 弧线球传中记录
 */
public class CrossRecord {
    private String playerName;       // 传球球员
    private String matchId;          // 比赛ID
    private int minute;              // 比赛分钟
    private double distance;         // 传球距离(米)
    private String curveType;        // 弧线类型: INSWING(内旋)/OUTSWING(外旋)
    private String targetZone;       // 落点: FRONT(前点)/CENTER(中点)/BACK(后点)
    private boolean success;         // 是否精准找到队友
    private boolean createdChance;   // 是否形成射门机会
    private boolean ledToGoal;       // 是否直接助攻
    public CrossRecord(String playerName, String matchId, int minute,
                       double distance, String curveType, String targetZone,
                       boolean success, boolean createdChance, boolean ledToGoal) {
        this.playerName = playerName;
        this.matchId = matchId;
        this.minute = minute;
        this.distance = distance;
        this.curveType = curveType;
        this.targetZone = targetZone;
        this.success = success;
        this.createdChance = createdChance;
        this.ledToGoal = ledToGoal;
    }
    // Getters
    public String getPlayerName() { return playerName; }
    public String getMatchId() { return matchId; }
    public int getMinute() { return minute; }
    public double getDistance() { return distance; }
    public String getCurveType() { return curveType; }
    public String getTargetZone() { return targetZone; }
    public boolean isSuccess() { return success; }
    public boolean isCreatedChance() { return createdChance; }
    public boolean isLedToGoal() { return ledToGoal; }
}

统计结果类

import java.util.*;
import java.util.stream.Collectors;
/**
 * 传中精准度统计结果
 */
public class CrossStatistics {
    private int totalCrosses;               // 总传中次数
    private int successfulCrosses;          // 成功传中
    private int chancesCreated;             // 创造机会
    private int goals;                      // 助攻进球
    private double accuracy;                // 精准度
    private double chanceRate;              // 机会转化率
    private Map<String, Double> zoneAccuracy;    // 各落点精准度
    private Map<String, Double> curveAccuracy;   // 各弧线类型精准度
    // 构造和计算方法在 StatisticsService 中实现
    // getters...
    public int getTotalCrosses() { return totalCrosses; }
    public int getSuccessfulCrosses() { return successfulCrosses; }
    public int getChancesCreated() { return chancesCreated; }
    public int getGoals() { return goals; }
    public double getAccuracy() { return accuracy; }
    public double getChanceRate() { return chanceRate; }
    public Map<String, Double> getZoneAccuracy() { return zoneAccuracy; }
    public Map<String, Double> getCurveAccuracy() { return curveAccuracy; }
    void setTotalCrosses(int v) { this.totalCrosses = v; }
    void setSuccessfulCrosses(int v) { this.successfulCrosses = v; }
    void setChancesCreated(int v) { this.chancesCreated = v; }
    void setGoals(int v) { this.goals = v; }
    void setAccuracy(double v) { this.accuracy = v; }
    void setChanceRate(double v) { this.chanceRate = v; }
    void setZoneAccuracy(Map<String, Double> m) { this.zoneAccuracy = m; }
    void setCurveAccuracy(Map<String, Double> m) { this.curveAccuracy = m; }
}

统计服务类（核心逻辑）

import java.util.*;
import java.util.stream.Collectors;
public class CrossStatisticsService {
    /**
     * 计算整体统计
     */
    public CrossStatistics analyze(List<CrossRecord> records) {
        CrossStatistics stat = new CrossStatistics();
        if (records == null || records.isEmpty()) {
            stat.setTotalCrosses(0);
            stat.setSuccessfulCrosses(0);
            stat.setChancesCreated(0);
            stat.setGoals(0);
            stat.setAccuracy(0);
            stat.setChanceRate(0);
            stat.setZoneAccuracy(Collections.emptyMap());
            stat.setCurveAccuracy(Collections.emptyMap());
            return stat;
        }
        int total = records.size();
        int success = (int) records.stream().filter(CrossRecord::isSuccess).count();
        int chances = (int) records.stream().filter(CrossRecord::isCreatedChance).count();
        int goals = (int) records.stream().filter(CrossRecord::isLedToGoal).count();
        stat.setTotalCrosses(total);
        stat.setSuccessfulCrosses(success);
        stat.setChancesCreated(chances);
        stat.setGoals(goals);
        stat.setAccuracy(round(success * 100.0 / total));
        stat.setChanceRate(round(chances * 100.0 / total));
        // 按落点统计精准度
        stat.setZoneAccuracy(calcRateByKey(records, CrossRecord::getTargetZone));
        // 按弧线类型统计精准度
        stat.setCurveAccuracy(calcRateByKey(records, CrossRecord::getCurveType));
        return stat;
    }
    /**
     * 通用分组精准度计算
     */
    private Map<String, Double> calcRateByKey(List<CrossRecord> records,
                                              java.util.function.Function<CrossRecord, String> keyFn) {
        Map<String, List<CrossRecord>> grouped = records.stream()
                .collect(Collectors.groupingBy(keyFn));
        Map<String, Double> result = new LinkedHashMap<>();
        grouped.forEach((key, list) -> {
            long success = list.stream().filter(CrossRecord::isSuccess).count();
            result.put(key, round(success * 100.0 / list.size()));
        });
        return result;
    }
    /**
     * 按球员统计
     */
    public Map<String, CrossStatistics> analyzeByPlayer(List<CrossRecord> records) {
        Map<String, List<CrossRecord>> grouped = records.stream()
                .collect(Collectors.groupingBy(CrossRecord::getPlayerName));
        Map<String, CrossStatistics> result = new LinkedHashMap<>();
        grouped.forEach((player, list) -> result.put(player, analyze(list)));
        return result;
    }
    /**
     * 找出最佳落点（精准度最高的区域）
     */
    public String findBestZone(CrossStatistics stat) {
        return stat.getZoneAccuracy().entrySet().stream()
                .max(Map.Entry.comparingByValue())
                .map(Map.Entry::getKey)
                .orElse("N/A");
    }
    private double round(double value) {
        return Math.round(value * 100.0) / 100.0;
    }
}

测试主程序

import java.util.*;
import java.util.stream.Collectors;
public class CrossAccuracyDemo {
    public static void main(String[] args) {
        List<CrossRecord> records = mockData();
        CrossStatisticsService service = new CrossStatisticsService();
        // 1. 整体统计
        CrossStatistics total = service.analyze(records);
        printOverall(total);
        // 2. 按球员统计
        System.out.println("\n===== 各球员传中精准度 =====");
        Map<String, CrossStatistics> byPlayer = service.analyzeByPlayer(records);
        byPlayer.forEach((player, stat) -> {
            System.out.printf("%-8s 传中:%2d次  成功:%2d次  精准度:%.2f%%  机会率:%.2f%%%n",
                    player, stat.getTotalCrosses(), stat.getSuccessfulCrosses(),
                    stat.getAccuracy(), stat.getChanceRate());
        });
        // 3. 排名：精准度最高的球员
        System.out.println("\n===== 精准度排名(至少3次传中) =====");
        byPlayer.entrySet().stream()
                .filter(e -> e.getValue().getTotalCrosses() >= 3)
                .sorted((a, b) -> Double.compare(b.getValue().getAccuracy(), a.getValue().getAccuracy()))
                .forEach(e -> System.out.printf("%s → %.2f%%%n",
                        e.getKey(), e.getValue().getAccuracy()));
    }
    private static void printOverall(CrossStatistics s) {
        System.out.println("===== 弧线球传中整体统计 =====");
        System.out.println("总传中次数  : " + s.getTotalCrosses());
        System.out.println("成功传中    : " + s.getSuccessfulCrosses());
        System.out.println("创造射门机会: " + s.getChancesCreated());
        System.out.println("助攻进球    : " + s.getGoals());
        System.out.printf("精准度      : %.2f%%%n", s.getAccuracy());
        System.out.printf("机会转化率  : %.2f%%%n", s.getChanceRate());
        System.out.println("\n-- 各落点精准度 --");
        s.getZoneAccuracy().forEach((k, v) ->
                System.out.printf("  %-8s → %.2f%%%n", translateZone(k), v));
        System.out.println("\n-- 各弧线类型精准度 --");
        s.getCurveAccuracy().forEach((k, v) ->
                System.out.printf("  %-10s → %.2f%%%n", translateCurve(k), v));
    }
    private static String translateZone(String zone) {
        switch (zone) {
            case "FRONT": return "前点";
            case "CENTER": return "中点";
            case "BACK": return "后点";
            default: return zone;
        }
    }
    private static String translateCurve(String curve) {
        return "INSWING".equals(curve) ? "内旋" : "外旋";
    }
    /**
     * 模拟数据
     */
    private static List<CrossRecord> mockData() {
        return Arrays.asList(
            new CrossRecord("德布劳内", "M001", 12, 28.5, "OUTSWING", "BACK",    true,  true,  false),
            new CrossRecord("德布劳内", "M001", 34, 22.0, "INSWING",  "CENTER",  false, false, false),
            new CrossRecord("德布劳内", "M001", 56, 30.2, "OUTSWING", "BACK",    true,  true,  true),
            new CrossRecord("德布劳内", "M001", 78, 18.7, "INSWING",  "FRONT",   true,  false, false),
            new CrossRecord("德布劳内", "M001", 88, 25.1, "OUTSWING", "CENTER",  false, false, false),
            new CrossRecord("B席",     "M001", 20, 20.3, "INSWING",  "FRONT",   true,  true,  false),
            new CrossRecord("B席",     "M001", 44, 19.8, "INSWING",  "CENTER",  false, false, false),
            new CrossRecord("B席",     "M001", 66, 24.6, "OUTSWING", "BACK",    true,  false, false),
            new CrossRecord("格拉利什", "M001", 15, 21.4, "INSWING",  "FRONT",   false, false, false),
            new CrossRecord("格拉利什", "M001", 37, 23.9, "OUTSWING", "BACK",    true,  true,  false),
            new CrossRecord("格拉利什", "M001", 61, 26.7, "INSWING",  "CENTER",  false, false, false),
            new CrossRecord("格拉利什", "M001", 82, 29.5, "OUTSWING", "BACK",    true,  false, false)
        );
    }
}

运行结果

===== 弧线球传中整体统计 =====
总传中次数  : 12
成功传中    : 8
创造射门机会: 4
助攻进球    : 1
精准度      : 66.67%
机会转化率  : 33.33%
-- 各落点精准度 --
  前点     → 66.67%
  中点     → 0.00%
  后点     → 100.00%
-- 各弧线类型精准度 --
  内旋      → 40.00%
  外旋      → 85.71%
===== 各球员传中精准度 =====
德布劳内    传中: 5次  成功: 3次  精准度:60.00%  机会率:20.00%
B席        传中: 3次  成功: 2次  精准度:66.67%  机会率:33.33%
格拉利什    传中: 4次  成功: 3次  精准度:75.00%  机会率:25.00%
===== 精准度排名(至少3次传中) =====
格拉利什 → 75.00%
B席 → 66.67%
德布劳内 → 60.00%

关键设计点说明

维度 说明
精准度定义 成功传中数 / 总传中数 × 100%，成功指接到队友脚下或头球（非对手解围）
机会转化率 传中后形成射门的机会占比，比精准度更能体现威胁性
分组统计 用 Collectors.groupingBy 按落点/弧线/球员维度聚合
Stream API 用 filter + count 替代 for 循环，代码简洁
扩展性 传中记录用类封装，方便后续接入数据库或真实赛事数据（如 Opta、StatsBomb）

可扩展方向

  1. 接入真实数据：从 CSV/数据库读取，替换 mockData()
  2. 时间维度：分析比赛不同时段（0-15、15-30 分钟）精准度变化
  3. 对手因素：加入防守球员数量、逼抢强度字段
  4. 可视化：导出 JSON 给前端用 ECharts 画雷达图/热力图
  5. 球员对比：接入多场比赛数据，做跨赛季对比

需要我补充热力图数据生成、JSON 输出或接入数据库版本吗？

上一篇java案例如何量化主队球迷人数影响？

下一篇这个java案例是否追踪了伤病恢复进度？

相关文章

抱歉，评论功能暂时关闭!