java案例统计头球争顶成功率如何？

wen java案例 2026-08-07 191

本文目录导读：

java案例统计头球争顶成功率如何？

基础数据模型
统计服务类
测试主类和示例
高级分析功能
输出示例

我来为您提供一个Java统计头球争顶成功率的完整案例：

基础数据模型

import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;
// 头球争顶事件实体类
class HeaderDuel {
    private Long playerId;
    private String playerName;
    private LocalDateTime eventTime;
    private boolean success;  // 是否成功
    private String opponent;   // 对手
    private String competition; // 赛事类型
    private String position;   // 场上位置
    public HeaderDuel(Long playerId, String playerName, boolean success, String opponent, String competition, String position) {
        this.playerId = playerId;
        this.playerName = playerName;
        this.eventTime = LocalDateTime.now();
        this.success = success;
        this.opponent = opponent;
        this.competition = competition;
        this.position = position;
    }
    // Getters and Setters
    public Long getPlayerId() { return playerId; }
    public String getPlayerName() { return playerName; }
    public LocalDateTime getEventTime() { return eventTime; }
    public boolean isSuccess() { return success; }
    public String getOpponent() { return opponent; }
    public String getCompetition() { return competition; }
    public String getPosition() { return position; }
}

统计服务类

class HeaderDuelStatisticsService {
    /**
     * 统计单个球员的头球争顶成功率
     */
    public Map<String, Object> calculatePlayerSuccessRate(List<HeaderDuel> duels, Long playerId) {
        List<HeaderDuel> playerDuels = duels.stream()
                .filter(d -> d.getPlayerId().equals(playerId))
                .collect(Collectors.toList());
        Map<String, Object> result = new HashMap<>();
        int total = playerDuels.size();
        long successCount = playerDuels.stream().filter(HeaderDuel::isSuccess).count();
        result.put("playerId", playerId);
        result.put("playerName", playerDuels.isEmpty() ? "未知" : playerDuels.get(0).getPlayerName());
        result.put("totalAttempts", total);
        result.put("successCount", successCount);
        result.put("successRate", total == 0 ? 0.0 : (double) successCount / total * 100);
        return result;
    }
    /**
     * 按赛事维度统计球员成功率
     */
    public Map<String, Map<String, Object>> calculateByCompetition(List<HeaderDuel> duels, Long playerId) {
        return duels.stream()
                .filter(d -> d.getPlayerId().equals(playerId))
                .collect(Collectors.groupingBy(
                    HeaderDuel::getCompetition,
                    Collectors.collectingAndThen(
                        Collectors.toList(),
                        list -> {
                            Map<String, Object> stats = new HashMap<>();
                            stats.put("total", list.size());
                            stats.put("success", list.stream().filter(HeaderDuel::isSuccess).count());
                            stats.put("successRate", 
                                list.isEmpty() ? 0.0 : 
                                (double) list.stream().filter(HeaderDuel::isSuccess).count() / list.size() * 100);
                            return stats;
                        }
                    )
                ));
    }
    /**
     * 按对手统计成功率
     */
    public Map<String, Map<String, Object>> calculateByOpponent(List<HeaderDuel> duels, Long playerId) {
        return duels.stream()
                .filter(d -> d.getPlayerId().equals(playerId))
                .collect(Collectors.groupingBy(
                    HeaderDuel::getOpponent,
                    Collectors.collectingAndThen(
                        Collectors.toList(),
                        list -> {
                            Map<String, Object> stats = new HashMap<>();
                            stats.put("total", list.size());
                            stats.put("success", list.stream().filter(HeaderDuel::isSuccess).count());
                            stats.put("successRate", 
                                list.isEmpty() ? 0.0 : 
                                (double) list.stream().filter(HeaderDuel::isSuccess).count() / list.size() * 100);
                            return stats;
                        }
                    )
                ));
    }
    /**
     * 按位置维度统计球员成功率
     */
    public Map<String, Map<String, Object>> calculateByPosition(List<HeaderDuel> duels, Long playerId) {
        return duels.stream()
                .filter(d -> d.getPlayerId().equals(playerId))
                .collect(Collectors.groupingBy(
                    HeaderDuel::getPosition,
                    Collectors.collectingAndThen(
                        Collectors.toList(),
                        list -> {
                            Map<String, Object> stats = new HashMap<>();
                            stats.put("total", list.size());
                            stats.put("success", list.stream().filter(HeaderDuel::isSuccess).count());
                            stats.put("successRate", 
                                list.isEmpty() ? 0.0 : 
                                (double) list.stream().filter(HeaderDuel::isSuccess).count() / list.size() * 100);
                            return stats;
                        }
                    )
                ));
    }
    /**
     * 统计所有球员的头球成功率排行榜
     */
    public List<Map<String, Object>> getPlayerRanking(List<HeaderDuel> duels) {
        Map<Long, List<HeaderDuel>> byPlayer = duels.stream()
                .collect(Collectors.groupingBy(HeaderDuel::getPlayerId));
        return byPlayer.entrySet().stream()
                .map(entry -> {
                    Map<String, Object> stats = new HashMap<>();
                    List<HeaderDuel> playerDuels = entry.getValue();
                    long success = playerDuels.stream().filter(HeaderDuel::isSuccess).count();
                    stats.put("playerId", entry.getKey());
                    stats.put("playerName", playerDuels.get(0).getPlayerName());
                    stats.put("totalAttempts", playerDuels.size());
                    stats.put("successCount", success);
                    stats.put("successRate", (double) success / playerDuels.size() * 100);
                    return stats;
                })
                .sorted((a, b) -> Double.compare(
                    (double) b.get("successRate"), 
                    (double) a.get("successRate")
                ))
                .collect(Collectors.toList());
    }
}

