java案例统计反越位成功形成单刀几次？

wen java案例 2026-08-19 152

本文目录导读：

版本一：简单命令行版
版本二：面向对象版（更完整）
运行说明
规则说明

简单命令行版

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class OffsideAnalysisSimple {
    public static void main(String[] args) {
        System.out.println("=== 反越位单刀统计系统 ===");
        System.out.println("请输入比赛事件，格式为：");
        System.out.println("  [球员名称] [动作]");
        System.out.println("动作说明：");
        System.out.println("  A - 尝试反越位插上");
        System.out.println("  S - 形成单刀");
        System.out.println("  F - 越位犯规");
        System.out.println("  G - 进球");
        System.out.println("输入 'end' 结束。");
        System.out.println("-----------------------------------");
        List<String[]> events = new ArrayList<>();
        Scanner scanner = new Scanner(System.in);
        while (true) {
            System.out.print("输入事件: ");
            String input = scanner.nextLine().trim();
            if ("end".equalsIgnoreCase(input)) {
                break;
            }
            String[] parts = input.split("\\s+");
            if (parts.length < 2) {
                System.out.println("格式错误，请重新输入！");
                continue;
            }
            events.add(parts);
        }
        scanner.close();
        int successful = countSuccessful(events);
        System.out.println("-----------------------------------");
        System.out.println("反越位成功形成单刀次数: " + successful);
    }
    /**
     * 统计反越位成功形成单刀的次数
     * 逻辑：A触发后，下一次出现S则算1次成功，出现F则算失败
     */
    public static int countSuccessful(List<String[]> events) {
        int successCount = 0;
        boolean attempted = false;   // 是否有反越位尝试
        for (String[] event : events) {
            String action = event[1].toUpperCase();
            if ("A".equals(action)) {
                attempted = true;
            } else if (attempted && "S".equals(action)) {
                successCount++;
                attempted = false;
            } else if (attempted && "F".equals(action)) {
                // 越位失败，重置状态
                attempted = false;
            } else if (attempted && "G".equals(action)) {
                // 也统计在成功单刀后进球
                successCount++;
                attempted = false;
            }
        }
        return successCount;
    }
}

面向对象版（更完整）

