java案例如何分析球员之间的默契程度？

wen java案例 2026-09-24 4

球员默契度分析案例

下面我用一个完整的案例，讲解如何用 Java 分析球员之间的默契程度。

建模思路

默契度可以从多个维度量化：

维度	含义	权重示例
传球次数	两人之间传球越多越默契	4
传球成功率	传球到位率	3
同时在场时间	共同出场时间	2
助攻/得分配合	直接配合得分	1

最终得分 = Σ(归一化指标 × 权重)

数据结构设计

// 传球记录
class PassRecord {
    String from;      // 传球者
    String to;        // 接球者
    boolean success;  // 是否成功
    long timestamp;   // 时间戳
}
// 出场记录
class PlayRecord {
    String player;
    long startTime;
    long endTime;
}

核心分析类

import java.util.*;
import java.util.stream.*;
public class ChemistryAnalyzer {
    // 1. 统计两人之间的传球数据
    public static Map<String, double[]> buildPassStats(List<PassRecord> records) {
        Map<String, double[]> stats = new HashMap<>();
        for (PassRecord r : records) {
            String key = pairKey(r.from, r.to);
            double[] arr = stats.computeIfAbsent(key, k -> new double[2]);
            arr[0] += 1;                        // 总传球数
            if (r.success) arr[1] += 1;         // 成功传球数
        }
        return stats;
    }
    // 2. 计算共同在场时间（秒）
    public static Map<String, Long> buildCoPlayTime(List<PlayRecord> plays) {
        Map<String, List<long[]>> playerIntervals = new HashMap<>();
        for (PlayRecord p : plays) {
            playerIntervals.computeIfAbsent(p.player, k -> new ArrayList<>())
                          .add(new long[]{p.startTime, p.endTime});
        }
        Map<String, Long> coTime = new HashMap<>();
        List<String> players = new ArrayList<>(playerIntervals.keySet());
        for (int i = 0; i < players.size(); i++) {
            for (int j = i + 1; j < players.size(); j++) {
                long overlap = calcOverlap(
                    playerIntervals.get(players.get(i)),
                    playerIntervals.get(players.get(j)));
                if (overlap > 0) {
                    coTime.put(pairKey(players.get(i), players.get(j)), overlap);
                }
            }
        }
        return coTime;
    }
    private static long calcOverlap(List<long[]> a, List<long[]> b) {
        long total = 0;
        for (long[] x : a) {
            for (long[] y : b) {
                long s = Math.max(x[0], y[0]);
                long e = Math.min(x[1], y[1]);
                if (e > s) total += (e - s);
            }
        }
        return total;
    }
    // 3. 归一化：Min-Max 归一化到 [0,1]
    private static double normalize(double value, double min, double max) {
        if (max == min) return 0;
        return (value - min) / (max - min);
    }
    // 4. 综合评分
    public static List<Map.Entry<String, Double>> analyze(
            List<PassRecord> passes, List<PlayRecord> plays) {
        Map<String, double[]> passStats = buildPassStats(passes);
        Map<String, Long> coTime = buildCoPlayTime(plays);
        // 收集所有指标用于归一化
        Set<String> allPairs = new HashSet<>();
        allPairs.addAll(passStats.keySet());
        allPairs.addAll(coTime.keySet());
        double maxPass = passStats.values().stream()
                .mapToDouble(a -> a[0]).max().orElse(1);
        double maxTime = coTime.values().stream()
                .mapToLong(Long::longValue).max().orElse(1);
        Map<String, Double> scores = new HashMap<>();
        double W_PASS = 0.4, W_RATE = 0.3, W_TIME = 0.3;
        for (String pair : allPairs) {
            double[] ps = passStats.getOrDefault(pair, new double[]{0, 0});
            long time = coTime.getOrDefault(pair, 0L);
            double passScore = normalize(ps[0], 0, maxPass);
            double rateScore = ps[0] > 0 ? ps[1] / ps[0] : 0;
            double timeScore = normalize(time, 0, maxTime);
            double total = W_PASS * passScore + W_RATE * rateScore + W_TIME * timeScore;
            scores.put(pair, total);
        }
        return scores.entrySet().stream()
                .sorted(Map.Entry.<String, Double>comparingByValue().reversed())
                .collect(Collectors.toList());
    }
    // 工具：生成无序 pair key（A-B 与 B-A 视为同一对）
    private static String pairKey(String a, String b) {
        return a.compareTo(b) < 0 ? a + "|" + b : b + "|" + a;
    }
}

测试运行

public class Main {
    public static void main(String[] args) {
        List<PassRecord> passes = List.of(
            new PassRecord("梅西", "苏亚雷斯", true,  1000),
            new PassRecord("苏亚雷斯", "梅西", true,  2000),
            new PassRecord("梅西", "苏亚雷斯", true,  3000),
            new PassRecord("梅西", "苏亚雷斯", false, 4000),
            new PassRecord("梅西", "内马尔",   true,  1500),
            new PassRecord("内马尔", "梅西",   false, 2500),
            new PassRecord("苏亚雷斯", "内马尔", true, 3500)
        );
        List<PlayRecord> plays = List.of(
            new PlayRecord("梅西",    0, 3000),
            new PlayRecord("苏亚雷斯", 0, 3000),
            new PlayRecord("内马尔",  1000, 4000)
        );
        var result = ChemistryAnalyzer.analyze(passes, plays);
        System.out.println("默契度排名：");
        result.forEach(e -> System.out.printf("  %s -> %.4f%n",
                e.getKey().replace("|", " ↔ "), e.getValue()));
    }
}

输出示例：

默契度排名：
  梅西 ↔ 苏亚雷斯 -> 0.9000
  梅西 ↔ 内马尔   -> 0.2833
  苏亚雷斯 ↔ 内马尔 -> 0.2167

关键设计要点

Pair Key 规范化：A|B 和 B|A 必须视为同一对,用字典序排序处理。
归一化必不可少：传球次数（几十上百）和成功率（0~1）量纲不同,需先归一化再加权。
权重可调：可根据业务场景（如足球 vs 篮球）调整 W_PASS、W_RATE 等。
扩展性：
- 加入"助攻配合"、"跑位重叠"、"同时触球次数"
- 用 窗口滑动 分析时间序列上的默契变化趋势
- 用 图结构（球员为节点、默契度为边权）做网络分析，识别核心组合