测试主类和示例

public class FootballHeaderStatistics {
    public static void main(String[] args) {
        // 创建模拟数据
        List<HeaderDuel> headerDuels = createMockData();
        // 统计服务
        HeaderDuelStatisticsService service = new HeaderDuelStatisticsService();
        // 1. 统计单个球员 (球员ID: 1)
        System.out.println("=== 球员1的头球争顶统计 ===");
        Map<String, Object> playerStats = service.calculatePlayerSuccessRate(headerDuels, 1L);
        playerStats.forEach((key, value) -> 
            System.out.printf("%-15s: %s%n", key, 
                key.equals("successRate") ? String.format("%.2f%%", value) : value));
        // 2. 按赛事统计
        System.out.println("\n=== 按赛事统计 ===");
        Map<String, Map<String, Object>> competitionStats = 
            service.calculateByCompetition(headerDuels, 1L);
        competitionStats.forEach((competition, stats) -> {
            System.out.printf("赛事: %s%n", competition);
            stats.forEach((key, value) -> 
                System.out.printf("  %-12s: %s%n", key, 
                    key.equals("successRate") ? String.format("%.2f%%", value) : value));
        });
        // 3. 成功率排行榜
        System.out.println("\n=== 头球成功率排行榜 ===");
        List<Map<String, Object>> ranking = service.getPlayerRanking(headerDuels);
        ranking.forEach(stats -> 
            System.out.printf("%-10s 总次数: %-4d 成功: %-4d 成功率: %.2f%%%n",
                stats.get("playerName"),
                (int) stats.get("totalAttempts"),
                (int) stats.get("successCount"),
                (double) stats.get("successRate")));
    }
    /**
     * 创建模拟数据
     */
    private static List<HeaderDuel> createMockData() {
        List<HeaderDuel> duels = new ArrayList<>();
        Random random = new Random();
        String[] players = {"张三", "李四", "王五", "赵六", "孙七"};
        String[] competitions = {"中超联赛", "足协杯", "亚冠联赛"};
        String[] opponents = {"上海队", "北京队", "广州队", "山东队"};
        String[] positions = {"前锋", "中锋", "后卫"};
        // 生成500条模拟数据
        for (int i = 0; i < 500; i++) {
            Long playerId = (long) (random.nextInt(5) + 1);
            String playerName = players[playerId.intValue() - 1];
            boolean success = random.nextDouble() < 0.45; // 45%成功率
            String opponent = opponents[random.nextInt(opponents.length)];
            String competition = competitions[random.nextInt(competitions.length)];
            String position = positions[random.nextInt(positions.length)];
            duels.add(new HeaderDuel(playerId, playerName, success, opponent, competition, position));
        }
        return duels;
    }
}

高级分析功能

class AdvancedHeaderAnalysis {
    /**
     * 计算球员近期的成功率变化趋势
     */
    public List<Map<String, Object>> calculateTrend(HeaderDuelStatisticsService service, 
                                                    List<HeaderDuel> duels, 
                                                    Long playerId, 
                                                    int periodDays) {
        LocalDateTime cutoff = LocalDateTime.now().minusDays(periodDays);
        return duels.stream()
            .filter(d -> d.getPlayerId().equals(playerId))
            .filter(d -> d.getEventTime().isAfter(cutoff))
            .sorted(Comparator.comparing(HeaderDuel::getEventTime))
            .collect(Collectors.groupingBy(
                d -> d.getEventTime().toLocalDate(),
                LinkedHashMap::new,
                Collectors.collectingAndThen(
                    Collectors.toList(),
                    list -> {
                        Map<String, Object> dayStats = new HashMap<>();
                        dayStats.put("date", list.get(0).getEventTime().toLocalDate());
                        dayStats.put("total", list.size());
                        dayStats.put("success", list.stream().filter(HeaderDuel::isSuccess).count());
                        dayStats.put("successRate", 
                            (double) list.stream().filter(HeaderDuel::isSuccess).count() / list.size() * 100);
                        return dayStats;
                    }
                )
            )).values().stream().collect(Collectors.toList());
    }
    /**
     * 和其他球员对比分析
     */
    public Map<String, Object> comparePlayers(List<HeaderDuel> duels, 
                                               List<Long> playerIds) {
        HeaderDuelStatisticsService service = new HeaderDuelStatisticsService();
        Map<String, Object> comparison = new HashMap<>();
        for (Long playerId : playerIds) {
            Map<String, Object> stats = service.calculatePlayerSuccessRate(duels, playerId);
            comparison.put(stats.get("playerName").toString(), stats);
        }
        // 计算平均成功率
        double avgRate = comparison.values().stream()
            .mapToDouble(m -> (double) ((Map<String, Object>) m).get("successRate"))
            .average()
            .orElse(0.0);
        comparison.put("averageSuccessRate", avgRate);
        return comparison;
    }
}

输出示例

=== 球员1的头球争顶统计 ===
playerId        : 1
playerName      : 张三
totalAttempts   : 98
successCount    : 44
successRate     : 44.90%
=== 按赛事统计 ===
赛事: 中超联赛
  total        : 41
  success      : 18
  successRate  : 43.90%
赛事: 足协杯
  total        : 35
  success      : 16
  successRate  : 45.71%
赛事: 亚冠联赛
  total        : 22
  success      : 10
  successRate  : 45.45%
=== 头球成功率排行榜 ===
赵六        总次数: 102  成功: 52  成功率: 50.98%
王五        总次数: 95   成功: 46  成功率: 48.42%
张三        总次数: 98   成功: 44  成功率: 44.90%
李四        总次数: 104  成功: 45  成功率: 43.27%
孙七        总次数: 101  成功: 43  成功率: 42.57%

这个案例提供了：