java案例统计界外球进攻威胁次数？

本文目录导读：

1. 整体架构设计
2. 核心统计引擎
3. 高级分析扩展
4. 数据模拟和测试
5. 技术特性
6. 应用场景

我将为您设计一个统计足球比赛中界外球进攻威胁次数的Java案例,这个系统将分析和统计界外球发球后形成的进攻威胁。

整体架构设计

// 1. 基础实体类
public class ThrowInEvent {
    private int minute;           // 比赛时间（分钟）
    private int second;           // 比赛时间（秒）
    private String team;          // 球队名称
    private String area;          // 界外球区域（前场/中场/后场）
    private double distanceToGoal; // 离球门距离（米）
    private String playerName;    // 界外球球员
    private int throwDirection;   // 掷球方向（1=向前，0=横传，-1=向后）
    // getter/setter...
}
public class AttackThreat {
    private String team;
    private int totalThrowIns;          // 总界外球数
    private int threatAttacks;          // 威胁进攻次数
    private double threatRate;          // 威胁率
    private List<String> threatDetails; // 威胁详情
    // getter/setter...
}

核心统计引擎

public class ThrowInThreatAnalyzer {
    // 威胁判定条件
    private static final double THREAT_DISTANCE = 30.0;  // 距球门30米内
    private static final int THREAT_MINUTE = 85;          // 85分钟后为关键时间
    // 区域权重
    private static final Map<String, Double> AREA_WEIGHTS = Map.of(
        "前场", 1.5,
        "中场", 1.0,
        "后场", 0.7
    );
    public AttackThreat analyzeThrowInThreat(List<ThrowInEvent> events) {
        AttackThreat threat = new AttackThreat();
        List<ThrowInEvent> teamEvents = events;
        threat.setTotalThrowIns(teamEvents.size());
        // 统计威胁进攻
        List<String> threats = new ArrayList<>();
        int threatCount = 0;
        for (ThrowInEvent event : teamEvents) {
            if (isThreatAttack(event)) {
                threatCount++;
                threats.add(formatThreatDetail(event));
            }
        }
        threat.setThreatAttacks(threatCount);
        threat.setThreatRate(calculateThreatRate(threatCount, teamEvents.size()));
        threat.setThreatDetails(threats);
        return threat;
    }
    private boolean isThreatAttack(ThrowInEvent event) {
        // 判定标准1: 前场界外球且在危险区域
        boolean inDangerArea = event.getArea().equals("前场") && 
                              event.getDistanceToGoal() <= THREAT_DISTANCE;
        // 判定标准2: 关键时间段的界外球
        boolean keyTime = event.getMinute() >= THREAT_MINUTE;
        // 判定标准3: 向前方的掷球
        boolean forwardThrow = event.getThrowDirection() == 1;
        // 综合判定
        if (inDangerArea && forwardThrow) {
            return true;  // 前场危险区域的向前掷球
        }
        if (inDangerArea && keyTime) {
            return true;  // 前场危险区域的关键时间掷球
        }
        return false;
    }
    private double calculateThreatRate(int threats, int total) {
        return total == 0 ? 0 : (double) threats / total * 100;
    }
    private String formatThreatDetail(ThrowInEvent event) {
        return String.format("第%d分%d秒 - %s球员掷界外球，距球门%.1f米，方向：%s",
            event.getMinute(), event.getSecond(),
            event.getPlayerName(), event.getDistanceToGoal(),
            event.getThrowDirection() == 1 ? "向前" : "其他");
    }
}

高级分析扩展

public class AdvancedThreatAnalyzer {
    // 按照多维度分析威胁
    public Map<String, Object> analyzeDetailedThreat(List<ThrowInEvent> events) {
        Map<String, Object> result = new HashMap<>();
        // 1. 时间段分析
        Map<String, Integer> timeBasedThreat = analyzeByTimePeriod(events);
        result.put("时间段威胁分布", timeBasedThreat);
        // 2. 区域分析
        Map<String, Integer> areaBasedThreat = analyzeByArea(events);
        result.put("区域威胁分布", areaBasedThreat);
        // 3. 连续进攻威胁（5分钟内连续前场界外球）
        List<List<ThrowInEvent>> consecutiveThreats = findConsecutiveThreats(events);
        result.put("连续进攻威胁", formatConsecutiveThreats(consecutiveThreats));
        // 4. 威胁得分计算
        result.put("威胁指数", calculateThreatScore(events));
        return result;
    }
    private Map<String, Integer> analyzeByTimePeriod(List<ThrowInEvent> events) {
        Map<String, Integer> distribution = new HashMap<>();
        distribution.put("开场0-15分钟", 0);
        distribution.put("16-45分钟", 0);
        distribution.put("46-70分钟", 0);
        distribution.put("71-90分钟", 0);
        for (ThrowInEvent event : events) {
            String period = getTimePeriod(event.getMinute());
            if (isThreatEvent(event)) {
                distribution.merge(period, 1, Integer::sum);
            }
        }
        return distribution;
    }
    private List<List<ThrowInEvent>> findConsecutiveThreats(List<ThrowInEvent> events) {
        List<List<ThrowInEvent>> consecutiveGroups = new ArrayList<>();
        List<ThrowInEvent> currentGroup = new ArrayList<>();
        for (ThrowInEvent event : events) {
            // 逻辑：如果连续的前场界外球在短时间内
            if (isConsecutive(event, currentGroup)) {
                currentGroup.add(event);
            } else {
                if (currentGroup.size() >= 2 && hasThreat(currentGroup)) {
                    consecutiveGroups.add(new ArrayList<>(currentGroup));
                }
                currentGroup.clear();
                currentGroup.add(event);
            }
        }
        // 处理最后一组
        if (currentGroup.size() >= 2 && hasThreat(currentGroup)) {
            consecutiveGroups.add(currentGroup);
        }
        return consecutiveGroups;
    }
}

