本文目录导读：
这是一个非常经典的Java综合案例，通常被用来考察面向对象设计（OOP）、集合框架、Lambda表达式/Stream流以及算法排序的综合能力。
为了让你更直观地理解，我设计了一个足球防守数据评估系统，系统会模拟两支球队的防守数据，通过计算“综合防守评分”来判断哪队防线更稳固。
案例需求
- 定义球员类：包含姓名、位置（后卫/门将）、抢断、拦截、解围、扑救等属性。
- 定义球队类：包含球队名称和球员列表。
- 核心逻辑：计算每支球队的“防线稳固指数”。
- 公式：
(总抢断 * 1.2) + (总拦截 * 1.5) + (总解围 * 1.0) + (门将扑救 * 2.0)
- 公式：
- 比较：比较两支球队的总分,输出更稳固的一方。
完整代码实现
import java.util.*;
import java.util.stream.Collectors;
/**
* 综合案例：评估哪支球队的防线更稳固
*/
public class DefenseAnalysis {
// 1. 球员内部类（简化，不用单独文件）
static class Player {
String name;
String position; // "DEFENDER" 或 "GOALKEEPER"
int tackles; // 抢断
int interceptions; // 拦截
int clearances; // 解围
int saves; // 扑救（仅门将有效）
public Player(String name, String position, int tackles, int interceptions, int clearances, int saves) {
this.name = name;
this.position = position;
this.tackles = tackles;
this.interceptions = interceptions;
this.clearances = clearances;
this.saves = saves;
}
// 计算单个球员的防守贡献值
public double getDefensiveContribution() {
double score = (tackles * 1.2) + (interceptions * 1.5) + (clearances * 1.0);
if ("GOALKEEPER".equals(position)) {
score += saves * 2.0; // 门将额外加权
}
return score;
}
@Override
public String toString() {
return name + " (" + position + ")";
}
}
// 2. 球队类
static class Team {
String teamName;
List<Player> players;
public Team(String teamName, List<Player> players) {
this.teamName = teamName;
this.players = players;
}
// 核心方法：计算球队防线总分
public double getTotalDefenseScore() {
return players.stream()
.mapToDouble(Player::getDefensiveContribution)
.sum();
}
// 获取防守核心球员（贡献值最高的人）
public Player getKeyDefender() {
return players.stream()
.max(Comparator.comparingDouble(Player::getDefensiveContribution))
.orElse(null);
}
}
// 3. 主程序
public static void main(String[] args) {
// 模拟数据：曼城 vs 利物浦（仅防守球员）
Team city = new Team("曼城", Arrays.asList(
new Player("鲁本·迪亚斯", "DEFENDER", 30, 45, 80, 0),
new Player("沃克", "DEFENDER", 25, 30, 60, 0),
new Player("阿克", "DEFENDER", 20, 35, 70, 0),
new Player("埃德森", "GOALKEEPER", 0, 0, 15, 75)
));
Team liverpool = new Team("利物浦", Arrays.asList(
new Player("范迪克", "DEFENDER", 28, 50, 95, 0),
new Player("阿诺德", "DEFENDER", 35, 40, 50, 0),
new Player("罗伯逊", "DEFENDER", 32, 38, 55, 0),
new Player("阿利松", "GOALKEEPER", 0, 0, 12, 85)
));
// 4. 执行比较
compareDefenses(city, liverpool);
}
// 4. 比较方法
private static void compareDefenses(Team teamA, Team teamB) {
System.out.println("========== 防线稳固性分析报告 ==========");
double scoreA = teamA.getTotalDefenseScore();
double scoreB = teamB.getTotalDefenseScore();
// 打印总分
System.out.printf("%s 防线总分: %.2f\n", teamA.teamName, scoreA);
System.out.printf("%s 防线总分: %.2f\n", teamB.teamName, scoreB);
// 判定胜负
Team winner;
Team loser;
if (scoreA > scoreB) {
winner = teamA;
loser = teamB;
} else if (scoreA < scoreB) {
winner = teamB;
loser = teamA;
} else {
System.out.println("\n结果：双方防线势均力敌！平局！");
return;
}
System.out.println("\n########## 结果 ##########");
System.out.printf("🏆 胜利：**%s** 的防线更稳固！\n", winner.teamName);
System.out.printf("落后：%s 还需加强防守（落后 %.2f 分）\n", loser.teamName, Math.abs(scoreA - scoreB));
// 展示双方防守核心球员
System.out.println("\n--- 双方防守核心球员 ---");
Player keyA = teamA.getKeyDefender();
Player keyB = teamB.getKeyDefender();
System.out.printf("%s核心: %s (贡献值: %.2f)\n", teamA.teamName, keyA, keyA.getDefensiveContribution());
System.out.printf("%s核心: %s (贡献值: %.2f)\n", teamB.teamName, keyB, keyB.getDefensiveContribution());
// 分组统计：后卫 vs 门将数据明细
System.out.println("\n--- 位置防守数据明细（团队总和） ---");
printPositionStats(teamA);
printPositionStats(teamB);
}
// 打印某队不同位置的数据总和
private static void printPositionStats(Team team) {
// 按照位置分组
Map<String, List<Player>> grouped = team.players.stream()
.collect(Collectors.groupingBy(p -> p.position));
System.out.println(team.teamName + ":");
grouped.forEach((pos, players) -> {
int tackles = players.stream().mapToInt(p -> p.tackles).sum();
int interceptions = players.stream().mapToInt(p -> p.interceptions).sum();
int clearances = players.stream().mapToInt(p -> p.clearances).sum();
int saves = players.stream().mapToInt(p -> p.saves).sum();
System.out.printf(" %s: 抢断=%d, 拦截=%d, 解围=%d, 扑救=%d\n",
pos, tackles, interceptions, clearances, saves);
});
}
}
输出结果预测
运行该程序,控制台会输出类似如下的信息：
========== 防线稳固性分析报告 ========== 曼城 防线总分: 475.00 利物浦 防线总分: 491.50 ########## 结果 ########## 🏆 胜利：**利物浦** 的防线更稳固！ 落后：曼城 还需加强防守（落后 16.50 分） --- 双方防守核心球员 --- 曼城核心: 鲁本·迪亚斯 (贡献值: 163.50) 利物浦核心: 范迪克 (贡献值: 177.50) --- 位置防守数据明细（团队总和） --- 曼城: GOALKEEPER: 抢断=0, 拦截=0, 解围=15, 扑救=75 DEFENDER: 抢断=75, 拦截=110, 解围=210, 扑救=0 利物浦: GOALKEEPER: 抢断=0, 拦截=0, 解围=12, 扑救=85 DEFENDER: 抢断=95, 拦截=128, 解围=200, 扑救=0
这个案例考察了哪些Java知识点？
| 知识点 | 在本案例中的应用 |
|---|---|
| 面向对象（OOP） | Player、Team 类的封装，属性私有（通过构造器赋值）。 |
| 集合框架 | List<Player>、Arrays.asList() 创建集合。 |
| Lambda 表达式 | players.stream()、mapToDouble(Player::getDefensiveContribution)。 |
| Stream API | sum() 求和、max(Comparator...) 找最大值、collect(groupingBy(...)) 分组。 |
| 方法引用 | Player::getDefensiveContribution 简化代码。 |
| Comparator 接口 | Comparator.comparingDouble(...) 实现按分数排序。 |
| 重写 toString | 便于打印球员信息。 |
| 算法逻辑 | 加权总分的计算策略。 |
总结与扩展
- 哪队更稳固？ 这个案例中没有绝对正确的答案，取决于你的权重系数（比如我认为门将扑救 0 很重要，但如果你认为后卫拦截更重要，把 5 改成 *2.5，结果可能反转）。
- 扩展建议：如果你想让它更复杂，可以加入“失球数”减分项，或者加入“犯规次数”作为负面指标,这样就更贴近真实的足球数据分析系统了。
如果你希望我调整数据（比如让曼城获胜）,我也可以重新算给你看。
