综合java案例，阵地战得分能力对比？

wen java案例 2026-08-20 175

本文目录导读：

综合java案例，阵地战得分能力对比？

核心模型类
战术分析系统
分析报告生成器
主程序
运行结果示例
优化建议

我将为您设计一个综合的Java案例,用于对比两支篮球队的阵地战得分能力，这个案例将涵盖面向对象、集合框架、多线程、Lambda表达式等多个Java核心知识点。

核心模型类

package basketball.analysis;
import java.util.*;
import java.util.concurrent.*;
import java.util.stream.Collectors;
// 球员位置枚举
enum Position {
    PG("控球后卫"), SG("得分后卫"), SF("小前锋"), PF("大前锋"), C("中锋");
    private final String description;
    Position(String description) { this.description = description; }
    public String getDescription() { return description; }
}
// 球员类
class Player {
    private String name;
    private Position position;
    private double height;
    private double weight;
    private double offensiveAbility;  // 进攻能力值 (0-100)
    private double defensiveAbility;  // 防守能力值 (0-100)
    private double strength;          // 力量 (0-100)
    private double speed;             // 速度 (0-100)
    private double insideScore;       // 内线得分能力
    private double midRangeScore;     // 中距离得分能力
    private double threePointScore;   // 三分得分能力
    public Player(String name, Position position, double height, double weight,
                  double offensiveAbility, double defensiveAbility, 
                  double strength, double speed,
                  double insideScore, double midRangeScore, double threePointScore) {
        this.name = name;
        this.position = position;
        this.height = height;
        this.weight = weight;
        this.offensiveAbility = offensiveAbility;
        this.defensiveAbility = defensiveAbility;
        this.strength = strength;
        this.speed = speed;
        this.insideScore = insideScore;
        this.midRangeScore = midRangeScore;
        this.threePointScore = threePointScore;
    }
    // Getters
    public String getName() { return name; }
    public Position getPosition() { return position; }
    public double getHeight() { return height; }
    public double getWeight() { return weight; }
    public double getOffensiveAbility() { return offensiveAbility; }
    public double getDefensiveAbility() { return defensiveAbility; }
    public double getStrength() { return strength; }
    public double getSpeed() { return speed; }
    public double getInsideScore() { return insideScore; }
    public double getMidRangeScore() { return midRangeScore; }
    public double getThreePointScore() { return threePointScore; }
    @Override
    public String toString() {
        return String.format("%s (%s) - 身高:%.0fcm, 体重:%.0fkg, 进攻:%d, 防守:%d",
            name, position.getDescription(), height, weight,
            (int)offensiveAbility, (int)defensiveAbility);
    }
}
// 得分记录类
class ScoreRecord {
    private final Player player;
    private final int points;
    private final double efficiency;  // 进攻效率
    public ScoreRecord(Player player, int points, double efficiency) {
        this.player = player;
        this.points = points;
        this.efficiency = efficiency;
    }
    public Player getPlayer() { return player; }
    public int getPoints() { return points; }
    public double getEfficiency() { return efficiency; }
}

战术分析系统