数据模拟和测试

public class ThreatAnalysisDemo {
    public static void main(String[] args) {
        // 模拟一场比赛的界外球数据
        List<ThrowInEvent> events = generateMatchEvents();
        // 基础分析
        ThrowInThreatAnalyzer basicAnalyzer = new ThrowInThreatAnalyzer();
        AttackThreat teamAThreat = basicAnalyzer.analyzeThrowInThreat(
            events.stream().filter(e -> e.getTeam().equals("Team A")).toList()
        );
        System.out.println("=== Team A 界外球威胁分析 ===");
        System.out.println("总界外球数: " + teamAThreat.getTotalThrowIns());
        System.out.println("威胁进攻次数: " + teamAThreat.getThreatAttacks());
        System.out.printf("威胁率: %.1f%%\n", teamAThreat.getThreatRate());
        // 显示具体威胁事件
        if (!teamAThreat.getThreatDetails().isEmpty()) {
            System.out.println("\n具体威胁事件:");
            teamAThreat.getThreatDetails().forEach(System.out::println);
        }
        // 高级分析
        AdvancedThreatAnalyzer advancedAnalyzer = new AdvancedThreatAnalyzer();
        Map<String, Object> detailedAnalysis = advancedAnalyzer.analyzeDetailedThreat(events);
        printAnalysisReport(detailedAnalysis);
    }
    private static List<ThrowInEvent> generateMatchEvents() {
        List<ThrowInEvent> events = new ArrayList<>();
        Random random = new Random();
        String[] players = {"Messi", "Ronaldo", "Neymar", "Mbappe", "Haaland"};
        for (int i = 0; i < 30; i++) {
            ThrowInEvent event = new ThrowInEvent();
            event.setMinute(random.nextInt(90) + 1);
            event.setSecond(random.nextInt(60));
            event.setTeam(random.nextBoolean() ? "Team A" : "Team B");
            event.setArea(getRandomArea());
            event.setDistanceToGoal(5 + random.nextInt(80));
            event.setThrowDirection(random.nextInt(3) - 1);
            event.setPlayerName(players[random.nextInt(players.length)]);
            events.add(event);
        }
        // 添加一些确定的高威胁事件
        addHighThreatEvent(events, 89, 5, "Messi", "Team A");
        addHighThreatEvent(events, 88, 5, "Ronaldo", "Team A");
        addHighThreatEvent(events, 90, 5, "Mbappe", "Team B");
        return events;
    }
    private static void addHighThreatEvent(List<ThrowInEvent> events, 
                                         int minute, int second, 
                                         String player, String team) {
        ThrowInEvent event = new ThrowInEvent();
        event.setMinute(minute);
        event.setSecond(second);
        event.setTeam(team);
        event.setArea("前场");
        event.setDistanceToGoal(10);
        event.setThrowDirection(1);
        event.setPlayerName(player);
        events.add(event);
    }
    private static void printAnalysisReport(Map<String, Object> analysis) {
        System.out.println("\n=== 高级威胁分析报告 ===");
        // 打印时间段分布
        @SuppressWarnings("unchecked")
        Map<String, Integer> timeDist = (Map<String, Integer>) analysis.get("时间段威胁分布");
        timeDist.forEach((period, count) -> 
            System.out.printf("  %s: %d次威胁\n", period, count));
        // 打印威胁指数
        System.out.println("威胁指数: " + analysis.get("威胁指数"));
    }
}

技术特性

1. 多维度分析：时间、区域、连续进攻等
2. 实时统计：可以实时更新数据
3. 可视化友好：输出格式便于展示
4. 可扩展性：易于添加新的判定规则

应用场景

• 足球比赛技术统计
• 教练战术分析
• 体育数据新闻报道
• 训练效果评估

这个系统通过量化界外球的进攻威胁,为教练和分析师提供数据支持，帮助评估球队的进攻效率和战术执行情况。