import java.time.LocalTime;
import java.util.*;
public class OffsideAnalysis {
    // 事件模型类
    static class MatchEvent {
        int minute;          // 比赛时间(分钟)
        String player;       // 球员
        String action;       // 动作
        String detail;       // 描述
        MatchEvent(int minute, String player, String action, String detail) {
            this.minute = minute;
            this.player = player;
            this.action = action;
            this.detail = detail;
        }
        @Override
        public String toString() {
            return String.format("[%02d'] %s - %s (%s)", minute, player, action, detail);
        }
    }
    // 定义动作常量
    static final String ACTION_ATTEMPT = "ATTACK";       // 反越位插上
    static final String ACTION_ONE_ON_ONE = "ONE_ON_ONE"; // 形成单刀
    static final String ACTION_OFFSIDE = "OFFSIDE";       // 越位犯规
    static final String ACTION_GOAL = "GOAL";             // 进球
    static final String ACTION_SAVE = "SAVE";             // 射门被扑
    // 分析引擎
    static class AnalysisEngine {
        private int successfulCount = 0;  // 成功单刀次数
        private int failedCount = 0;      // 失败次数
        private boolean waitingForOutcome = false;  // 是否在等待成功/失败
        private List<MatchEvent> currentSuccessEvents = new ArrayList<>();
        private List<MatchEvent> allSuccessSeq = new ArrayList<>();
        public void processEvent(MatchEvent event) {
            // 开始一次新的进攻尝试
            if (event.action.equals(ACTION_ATTEMPT)) {
                waitingForOutcome = true;
                currentSuccessEvents.clear();
                currentSuccessEvents.add(event);
                return;
            }
            // 如果当前在等待结果
            if (waitingForOutcome) {
                currentSuccessEvents.add(event);
                if (event.action.equals(ACTION_ONE_ON_ONE)) {
                    // 形成单刀
                    successfulCount++;
                    allSuccessSeq.addAll(new ArrayList<>(currentSuccessEvents));
                    printSuccessSequence(currentSuccessEvents);
                    waitingForOutcome = false;
                } else if (event.action.equals(ACTION_OFFSIDE)) {
                    // 越位失败
                    failedCount++;
                    waitingForOutcome = false;
                } else if (event.action.equals(ACTION_GOAL)) {
                    // 进球（单刀成功+1）
                    successfulCount++;
                    allSuccessSeq.addAll(new ArrayList<>(currentSuccessEvents));
                    printSuccessSequence(currentSuccessEvents);
                    waitingForOutcome = false;
                } else if (event.action.equals(ACTION_SAVE)) {
                    // 如果没有后续动作，当作失败，但这里可以根据规则处理
                    // 这里简单把单刀前被扑救也视作失败
                    failedCount++;
                    waitingForOutcome = false;
                }
            }
        }
        private void printSuccessSequence(List<MatchEvent> events) {
            System.out.println("  成功序列: ");
            for (MatchEvent e : events) {
                System.out.println("    " + e);
            }
            System.out.println();
        }
        public void printReport() {
            System.out.println("\n===== 分析报告 =====");
            System.out.println("反越位成功形成单刀次数: " + successfulCount);
            System.out.println("反越位失败(越位)次数: " + failedCount);
            double successRate = (successfulCount + failedCount) > 0 ? 
                    (double) successfulCount / (successfulCount + failedCount) * 100 : 0;
            System.out.printf("成功率: %.1f%%\n", successRate);
        }
    }
    public static void main(String[] args) {
        // ---------- 构造测试数据 ----------
        List<MatchEvent> events = new ArrayList<>();
        // 模拟一场比赛
        events.add(new MatchEvent(12, "梅西", ACTION_ATTEMPT, "反越位跑位"));
        events.add(new MatchEvent(12, "梅西", ACTION_ONE_ON_ONE, "接到直塞，单刀面对门将"));
        events.add(new MatchEvent(35, "姆巴佩", ACTION_ATTEMPT, "反越位冲入禁区"));
        events.add(new MatchEvent(35, "姆巴佩", ACTION_OFFSIDE, "裁判示意越位"));
        events.add(new MatchEvent(50, "C罗", ACTION_ATTEMPT, "反越位斜插"));
        events.add(new MatchEvent(50, "C罗", ACTION_ONE_ON_ONE, "单刀射门"));
        events.add(new MatchEvent(50, "C罗", ACTION_GOAL, "球进了!"));
        events.add(new MatchEvent(67, "哈兰德", ACTION_ATTEMPT, "反越位禁区外"));
        events.add(new MatchEvent(67, "哈兰德", ACTION_ONE_ON_ONE, "长驱直入"));
        events.add(new MatchEvent(67, "哈兰德", ACTION_SAVE, "单刀被扑出"));
        events.add(new MatchEvent(78, "萨拉赫", ACTION_ATTEMPT, "反越位切入"));
        events.add(new MatchEvent(78, "萨拉赫", ACTION_ONE_ON_ONE, "形成单刀"));
        events.add(new MatchEvent(78, "萨拉赫", ACTION_GOAL, "推射破门"));
        events.add(new MatchEvent(89, "凯恩", ACTION_ATTEMPT, "反越位"));
        events.add(new MatchEvent(89, "凯恩", ACTION_ONE_ON_ONE, "单刀打偏"));
        events.add(new MatchEvent(89, "凯恩", ACTION_OFFSIDE, "实际上越位了（裁判回看VAR）"));
        // ---------- 运行分析 ----------
        System.out.println("========== 实时事件分析 ==========");
        AnalysisEngine engine = new AnalysisEngine();
        for (MatchEvent event : events) {
            System.out.println("处理事件: " + event);
            engine.processEvent(event);
        }
        engine.printReport();
        // ---------- 统计所有单刀数据的原始数据也很重要 ----------
        System.out.println("\n===== 所有事件记录 =====");
        for (MatchEvent event : events) {
            System.out.println(event);
        }
    }
}

运行说明

版本一使用方式：

=== 反越位单刀统计系统 ===
请输入比赛事件，格式为：
  [球员名称] [动作]
动作说明：
  A - 尝试反越位插上
  S - 形成单刀
  F - 越位犯规
  G - 进球
输入 'end' 结束。
-----------------------------------
输入事件: 梅西 A
输入事件: 梅西 S
输入事件: 姆巴佩 A
输入事件: 姆巴佩 F
输入事件: end
-----------------------------------
反越位成功形成单刀次数: 1

版本二输出示例：

========== 实时事件分析 ==========
处理事件: [12'] 梅西 - ATTACK (反越位跑位)
处理事件: [12'] 梅西 - ONE_ON_ONE (接到直塞，单刀面对门将)
  成功序列: 
    [12'] 梅西 - ATTACK (反越位跑位)
    [12'] 梅西 - ONE_ON_ONE (接到直塞，单刀面对门将)
处理事件: [35'] 姆巴佩 - ATTACK (反越位冲入禁区)
处理事件: [35'] 姆巴佩 - OFFSIDE (裁判示意越位)
...
===== 分析报告 =====
反越位成功形成单刀次数: 3
反越位失败(越位)次数: 2
成功率: 60.0%