java案例怎么看两队边路突破能力对比？

wen java案例 2026-11-09 2

Java 案例分析：两队边路突破能力对比

下面我用一个完整的 Java 案例来演示如何对比两支球队的边路突破能力。

场景设计

假设我们要对比球队的边路突破能力，关键指标包括：

指标	说明
边路突破次数	边路1v1成功过人次数
突破成功率	成功次数 / 尝试次数
传中次数	突破后传中数量
创造机会	突破后形成的射门机会
被抢断率	突破失败比例

数据模型

// 边路球员突破数据
public class WingBreakStats {
    private String teamName;
    private String playerName;
    private String side;          // LEFT / RIGHT
    private int attemptCount;     // 突破尝试次数
    private int successCount;     // 成功突破次数
    private int crossCount;       // 传中次数
    private int chanceCreated;    // 创造机会数
    public WingBreakStats(String teamName, String playerName, String side,
                          int attemptCount, int successCount,
                          int crossCount, int chanceCreated) {
        this.teamName = teamName;
        this.playerName = playerName;
        this.side = side;
        this.attemptCount = attemptCount;
        this.successCount = successCount;
        this.crossCount = crossCount;
        this.chanceCreated = chanceCreated;
    }
    // 突破成功率
    public double getSuccessRate() {
        return attemptCount == 0 ? 0 : (double) successCount / attemptCount * 100;
    }
    // 突破效率 = 创造机会 / 尝试次数
    public double getEfficiency() {
        return attemptCount == 0 ? 0 : (double) chanceCreated / attemptCount;
    }
    // getter 省略...
    public String getTeamName() { return teamName; }
    public String getSide() { return side; }
    public int getSuccessCount() { return successCount; }
    public int getCrossCount() { return crossCount; }
    public int getChanceCreated() { return chanceCreated; }
    public int getAttemptCount() { return attemptCount; }
}

球队汇总模型

public class TeamWingStats {
    private String teamName;
    private int totalAttempt;
    private int totalSuccess;
    private int totalCross;
    private int totalChance;
    // 综合评分（加权）
    public double getScore() {
        double successRate = totalAttempt == 0 ? 0 : (double) totalSuccess / totalAttempt;
        double chancePerAttempt = totalAttempt == 0 ? 0 : (double) totalChance / totalAttempt;
        // 权重可根据实际调整：成功率 60% + 转化 40%
        return successRate * 60 + chancePerAttempt * 40;
    }
    // 构造和 getter 省略...
}

核心分析代码

import java.util.*;
import java.util.stream.Collectors;
public class WingBreakAnalyzer {
    public static void main(String[] args) {
        // 模拟数据：A队 vs B队（左右边路各一名球员）
        List<WingBreakStats> data = Arrays.asList(
            // A队
            new WingBreakStats("TeamA", "A-左边锋", "LEFT",  12, 8, 6, 5),
            new WingBreakStats("TeamA", "A-右边锋", "RIGHT", 10, 5, 4, 2),
            // B队
            new WingBreakStats("TeamB", "B-左边锋", "LEFT",  15, 9, 8, 6),
            new WingBreakStats("TeamB", "B-右边锋", "RIGHT",  8, 3, 3, 1)
        );
        // 1. 按球队汇总
        Map<String, TeamWingStats> teamMap = data.stream()
            .collect(Collectors.groupingBy(
                WingBreakStats::getTeamName,
                Collectors.collectingAndThen(Collectors.toList(), list -> {
                    TeamWingStats t = new TeamWingStats();
                    t.setTeamName(list.get(0).getTeamName());
                    t.setTotalAttempt(list.stream().mapToInt(WingBreakStats::getAttemptCount).sum());
                    t.setTotalSuccess(list.stream().mapToInt(WingBreakStats::getSuccessCount).sum());
                    t.setTotalCross(list.stream().mapToInt(WingBreakStats::getCrossCount).sum());
                    t.setTotalChance(list.stream().mapToInt(WingBreakStats::getChanceCreated).sum());
                    return t;
                })
            ));
        // 2. 输出对比
        System.out.println("===== 边路突破能力对比 =====");
        teamMap.values().forEach(t -> {
            System.out.printf("%s: 尝试=%d, 成功=%d, 成功率=%.1f%%, 传中=%d, 创造机会=%d, 综合评分=%.2f%n",
                t.getTeamName(), t.getTotalAttempt(), t.getTotalSuccess(),
                t.getSuccessRate() * 100, t.getTotalCross(),
                t.getTotalChance(), t.getScore());
        });
        // 3. 分边路对比
        System.out.println("\n===== 分边路对比 =====");
        compareBySide(data, "LEFT");
        compareBySide(data, "RIGHT");
    }
    private static void compareBySide(List<WingBreakStats> data, String side) {
        System.out.println("--- " + side + " 边路 ---");
        data.stream()
            .filter(d -> d.getSide().equals(side))
            .forEach(d -> System.out.printf(
                "  %s [%s]: 成功率=%.1f%%, 突破效率=%.2f, 传中=%d, 创造机会=%d%n",
                d.getTeamName(), d.getPlayerName(),
                d.getSuccessRate(), d.getEfficiency(),
                d.getCrossCount(), d.getChanceCreated()));
    }
}

输出示例

===== 边路突破能力对比 =====
TeamA: 尝试=22, 成功=13, 成功率=59.1%, 传中=10, 创造机会=7, 综合评分=48.3
TeamB: 尝试=23, 成功=12, 成功率=52.2%, 传中=11, 创造机会=7, 综合评分=43.4
===== 分边路对比 =====
--- LEFT 边路 ---
  TeamA [A-左边锋]: 成功率=66.7%, 突破效率=0.42, 传中=6, 创造机会=5
  TeamB [B-左边锋]: 成功率=60.0%, 突破效率=0.40, 传中=8, 创造机会=6
--- RIGHT 边路 ---
  TeamA [A-右边锋]: 成功率=50.0%, 突破效率=0.20, 传中=4, 创造机会=2
  TeamB [B-右边锋]: 成功率=37.5%, 突破效率=0.13, 传中=3, 创造机会=1

从数据可读出：