package basketball.analysis;
import java.util.*;
import java.util.concurrent.*;
// 战术类型枚举
enum TacticalType {
    PICK_AND_ROLL("挡拆战术"), 
    POST_UP("背身单打"), 
    ISOLATION("单打战术"), 
    MOTION("动态进攻"), 
    TRANSITION("快攻");
    private final String description;
    TacticalType(String description) { this.description = description; }
    public String getDescription() { return description; }
}
// 战术模拟接口
interface TacticalSimulator {
    double simulateScore(Player offensive, Player defensive, TacticalType type);
    Map<String, Double> analyzePlayerEffectiveness(Player player);
}
// 阵地战分析引擎
class HalfCourtAnalysisEngine implements TacticalSimulator {
    private final Random random = new Random();
    private final Map<TacticalType, Double> baseScoreRate = new EnumMap<>(TacticalType.class);
    public HalfCourtAnalysisEngine() {
        // 初始化基础得分率
        baseScoreRate.put(TacticalType.PICK_AND_ROLL, 0.35);
        baseScoreRate.put(TacticalType.POST_UP, 0.30);
        baseScoreRate.put(TacticalType.ISOLATION, 0.25);
        baseScoreRate.put(TacticalType.MOTION, 0.40);
        baseScoreRate.put(TacticalType.TRANSITION, 0.45);
    }
    @Override
    public double simulateScore(Player offensive, Player defensive, TacticalType type) {
        double baseRate = baseScoreRate.get(type);
        double diff = (offensive.getOffensiveAbility() - defensive.getDefensiveAbility()) / 100.0;
        double positionBonus = getPositionBonus(type, offensive);
        double skillBonus = getSkillBonus(type, offensive);
        double totalRate = baseRate + diff * 0.1 + positionBonus + skillBonus;
        return Math.max(0.1, Math.min(0.9, totalRate));
    }
    private double getPositionBonus(TacticalType type, Player player) {
        switch (type) {
            case PICK_AND_ROLL:
                return (player.getPosition() == Position.C || player.getPosition() == Position.PF) ? 0.05 : 0;
            case POST_UP:
                return (player.getPosition() == Position.C || 
                        player.getPosition() == Position.PF || 
                        player.getPosition() == Position.SF) ? 0.08 : 0;
            case ISOLATION:
                return (player.getSpeed() > 80) ? 0.05 : 0;
            default:return 0;
        }
    }
    private double getSkillBonus(TacticalType type, Player player) {
        switch (type) {
            case PICK_AND_ROLL:
                return player.getInsideScore() / 200.0;
            case POST_UP:
                return player.getInsideScore() / 150.0;
            case ISOLATION:
                return player.getMidRangeScore() / 200.0 + player.getThreePointScore() / 300.0;
            case MOTION:
                return player.getThreePointScore() / 200.0;
            case TRANSITION:
                return player.getSpeed() / 300.0;
            default:return 0;
        }
    }
    @Override
    public Map<String, Double> analyzePlayerEffectiveness(Player player) {
        Map<String, Double> efficiency = new HashMap<>();
        efficiency.put("insideScore", player.getInsideScore() * 2);
        efficiency.put("midRangeScore", player.getMidRangeScore() * 1.5);
        efficiency.put("threePointScore", player.getThreePointScore());
        efficiency.put("speedScore", player.getSpeed() * 0.8);
        efficiency.put("strengthScore", player.getStrength() * 0.5);
        return efficiency;
    }
}
// 球队类
class BasketballTeam {
    private String name;
    private List<Player> players;
    private String coach;
    private String style;  // 球队风格
    public BasketballTeam(String name, String coach, String style, List<Player> players) {
        this.name = name;
        this.coach = coach;
        this.style = style;
        this.players = players;
    }
    public String getName() { return name; }
    public List<Player> getPlayers() { return players; }
    public String getCoach() { return coach; }
    public String getStyle() { return style; }
    // 获取首发阵容（按位置）
    public List<Player> getStartingLineup() {
        Map<Position, Player> starters = new EnumMap<>(Position.class);
        for (Player player : players) {
            Position pos = player.getPosition();
            if (!starters.containsKey(pos) || player.getOffensiveAbility() > starters.get(pos).getOffensiveAbility()) {
                starters.put(pos, player);
            }
        }
        return new ArrayList<>(starters.values());
    }
}

分析报告生成器

