这个java案例显示体能消耗数据差异？

本文目录导读：

1. Java体能消耗数据差异示例
2. 关键功能说明
3. 运行结果示例

我理解您想了解Java中如何展示体能消耗数据的差异,由于您没有提供具体的代码，我将为您提供一个完整的Java示例，演示如何计算和展示不同运动类型的体能消耗差异。

Java体能消耗数据差异示例

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
 * 体能消耗数据差异分析系统
 */
public class EnergyExpenditureAnalyzer {
    // 运动类型枚举
    public enum ExerciseType {
        RUNNING("跑步", 10.5),      // 每公斤体重每小时消耗千卡
        SWIMMING("游泳", 8.2),
        CYCLING("骑行", 7.5),
        YOGA("瑜伽", 3.5),
        WALKING("步行", 3.0),
        BASKETBALL("篮球", 11.3);
        private final String displayName;
        private final double caloriesPerKgPerHour;
        ExerciseType(String displayName, double caloriesPerKgPerHour) {
            this.displayName = displayName;
            this.caloriesPerKgPerHour = caloriesPerKgPerHour;
        }
        public String getDisplayName() { return displayName; }
        public double getCaloriesPerKgPerHour() { return caloriesPerKgPerHour; }
    }
    // 运动记录类
    public static class ExerciseRecord {
        private final String personName;
        private final double weightKg;
        private final ExerciseType exerciseType;
        private final double durationHours;
        public ExerciseRecord(String personName, double weightKg, 
                            ExerciseType exerciseType, double durationHours) {
            this.personName = personName;
            this.weightKg = weightKg;
            this.exerciseType = exerciseType;
            this.durationHours = durationHours;
        }
        public double calculateCalories() {
            return weightKg * exerciseType.getCaloriesPerKgPerHour() * durationHours;
        }
        public String getPersonName() { return personName; }
        public double getWeightKg() { return weightKg; }
        public ExerciseType getExerciseType() { return exerciseType; }
        public double getDurationHours() { return durationHours; }
    }
    // 统计分析类
    public static class AnalysisResult {
        private final double maxCalories;
        private final double minCalories;
        private final double averageCalories;
        private final double variance;
        private final double standardDeviation;
        private final double maxMinRatio;
        public AnalysisResult(List<Double> caloriesList) {
            if (caloriesList.isEmpty()) {
                throw new IllegalArgumentException("数据列表不能为空");
            }
            this.maxCalories = caloriesList.stream().max(Double::compareTo).orElse(0);
            this.minCalories = caloriesList.stream().min(Double::compareTo).orElse(0);
            this.averageCalories = caloriesList.stream().mapToDouble(Double::doubleValue).average().orElse(0);
            // 计算方差和标准差
            double sumSquares = caloriesList.stream()
                .mapToDouble(c -> Math.pow(c - averageCalories, 2))
                .sum();
            this.variance = sumSquares / caloriesList.size();
            this.standardDeviation = Math.sqrt(variance);
            this.maxMinRatio = maxCalories / minCalories;
        }
        public double getMaxCalories() { return maxCalories; }
        public double getMinCalories() { return minCalories; }
        public double getAverageCalories() { return averageCalories; }
        public double getVariance() { return variance; }
        public double getStandardDeviation() { return standardDeviation; }
        public double getMaxMinRatio() { return maxMinRatio; }
    }
    public static void main(String[] args) {
        // 创建测试数据
        List<ExerciseRecord> records = createTestData();
        System.out.println("===== 体能消耗数据分析系统 =====");
        System.out.println();
        // 1. 展示所有运动记录
        displayAllRecords(records);
        // 2. 按运动类型统计分析
        displayExerciseTypeAnalysis(records);
        // 3. 按人员统计分析
        displayPersonAnalysis(records);
        // 4. 总体统计分析
        displayOverallStatistics(records);
        // 5. 差异比较
        displayComparisons(records);
    }
    private static List<ExerciseRecord> createTestData() {
        List<ExerciseRecord> records = new ArrayList<>();
        // 添加不同人员的运动记录
        records.add(new ExerciseRecord("张三", 70.0, ExerciseType.RUNNING, 1.0));
        records.add(new ExerciseRecord("张三", 70.0, ExerciseType.YOGA, 1.5));
        records.add(new ExerciseRecord("李四", 65.0, ExerciseType.SWIMMING, 1.0));
        records.add(new ExerciseRecord("李四", 65.0, ExerciseType.BASKETBALL, 2.0));
        records.add(new ExerciseRecord("王五", 80.0, ExerciseType.CYCLING, 3.0));
        records.add(new ExerciseRecord("王五", 80.0, ExerciseType.WALKING, 2.0));
        records.add(new ExerciseRecord("赵六", 75.0, ExerciseType.RUNNING, 2.0));
        records.add(new ExerciseRecord("赵六", 75.0, ExerciseType.BASKETBALL, 1.5));
        records.add(new ExerciseRecord("钱七", 68.0, ExerciseType.SWIMMING, 1.5));
        records.add(new ExerciseRecord("钱七", 68.0, ExerciseType.CYCLING, 2.0));
        return records;
    }
    private static void displayAllRecords(List<ExerciseRecord> records) {
        System.out.println("【所有运动记录】");
        System.out.println("人员\t\t体重(kg)\t运动类型\t时长(小时)\t消耗(千卡)");
        System.out.println("=".repeat(80));
        records.stream()
            .sorted(Comparator.comparingDouble(ExerciseRecord::calculateCalories).reversed())
            .forEach(record -> {
                System.out.printf("%-8s\t%-8.1f\t%-8s\t%-8.1f\t%.2f%n",
                    record.getPersonName(),
                    record.getWeightKg(),
                    record.getExerciseType().getDisplayName(),
                    record.getDurationHours(),
                    record.calculateCalories());
            });
        System.out.println();
    }
    private static void displayExerciseTypeAnalysis(List<ExerciseRecord> records) {
        System.out.println("【按运动类型分析】");
        System.out.println("运动类型\t\t平均消耗(千卡)\t最大消耗\t最小消耗\t参与次数");
        System.out.println("=".repeat(80));
        Map<ExerciseType, List<ExerciseRecord>> byType = records.stream()
            .collect(Collectors.groupingBy(ExerciseRecord::getExerciseType));
        byType.forEach((type, typeRecords) -> {
            List<Double> calories = typeRecords.stream()
                .map(ExerciseRecord::calculateCalories)
                .collect(Collectors.toList());
            double avg = calories.stream().mapToDouble(Double::doubleValue).average().orElse(0);
            double max = calories.stream().max(Double::compareTo).orElse(0);
            double min = calories.stream().min(Double::compareTo).orElse(0);
            System.out.printf("%-8s\t\t%.2f\t\t%.2f\t\t%.2f\t\t%d%n",
                type.getDisplayName(), avg, max, min, typeRecords.size());
        });
        System.out.println();
    }
    private static void displayPersonAnalysis(List<ExerciseRecord> records) {
        System.out.println("【按人员分析】");
        System.out.println("人员\t\t总消耗(千卡)\t平均每次\t运动次数\t最高单次消耗");
        System.out.println("=".repeat(80));
        Map<String, List<ExerciseRecord>> byPerson = records.stream()
            .collect(Collectors.groupingBy(ExerciseRecord::getPersonName));
        byPerson.forEach((person, personRecords) -> {
            List<Double> calories = personRecords.stream()
                .map(ExerciseRecord::calculateCalories)
                .collect(Collectors.toList());
            double total = calories.stream().mapToDouble(Double::doubleValue).sum();
            double avg = total / calories.size();
            double max = calories.stream().max(Double::compareTo).orElse(0);
            System.out.printf("%-8s\t\t%.2f\t\t%.2f\t\t%d\t\t%.2f%n",
                person, total, avg, calories.size(), max);
        });
        System.out.println();
    }
    private static void displayOverallStatistics(List<ExerciseRecord> records) {
        System.out.println("【总体统计分析】");
        System.out.println("=".repeat(80));
        List<Double> allCalories = records.stream()
            .map(ExerciseRecord::calculateCalories)
            .collect(Collectors.toList());
        AnalysisResult result = new AnalysisResult(allCalories);
        System.out.printf("最大消耗: %.2f 千卡%n", result.getMaxCalories());
        System.out.printf("最小消耗: %.2f 千卡%n", result.getMinCalories());
        System.out.printf("平均消耗: %.2f 千卡%n", result.getAverageCalories());
        System.out.printf("方差: %.2f%n", result.getVariance());
        System.out.printf("标准差: %.2f%n", result.getStandardDeviation());
        System.out.printf("最大/最小比: %.2f 倍%n", result.getMaxMinRatio());
        System.out.printf("数据离散程度: %s%n", 
            result.getStandardDeviation() > 100 ? "高" : 
            result.getStandardDeviation() > 50 ? "中等" : "低");
        System.out.println();
    }
    private static void displayComparisons(List<ExerciseRecord> records) {
        System.out.println("【数据差异分析】");
        System.out.println("=".repeat(80));
        // 找出最高和最低消耗记录
        ExerciseRecord most = records.stream()
            .max(Comparator.comparingDouble(ExerciseRecord::calculateCalories))
            .orElseThrow();
        ExerciseRecord least = records.stream()
            .min(Comparator.comparingDouble(ExerciseRecord::calculateCalories))
            .orElseThrow();
        System.out.println("最高消耗记录:");
        System.out.printf("  人员: %s, 运动: %s, 消耗: %.2f 千卡%n",
            most.getPersonName(), 
            most.getExerciseType().getDisplayName(),
            most.calculateCalories());
        System.out.println("最低消耗记录:");
        System.out.printf("  人员: %s, 运动: %s, 消耗: %.2f 千卡%n",
            least.getPersonName(),
            least.getExerciseType().getDisplayName(),
            least.calculateCalories());
        double difference = most.calculateCalories() - least.calculateCalories();
        System.out.printf("最大差值: %.2f 千卡%n", difference);
        // 不同人员的比较
        System.out.println("\n不同人员体能消耗对比:");
        Map<String, List<ExerciseRecord>> byPerson = records.stream()
            .collect(Collectors.groupingBy(ExerciseRecord::getPersonName));
        byPerson.entrySet().stream()
            .sorted((e1, e2) -> {
                double s1 = e1.getValue().stream().mapToDouble(ExerciseRecord::calculateCalories).sum();
                double s2 = e2.getValue().stream().mapToDouble(ExerciseRecord::calculateCalories).sum();
                return Double.compare(s2, s1);
            })
            .forEach(entry -> {
                double total = entry.getValue().stream()
                    .mapToDouble(ExerciseRecord::calculateCalories)
                    .sum();
                System.out.printf("  %s: 总消耗 %.2f 千卡%n", entry.getKey(), total);
            });
        // 数据离散性分析
        List<Double> calories = records.stream()
            .map(ExerciseRecord::calculateCalories)
            .collect(Collectors.toList());
        double mean = calories.stream().mapToDouble(Double::doubleValue).average().orElse(0);
        double max = calories.stream().max(Double::compareTo).orElse(0);
        double min = calories.stream().min(Double::compareTo).orElse(0);
        System.out.printf("%n数据范围: %.2f ~ %.2f (差值: %.2f)%n", min, max, max - min);
        System.out.printf("平均偏差率: %.2f%%%n", 
            calories.stream()
                .mapToDouble(c -> Math.abs(c - mean) / mean * 100)
                .average()
                .orElse(0));
    }
}

关键功能说明

1. 数据模型：使用枚举定义不同运动类型及对应的热量消耗系数

2. 统计分析：计算最大值、最小值、平均值、方差、标准差等统计指标

3. 差异可视化：

   • 按运动类型比较不同运动的消耗差异
   • 按人员比较不同个体的消耗差异
   • 计算最大差值、离散程度等指标

4. 排序功能：按消耗量降序排列，直观显示差异

运行结果示例

运行此程序,您会看到：

• 所有运动记录及其消耗量
• 不同运动类型的平均消耗对比
• 不同人员的总消耗对比
• 总体统计指标（最大值、最小值、标准差等）
• 数据差异的可视化展示

这个案例充分展示了体能消耗数据在不同人群、不同运动类型之间的显著差异，帮助您更好地理解运动消耗的多样性。