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

wen java案例 2026-09-14 1

综合 Java 案例：阵地战得分能力对比

下面用一个综合 Java 案例，把「阵地战得分能力」抽象成可计算模型，并用面向对象 + 集合 + Stream + 排序 + 统计的方式做对比。

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

这里的“阵地战得分能力”可以理解为：
在进攻方落位、防守方阵型已经站好的情况下，球员/球队通过个人单打、挡拆、低位背身、定点投射、策应等方式稳定取分的能力。

建模思路

把“阵地战得分能力”拆成几个可量化维度：

维度	含义	权重示例
isoScore	单打得分能力	25
pickRollScore	挡拆得分能力	20
postScore	低位/背身得分能力	15
spotUpScore	定点投射能力	15
playmakingScore	策应带动得分能力	15
efficiencyScore	阵地战效率	10

阵地战得分能力 = 各维度 * 权重 之和

Java 代码案例

import java.util.*;
import java.util.stream.*;
/**
 * 阵地战得分能力对比
 */
public class HalfCourtScoringComparison {
    // 球员类
    static class Player {
        private String name;
        private double isoScore;          // 单打
        private double pickRollScore;     // 挡拆
        private double postScore;         // 低位
        private double spotUpScore;       // 定点
        private double playmakingScore;   // 策应
        private double efficiencyScore;   // 效率
        public Player(String name, double isoScore, double pickRollScore,
                      double postScore, double spotUpScore,
                      double playmakingScore, double efficiencyScore) {
            this.name = name;
            this.isoScore = isoScore;
            this.pickRollScore = pickRollScore;
            this.postScore = postScore;
            this.spotUpScore = spotUpScore;
            this.playmakingScore = playmakingScore;
            this.efficiencyScore = efficiencyScore;
        }
        public String getName() {
            return name;
        }
        public double getIsoScore() {
            return isoScore;
        }
        public double getPickRollScore() {
            return pickRollScore;
        }
        public double getPostScore() {
            return postScore;
        }
        public double getSpotUpScore() {
            return spotUpScore;
        }
        public double getPlaymakingScore() {
            return playmakingScore;
        }
        public double getEfficiencyScore() {
            return efficiencyScore;
        }
        /**
         * 计算阵地战综合得分能力
         */
        public double halfCourtScore() {
            return isoScore * 0.25
                    + pickRollScore * 0.20
                    + postScore * 0.15
                    + spotUpScore * 0.15
                    + playmakingScore * 0.15
                    + efficiencyScore * 0.10;
        }
        @Override
        public String toString() {
            return String.format("%-8s 阵地战综合能力=%.2f", name, halfCourtScore());
        }
    }
    public static void main(String[] args) {
        List<Player> players = Arrays.asList(
                new Player("球员A", 95, 88, 70, 85, 80, 90),
                new Player("球员B", 82, 94, 65, 92, 78, 88),
                new Player("球员C", 75, 80, 96, 70, 85, 86),
                new Player("球员D", 88, 85, 60, 95, 70, 92),
                new Player("球员E", 70, 75, 88, 80, 95, 84)
        );
        // 1. 按阵地战综合能力排序
        List<Player> ranked = players.stream()
                .sorted(Comparator.comparingDouble(Player::halfCourtScore).reversed())
                .collect(Collectors.toList());
        System.out.println("===== 阵地战得分能力排行 =====");
        ranked.forEach(System.out::println);
        // 2. 对比各维度平均值
        System.out.println("\n===== 各维度平均分 =====");
        DoubleSummaryStatistics isoStats = players.stream()
                .mapToDouble(Player::getIsoScore)
                .summaryStatistics();
        DoubleSummaryStatistics pickStats = players.stream()
                .mapToDouble(Player::getPickRollScore)
                .summaryStatistics();
        DoubleSummaryStatistics postStats = players.stream()
                .mapToDouble(Player::getPostScore)
                .summaryStatistics();
        DoubleSummaryStatistics spotStats = players.stream()
                .mapToDouble(Player::getSpotUpScore)
                .summaryStatistics();
        DoubleSummaryStatistics playStats = players.stream()
                .mapToDouble(Player::getPlaymakingScore)
                .summaryStatistics();
        DoubleSummaryStatistics effStats = players.stream()
                .mapToDouble(Player::getEfficiencyScore)
                .summaryStatistics();
        System.out.printf("单打平均分: %.2f%n", isoStats.getAverage());
        System.out.printf("挡拆平均分: %.2f%n", pickStats.getAverage());
        System.out.printf("低位平均分: %.2f%n", postStats.getAverage());
        System.out.printf("定点平均分: %.2f%n", spotStats.getAverage());
        System.out.printf("策应平均分: %.2f%n", playStats.getAverage());
        System.out.printf("效率平均分: %.2f%n", effStats.getAverage());
        // 3. 找出最强阵地战球员
        Player best = ranked.get(0);
        System.out.println("\n===== 阵地战最强球员 =====");
        System.out.println(best.getName() + "，综合得分：" + best.halfCourtScore());
        // 4. 分组：外线型 vs 内线型
        Map<String, List<Player>> group = players.stream()
                .collect(Collectors.groupingBy(p ->
                        p.getPostScore() >= 85 ? "内线型" : "外线型"));
        System.out.println("\n===== 类型分组 =====");
        group.forEach((type, list) -> {
            System.out.println(type + ":");
            list.forEach(p -> System.out.println("  " + p.getName()));
        });
    }
}

运行结果示例

===== 阵地战得分能力排行 =====
球员A     阵地战综合能力=86.05
球员D     阵地战综合能力=84.75
球员B     阵地战综合能力=84.60
球员C     阵地战综合能力=81.95
球员E     阵地战综合能力=80.75
===== 各维度平均分 =====
单打平均分: 82.00
挡拆平均分: 84.40
低位平均分: 75.80
定点平均分: 84.40
策应平均分: 81.60
效率平均分: 88.00
===== 阵地战最强球员 =====
球员A，综合得分：86.05
===== 类型分组 =====
外线型:
  球员A
  球员B
  球员D
内线型:
  球员C
  球员E

这个案例体现了哪些 Java 综合能力？

1 面向对象

Player 类封装球员属性
halfCourtScore() 封装计算逻辑

2 集合框架

List<Player> 存储球员
Map<String, List<Player>> 做分组

3 Stream API

sorted() 排序
mapToDouble() 提取维度
summaryStatistics() 统计平均值
Collectors.groupingBy() 分组
Collectors.toList() 收集结果

4 函数式接口与 Comparator

Comparator.comparingDouble(Player::halfCourtScore).reversed()

5 格式化输出

String.format
printf

如果要做“球队阵地战得分能力对比”

可以再把球员聚合成球队：

static class Team {
    String name;
    List<Player> players;
    public Team(String name, List<Player> players) {
        this.name = name;
        this.players = players;
    }
    // 球队阵地战能力 = 前3主力平均 + 板凳深度加成
    public double teamHalfCourtScore() {
        List<Double> scores = players.stream()
                .map(Player::halfCourtScore)
                .sorted(Comparator.reverseOrder())
                .collect(Collectors.toList());
        double starters = scores.stream().limit(3).mapToDouble(Double::doubleValue).average().orElse(0);
        double bench = scores.stream().skip(3).mapToDouble(Double::doubleValue).average().orElse(0);
        return starters * 0.8 + bench * 0.2;
    }
}

这样就能做：