本文目录导读：
我将为您设计一个综合的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、集合框架、枚举、线程池等技术要点，您可以根据实际需求进一步扩展功能，如增加数据库存储、机器学习预测、图形化界面等。