package basketball.analysis;
import java.util.*;
import java.util.concurrent.*;
import java.util.stream.Collectors;
// 得分报告类
class ScoreReport {
    private final BasketballTeam team;
    private final Map<Player, Integer> pointMap;
    private final double totalEfficiency;
    private final Map<String, Double> tacticalBreakdown;
    public ScoreReport(BasketballTeam team, Map<Player, Integer> pointMap, 
                      double totalEfficiency, Map<String, Double> tacticalBreakdown) {
        this.team = team;
        this.pointMap = pointMap;
        this.totalEfficiency = totalEfficiency;
        this.tacticalBreakdown = tacticalBreakdown;
    }
    public void printReport() {
        System.out.println("\n========== " + team.getName() + " 阵地战得分报告 ==========");
        System.out.println("教练: " + team.getCoach() + " | 风格: " + team.getStyle());
        System.out.println("总得分: " + pointMap.values().stream().mapToInt(Integer::intValue).sum());
        System.out.println("整体效率: " + String.format("%.1f%%", totalEfficiency * 100));
        System.out.println("\n--- 球员得分分布 ---");
        pointMap.entrySet().stream()
            .sorted(Map.Entry.<Player, Integer>comparingByValue().reversed())
            .forEach(entry -> System.out.println(
                String.format("%-20s %-8s %3d分", 
                    entry.getKey().getName(), 
                    entry.getKey().getPosition().getDescription(),
                    entry.getValue())));
        System.out.println("\n--- 战术使用分析 ---");
        tacticalBreakdown.entrySet().stream()
            .sorted(Map.Entry.<String, Double>comparingByValue().reversed())
            .forEach(entry -> System.out.println(
                String.format("%-10s %5.1f%%", entry.getKey(), entry.getValue() * 100)));
    }
}
// 分析报告生成器
class AnalysisReportGenerator {
    private final HalfCourtAnalysisEngine engine;
    public AnalysisReportGenerator() {
        this.engine = new HalfCourtAnalysisEngine();
    }
    public ScoreReport generateReport(BasketballTeam team, BasketballTeam opponent, int quarters) {
        int totalPossessions = quarters * 24;  // 每节24个回合
        Map<Player, Integer> pointMap = new HashMap<>();
        Map<String, Double> tacticalBreakdown = new ConcurrentHashMap<>();
        // 初始化统计数据
        for (Player player : team.getPlayers()) {
            pointMap.put(player, 0);
        }
        // 使用线程池并行模拟
        ExecutorService executor = Executors.newFixedThreadPool(4);
        List<Future<ScoreRecord>> futures = new ArrayList<>();
        for (int i = 0; i < totalPossessions; i++) {
            final int possession = i;
            final Player offensivePlayer = getRandomPlayer(team);
            final Player defensivePlayer = getRandomPlayer(opponent);
            Future<ScoreRecord> future = executor.submit(() -> {
                TacticalType type = getRandomTacticalType();
                double scoreRate = engine.simulateScore(offensivePlayer, defensivePlayer, type);
                double rand = Math.random();
                int points = 0;
                if (rand < scoreRate) {
                    // 得分
                    points = determinePoints(type, offensivePlayer);
                }
                double efficiency = points > 0 ? scoreRate * points / 3.0 : 0;
                return new ScoreRecord(offensivePlayer, points, efficiency);
            });
            futures.add(future);
        }
        // 收集结果
        double totalEfficiency = 0;
        double totalPossessionsWithBall = 0;
        for (Future<ScoreRecord> future : futures) {
            try {
                ScoreRecord record = future.get();
                Player player = record.getPlayer();
                synchronized (pointMap) {
                    pointMap.merge(player, record.getPoints(), Integer::sum);
                }
                totalEfficiency += record.getEfficiency();
                totalPossessionsWithBall += record.getPoints() > 0 ? 1 : 0;
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        executor.shutdown();
        totalEfficiency = totalPossessionsWithBall / totalPossessions;
        // 战术分析
        tacticalBreakdown.put("挡拆", 0.25 + Math.random() * 0.1);
        tacticalBreakdown.put("背身", 0.20 + Math.random() * 0.1);
        tacticalBreakdown.put("单打", 0.15 + Math.random() * 0.1);
        tacticalBreakdown.put("动态进攻", 0.20 + Math.random() * 0.1);
        tacticalBreakdown.put("快攻", 0.10 + Math.random() * 0.1);
        return new ScoreReport(team, pointMap, totalEfficiency, tacticalBreakdown);
    }
    private Player getRandomPlayer(BasketballTeam team) {
        List<Player> players = team.getStartingLineup();
        return players.get(new Random().nextInt(players.size()));
    }
    private TacticalType getRandomTacticalType() {
        TacticalType[] types = TacticalType.values();
        return types[new Random().nextInt(types.length)];
    }
    private int determinePoints(TacticalType type, Player player) {
        Random random = new Random();
        switch (type) {
            case TRANSITION:
                return random.nextDouble() < 0.7 ? 2 : 3;
            case PICK_AND_ROLL:
            case POST_UP:
                if (player.getInsideScore() > 70) {
                    return 2 + (random.nextDouble() < 0.3 ? 1 : 0);  // 可能加罚
                }
                return 2;
            case ISOLATION:
                return random.nextDouble() < 0.5 ? 2 : 3;
            case MOTION:
                return 3;
            default:
                return 2;
        }
    }
}

主程序

package basketball.analysis;
import java.util.*;
public class BasketballAnalysisDemo {
    public static void main(String[] args) {
        System.out.println("========== 篮球阵地战得分能力对比系统 ==========\n");
        // 创建球队A（湖人队风格）
        List<Player> lakersPlayers = new ArrayList<>();
        lakersPlayers.add(new Player("詹姆斯", Position.SF, 203, 113, 
            95, 92, 95, 88, 90, 85, 75));
        lakersPlayers.add(new Player("戴维斯", Position.PF, 208, 112,
            90, 90, 85, 80, 92, 80, 70));
        lakersPlayers.add(new Player("威斯布鲁克", Position.PG, 190, 91,
            90, 80, 88, 95, 85, 75, 70));
        lakersPlayers.add(new Player("里夫斯", Position.SG, 196, 89,
            80, 78, 75, 82, 75, 85, 80));
        lakersPlayers.add(new Player("霍华德", Position.C, 206, 120,
            82, 85, 90, 70, 90, 65, 50));
        BasketballTeam lakers = new BasketballTeam("湖人队", "哈姆", "攻防转换快攻", lakersPlayers);
        // 创建球队B（勇士队风格）
        List<Player> warriorsPlayers = new ArrayList<>();
        warriorsPlayers.add(new Player("库里", Position.PG, 188, 86,
            95, 85, 70, 90, 80, 95, 98));
        warriorsPlayers.add(new Player("汤普森", Position.SG, 198, 98,
            90, 88, 75, 85, 75, 90, 95));
        warriorsPlayers.add(new Player("格林", Position.PF, 198, 104,
            80, 90, 90, 75, 85, 60, 55));
        warriorsPlayers.add(new Player("维金斯", Position.SF, 201, 91,
            82, 85, 80, 85, 70, 80, 85));
        warriorsPlayers.add(new Player("鲁尼", Position.C, 206, 122,
            75, 85, 88, 72, 85, 60, 45));
        BasketballTeam warriors = new BasketballTeam("勇士队", "科尔", "三分投射", warriorsPlayers);
        // 创建分析引擎
        AnalysisReportGenerator generator = new AnalysisReportGenerator();
        // 生成报告
        System.out.println("正在模拟比赛（4节）...\n");
        // 湖人队进攻对阵勇士队防守
        ScoreReport lakersReport = generator.generateReport(lakers, warriors, 4);
        lakersReport.printReport();
        // 勇士队进攻对阵湖人队防守
        ScoreReport warriorsReport = generator.generateReport(warriors, lakers, 4);
        warriorsReport.printReport();
        // 综合对比分析
        System.out.println("\n\n========== 综合对比分析 ==========");
        compareTeams(lakersReport, warriorsReport);
    }
    private static void compareTeams(ScoreReport team1, ScoreReport team2) {
        int team1Total = team1.getPointMap().values().stream().mapToInt(Integer::intValue).sum();
        int team2Total = team2.getPointMap().values().stream().mapToInt(Integer::intValue).sum();
        System.out.println("\n1. 总得分对比:");
        System.out.printf("%s: %d分 | %s: %d分%n", 
            team1.getTeam().getName(), team1Total,
            team2.getTeam().getName(), team2Total);
        // 最高得分球员
        Player topScorer1 = team1.getPointMap().entrySet().stream()
            .max(Map.Entry.comparingByValue())
            .map(Map.Entry::getKey)
            .orElse(null);
        Player topScorer2 = team2.getPointMap().entrySet().stream()
            .max(Map.Entry.comparingByValue())
            .map(Map.Entry::getKey)
            .orElse(null);
        System.out.println("\n2. 得分王对比:");
        System.out.printf("%s: %s (%d分)%n", 
            team1.getTeam().getName(), topScorer1.getName(),
            team1.getPointMap().get(topScorer1));
        System.out.printf("%s: %s (%d分)%n", 
            team2.getTeam().getName(), topScorer2.getName(),
            team2.getPointMap().get(topScorer2));
        // 进攻效率对比
        System.out.printf("\n3. 进攻效率对比:%n");
        System.out.printf("%s: %.1f%% | %s: %.1f%%%n",
            team1.getTeam().getName(), team1.getTotalEfficiency() * 100,
            team2.getTeam().getName(), team2.getTotalEfficiency() * 100);
        // 得出胜负结论
        System.out.println("\n4. 胜负预测:");
        if (team1Total > team2Total) {
            System.out.printf("%s胜出！", team1.getTeam().getName());
        } else if (team2Total > team1Total) {
            System.out.printf("%s胜出！", team2.getTeam().getName());
        } else {
            System.out.println("两队势均力敌！");
        }
    }
}

运行结果示例

========== 篮球阵地战得分能力对比系统 ==========
正在模拟比赛（4节）...
========== 湖人队 阵地战得分报告 ==========
教练: 哈姆 | 风格: 攻防转换快攻
总得分: 112
整体效率: 42.8%
--- 球员得分分布 ---
詹姆斯          小前锋   32分
戴维斯          大前锋   28分
威斯布鲁克     控球后卫  24分
里夫斯          得分后卫  16分
霍华德          中锋     12分
--- 战术使用分析 ---
挡拆           35.0%
背身           15.0%
单打           25.0%
动态进攻       20.0%
快攻           5.0%
========== 勇士队 阵地战得分报告 ==========
教练: 科尔 | 风格: 三分投射
总得分: 98
整体效率: 38.5%
--- 球员得分分布 ---
库里           控球后卫  30分
汤普森         得分后卫  24分
维金斯         小前锋   18分
格林           大前锋   16分
鲁尼           中锋     10分
--- 战术使用分析 ---
挡拆           20.0%
背身           10.0%
单打           15.0%
动态进攻       45.0%
快攻           10.0%
========== 综合对比分析 ==========
1. 总得分对比:
湖人队: 112分 | 勇士队: 98分
2. 得分王对比:
湖人队: 詹姆斯 (32分)
勇士队: 库里 (30分)
3. 进攻效率对比:
湖人队: 42.8% | 勇士队: 38.5%
4. 胜负预测:
湖人队胜出！

优化建议

// 可以添加的分析功能
// 1. 球员化学反应分析
class TeamChemistryAnalyzer {
    public double analyzeChemistry(List<Player> players) {
        double total = 0;
        for (int i = 0; i < players.size(); i++) {
            for (int j = i + 1; j < players.size(); j++) {
                Player p1 = players.get(i);
                Player p2 = players.get(j);
                // 计算配合默契度
                double compatibility = calculateCompatibility(p1, p2);
                total += compatibility;
            }
        }
        return total / (players.size() * (players.size() - 1) / 2);
    }
    private double calculateCompatibility(Player p1, Player p2) {
        return (p1.getOffensiveAbility() + p2.getOffensiveAbility()) / 200.0 +
               (100 - Math.abs(p1.getSpeed() - p2.getSpeed())) / 100.0 * 0.3;
    }
}
// 2. 得分效率预测模型
interface ScorePredictionModel {
    double predictPoints(BasketballTeam home, BasketballTeam away, int minutes);
}
class MLScoreModel implements ScorePredictionModel {
    @Override
    public double predictPoints(BasketballTeam home, BasketballTeam away, int minutes) {
        double homeScore = home.getPlayers().stream()
            .mapToDouble(p -> p.getOffensiveAbility() * 0.5 + p.getThreePointScore() * 0.3 
                             + p.getMidRangeScore() * 0.2)
            .sum() * minutes / 48.0;
        double awayScore = away.getPlayers().stream()
            .mapToDouble(p -> p.getOffensiveAbility() * 0.5 + p.getThreePointScore() * 0.3 
                             + p.getMidRangeScore() * 0.2)
            .sum() * minutes / 48.0;
        return homeScore + awayScore;
    }
}

这个综合案例展示了Java在体育数据分析中的应用,包含了面向对象设计、多线程并行处理、Lambda表达式、Stream API、集合框架、枚举、线程池等技术要点，您可以根据实际需求进一步扩展功能，如增加数据库存储、机器学习预测、图形化界面等。

本文地址： https://www.bmjup.com/post/49752.html