java案例统计门球短传配合成功率？

本文目录导读：

1. 实现代码
2. 功能说明
3. 运行示例输出

我来为您创建一个门球短传配合成功率的统计案例,这个案例将模拟门球比赛中球员之间的短传配合数据统计。

实现代码

import java.util.*;
import java.text.SimpleDateFormat;
import java.text.DecimalFormat;
/**
 * 门球短传配合成功率统计系统
 */
public class GateBallPassStatistic {
    // 球员类
    static class Player {
        private String id;
        private String name;
        private String position; // 位置：前锋、中场、后卫
        public Player(String id, String name, String position) {
            this.id = id;
            this.name = name;
            this.position = position;
        }
        public String getId() { return id; }
        public String getName() { return name; }
        public String getPosition() { return position; }
        @Override
        public String toString() {
            return String.format("%s(%s-%s)", name, position, id);
        }
    }
    // 传球记录类
    static class PassRecord {
        private Player passer;      // 传球球员
        private Player receiver;    // 接球球员
        private boolean successful; // 是否成功
        private Date time;          // 传球时间
        private double distance;    // 传球距离（米）
        public PassRecord(Player passer, Player receiver, boolean successful, double distance) {
            this.passer = passer;
            this.receiver = receiver;
            this.successful = successful;
            this.time = new Date();
            this.distance = distance;
        }
        public Player getPasser() { return passer; }
        public Player getReceiver() { return receiver; }
        public boolean isSuccessful() { return successful; }
        public Date getTime() { return time; }
        public double getDistance() { return distance; }
    }
    // 统计数据类
    static class PlayerStat {
        private Player player;
        private int totalPasses;      // 总传球次数
        private int successfulPasses; // 成功传球次数
        private int totalReceives;    // 总接球次数
        private int successfulReceives; // 成功接球次数
        private Map<String, PassPairStat> pairStats; // 与不同队友的配合统计
        public PlayerStat(Player player) {
            this.player = player;
            this.totalPasses = 0;
            this.successfulPasses = 0;
            this.totalReceives = 0;
            this.successfulReceives = 0;
            this.pairStats = new HashMap<>();
        }
        // 记录传球
        public void recordPass(boolean success, Player receiver) {
            totalPasses++;
            if (success) {
                successfulPasses++;
            }
            // 更新配对统计
            String pairKey = receiver.getId();
            PassPairStat pairStat = pairStats.computeIfAbsent(pairKey, 
                k -> new PassPairStat(player, receiver));
            pairStat.recordPass(success);
        }
        // 记录接球
        public void recordReceive(boolean success) {
            totalReceives++;
            if (success) {
                successfulReceives++;
            }
        }
        public double getPassSuccessRate() {
            return totalPasses == 0 ? 0 : (double) successfulPasses / totalPasses * 100;
        }
        public double getReceiveSuccessRate() {
            return totalReceives == 0 ? 0 : (double) successfulReceives / totalReceives * 100;
        }
        public int getTotalPasses() { return totalPasses; }
        public int getSuccessfulPasses() { return successfulPasses; }
        public int getTotalReceives() { return totalReceives; }
        public int getSuccessfulReceives() { return successfulReceives; }
        public Player getPlayer() { return player; }
        public Map<String, PassPairStat> getPairStats() { return pairStats; }
    }
    // 配对统计类
    static class PassPairStat {
        private Player passer;
        private Player receiver;
        private int totalPasses;
        private int successfulPasses;
        public PassPairStat(Player passer, Player receiver) {
            this.passer = passer;
            this.receiver = receiver;
            this.totalPasses = 0;
            this.successfulPasses = 0;
        }
        public void recordPass(boolean success) {
            totalPasses++;
            if (success) {
                successfulPasses++;
            }
        }
        public double getSuccessRate() {
            return totalPasses == 0 ? 0 : (double) successfulPasses / totalPasses * 100;
        }
        public int getTotalPasses() { return totalPasses; }
        public int getSuccessfulPasses() { return successfulPasses; }
    }
    // 统计系统类
    static class StatisticSystem {
        private Map<String, Player> players;
        private List<PassRecord> passRecords;
        private Map<String, PlayerStat> playerStats;
        private Random random;
        private DecimalFormat df;
        public StatisticSystem() {
            this.players = new HashMap<>();
            this.passRecords = new ArrayList<>();
            this.playerStats = new HashMap<>();
            this.random = new Random();
            this.df = new DecimalFormat("#.##");
            initializePlayers();
        }
        // 初始化球队球员
        private void initializePlayers() {
            // 前锋
            addPlayer("P001", "王强", "前锋");
            addPlayer("P002", "李明", "前锋");
            // 中场
            addPlayer("P003", "张伟", "中场");
            addPlayer("P004", "刘洋", "中场");
            addPlayer("P005", "陈杰", "中场");
            // 后卫
            addPlayer("P006", "赵磊", "后卫");
            addPlayer("P007", "孙浩", "后卫");
            addPlayer("P008", "周宇", "后卫");
        }
        private void addPlayer(String id, String name, String position) {
            Player player = new Player(id, name, position);
            players.put(id, player);
            playerStats.put(id, new PlayerStat(player));
        }
        // 记录一次传球
        public void recordPass(String passerId, String receiverId, boolean success, double distance) {
            Player passer = players.get(passerId);
            Player receiver = players.get(receiverId);
            if (passer == null || receiver == null) {
                System.out.println("球员不存在！");
                return;
            }
            // 记录传球
            PassRecord record = new PassRecord(passer, receiver, success, distance);
            passRecords.add(record);
            // 更新统计数据
            PlayerStat passerStat = playerStats.get(passerId);
            PlayerStat receiverStat = playerStats.get(receiverId);
            passerStat.recordPass(success, receiver);
            receiverStat.recordReceive(success);
        }
        // 模拟一场比赛
        public void simulateMatch(int passCount) {
            System.out.println("\n========== 比赛模拟开始 ==========");
            System.out.println("预计传球次数：" + passCount);
            List<String> playerIds = new ArrayList<>(players.keySet());
            for (int i = 0; i < passCount; i++) {
                // 随机选择发球员和接球员
                String passerId = playerIds.get(random.nextInt(playerIds.size()));
                String receiverId;
                do {
                    receiverId = playerIds.get(random.nextInt(playerIds.size()));
                } while (receiverId.equals(passerId));
                // 随机成功率（模拟真实比赛，成功率在60%-85%之间）
                double successRate = 0.60 + random.nextDouble() * 0.25;
                boolean success = random.nextDouble() < successRate;
                // 随机传球距离（5-15米为短传）
                double distance = 5 + random.nextDouble() * 10;
                recordPass(passerId, receiverId, success, distance);
            }
            System.out.println("========== 比赛模拟结束 ==========\n");
        }
        // 打印球员统计
        public void printPlayerStatistics() {
            System.out.println("========== 球员个人统计 ==========");
            System.out.println("┌──────┬────────┬────────┬────────┬──────────┬────────────┬────────────┐");
            System.out.println("│ 编号 │  球员  │ 位置   │ 传球数 │ 成功数   │ 成功率(%) │ 接球成功率 │");
            System.out.println("├──────┼────────┼────────┼────────┼──────────┼────────────┼────────────┤");
            List<PlayerStat> stats = new ArrayList<>(playerStats.values());
            stats.sort((s1, s2) -> Double.compare(
                s2.getPassSuccessRate(), s1.getPassSuccessRate()));
            for (PlayerStat stat : stats) {
                Player player = stat.getPlayer();
                System.out.printf("│ %-4s │ %-6s │ %-6s │ %-6d │ %-8d │ %-10s │ %-10s │%n",
                    player.getId(),
                    player.getName(),
                    player.getPosition(),
                    stat.getTotalPasses(),
                    stat.getSuccessfulPasses(),
                    df.format(stat.getPassSuccessRate()) + "%",
                    df.format(stat.getReceiveSuccessRate()) + "%");
            }
            System.out.println("└──────┴────────┴────────┴────────┴──────────┴────────────┴────────────┘");
        }
        // 打印球员配对统计
        public void printPairStatistics() {
            System.out.println("\n========== 球员配对统计 ==========");
            System.out.println("┌───────────┬───────────┬────────┬──────────┬───────────┐");
            System.out.println("│ 传球球员   │ 接球球员   │ 传球次数 │ 成功次数 │ 成功率(%) │");
            System.out.println("├───────────┼───────────┼────────┼──────────┼───────────┤");
            List<PlayerStat> stats = new ArrayList<>(playerStats.values());
            stats.sort((s1, s2) -> 
                s2.getPairStats().size() - s1.getPairStats().size());
            for (PlayerStat stat : stats) {
                Player player = stat.getPlayer();
                for (PassPairStat pairStat : stat.getPairStats().values()) {
                    if (pairStat.getTotalPasses() > 0) {
                        System.out.printf("│ %-9s │ %-9s │ %-6d │ %-8d │ %-9s │%n",
                            player.getName(),
                            pairStat.receiver.getName(),
                            pairStat.getTotalPasses(),
                            pairStat.getSuccessfulPasses(),
                            df.format(pairStat.getSuccessRate()) + "%");
                    }
                }
            }
            System.out.println("└───────────┴───────────┴────────┴──────────┴───────────┘");
        }
        // 打印球队整体统计
        public void printTeamStatistics() {
            int totalPasses = 0;
            int successfulPasses = 0;
            for (PassRecord record : passRecords) {
                totalPasses++;
                if (record.isSuccessful()) {
                    successfulPasses++;
                }
            }
            System.out.println("\n========== 球队整体统计 ==========");
            System.out.println("总传球次数：" + totalPasses);
            System.out.println("成功传球次数：" + successfulPasses);
            System.out.println("整体成功率：" + 
                df.format((double) successfulPasses / totalPasses * 100) + "%");
            // 按位置统计
            Map<String, Integer[]> positionStats = new HashMap<>();
            for (PassRecord record : passRecords) {
                String position = record.getPasser().getPosition();
                positionStats.computeIfAbsent(position, k -> new Integer[]{0, 0});
                Integer[] counts = positionStats.get(position);
                counts[0]++;
                if (record.isSuccessful()) {
                    counts[1]++;
                }
            }
            System.out.println("\n位置统计：");
            for (Map.Entry<String, Integer[]> entry : positionStats.entrySet()) {
                Integer[] counts = entry.getValue();
                double rate = counts[0] == 0 ? 0 : (double) counts[1] / counts[0] * 100;
                System.out.printf("%s：传球%d次，成功%d次，成功率%.2f%%%n", 
                    entry.getKey(), counts[0], counts[1], rate);
            }
        }
        // 分析配合质量
        public void analyzeCooperation() {
            System.out.println("\n========== 配合质量分析 ==========");
            // 找出最佳组合
            List<PassPairStat> allPairs = new ArrayList<>();
            for (PlayerStat stat : playerStats.values()) {
                allPairs.addAll(stat.getPairStats().values());
            }
            allPairs.sort((p1, p2) -> 
                Integer.compare(p2.getTotalPasses(), p1.getTotalPasses()));
            System.out.println("最佳配对组合（按传球次数排序）：");
            for (int i = 0; i < Math.min(3, allPairs.size()); i++) {
                PassPairStat pair = allPairs.get(i);
                if (pair.getTotalPasses() > 0) {
                    System.out.printf("第%d名：%s → %s，传球%d次，成功率%.2f%%%n",
                        i + 1,
                        pair.passer.getName(),
                        pair.receiver.getName(),
                        pair.getTotalPasses(),
                        pair.getSuccessRate());
                }
            }
            // 分析传球成功率趋势
            System.out.println("\n传球成功率趋势（按时间段）：");
            int periodSize = Math.max(1, passRecords.size() / 3);
            for (int i = 0; i < passRecords.size(); i += periodSize) {
                int endIndex = Math.min(i + periodSize, passRecords.size());
                int periodPasses = 0;
                int periodSuccesses = 0;
                for (int j = i; j < endIndex; j++) {
                    periodPasses++;
                    if (passRecords.get(j).isSuccessful()) {
                        periodSuccesses++;
                    }
                }
                double rate = periodPasses == 0 ? 0 : 
                    (double) periodSuccesses / periodPasses * 100;
                System.out.printf("第%d个时段：传球%d次，成功率%.2f%%%n", 
                    i / periodSize + 1, periodPasses, rate);
            }
        }
    }
    // 主程序
    public static void main(String[] args) {
        // 创建统计系统
        StatisticSystem system = new StatisticSystem();
        // 模拟比赛（100次传球）
        system.simulateMatch(100);
        // 输出各项统计
        system.printPlayerStatistics();
        system.printPairStatistics();
        system.printTeamStatistics();
        system.analyzeCooperation();
        // 手动添加一些特定记录演示
        System.out.println("\n========== 手动添加测试记录 ==========");
        system.recordPass("P001", "P002", true, 12.5);
        system.recordPass("P001", "P003", false, 8.3);
        system.recordPass("P003", "P001", true, 15.0);
        // 查看更新后的统计
        system.printPlayerStatistics();
    }
}

功能说明

核心功能

• 球员管理：管理球队球员信息（编号、姓名、位置）
• 传球记录：记录每次短传的传球者和接球者、是否成功
• 统计分析：计算个人、配对和球队整体的短传配合成功率

统计维度

• 个人统计：每个球员的传球成功率和接球成功率
• 配对统计：特定球员组合之间的配合成功率
• 位置统计：前锋、中场、后卫的传球成功率对比
• 趋势分析：比赛不同阶段的成功率变化

模拟功能

• 自动模拟一场比赛的传球数据
• 可手动添加特定的传球记录
• 模拟真实比赛的成功率范围

输出展示

• 使用表格格式清晰展示统计结果
• 包含详细的球员配对配合分析
• 形成可视化的统计报告

运行示例输出

========== 比赛模拟开始 ==========
预计传球次数：100
========== 比赛模拟结束 ==========
========== 球员个人统计 ==========
┌──────┬────────┬────────┬────────┬──────────┬────────────┬────────────┐
│ 编号 │  球员  │ 位置   │ 传球数 │ 成功数   │ 成功率(%) │ 接球成功率 │
├──────┼────────┼────────┼────────┼──────────┼────────────┼────────────┤
│ P003 │ 张伟   │ 中场   │ 15     │ 12       │ 80.00%     │ 75.00%     │
│ P001 │ 王强   │ 前锋   │ 14     │ 11       │ 78.57%     │ 82.35%     │
...

这个系统可以根据实际需求进行扩展,

• 增加更多球员统计指标
• 引入传球距离、传球时机等更多维度
• 可视化图表展示
• 数据库持久化存储
• 实时比赛数据接入