【日常开发】一个list集合 根据a字段 b字段进行分组 并计算c字段的和 并封装这种格式：年份【2023，2024】 然后 竖仓【1，2】 平仓 【1，2】 临时仓【50，0】

🎈边走、边悟🎈迟早会好

        要将一个包含多个对象的 List 集合根据 a 字段和 b 字段进行分组，并计算 c 字段的和，并封装成特定格式（例如：年份、竖仓、平仓、临时仓），可以按照以下步骤操作：

1. 定义一个包含字段 a、b 和 c 的类 Item。
2. 使用 Stream API 进行分组和求和操作。
3. 构建结果对象或结构，并输出结果。

   import java.util.*;
   import java.util.stream.Collectors;
   
   class Item {
       String year;
       String storageType;
       double amount;
   
       public Item(String year, String storageType, double amount) {
           this.year = year;
           this.storageType = storageType;
           this.amount = amount;
       }
   
       public String getYear() {
           return year;
       }
   
       public String getStorageType() {
           return storageType;
       }
   
       public double getAmount() {
           return amount;
       }
   }
   
   public class Main {
       public static void main(String[] args) {
           List<Item> items = Arrays.asList(
               new Item("2023", "竖仓", 1.2),
               new Item("2023", "平仓", 1.5),
               new Item("2023", "临时仓", 5.0),
               new Item("2024", "竖仓", 2.4),
               new Item("2024", "平仓", 2.0),
               new Item("2024", "临时仓", 0.0)
           );
   
           // 根据年份和仓库类型分组并计算总量
           Map<String, Map<String, Double>> groupedData = items.stream()
               .collect(Collectors.groupingBy(
                   Item::getYear,
                   Collectors.groupingBy(
                       Item::getStorageType,
                       Collectors.summingDouble(Item::getAmount)
                   )
               ));
   
           // 提取所有年份
           List<String> years = groupedData.keySet().stream().sorted().collect(Collectors.toList());
   
           // 提取竖仓、平仓、临时仓的数据
           List<Double> verticalStorage = new ArrayList<>();
           List<Double> flatStorage = new ArrayList<>();
           List<Double> temporaryStorage = new ArrayList<>();
   
           for (String year : years) {
               Map<String, Double> storageTypes = groupedData.get(year);
               verticalStorage.add(storageTypes.getOrDefault("竖仓", 0.0));
               flatStorage.add(storageTypes.getOrDefault("平仓", 0.0));
               temporaryStorage.add(storageTypes.getOrDefault("临时仓", 0.0));
           }
   
           // 输出结果
           System.out.println("年份: " + years);
           System.out.println("竖仓: " + verticalStorage);
           System.out.println("平仓: " + flatStorage);
           System.out.println("临时仓: " + temporaryStorage);
       }
   }
   

   在这个示例中：

1. 定义了一个包含 year、storageType 和 amount 字段的 Item 类。
2. 创建了一个包含多个 Item 对象的列表 items。
3. 使用 Stream API 进行分组操作，并计算 amount 字段的和。分组后的结果存储在 Map<String, Map<String, Double>> 中，其中外层 Map 的键是 year 字段的值，内层 Map 的键是 storageType 字段的值，值是对应的 amount 字段和。
4. 提取所有年份，按排序顺序生成年份列表。
5. 提取每个年份的竖仓、平仓和临时仓的数据。
6. 输出结果，显示年份、竖仓、平仓和临时仓的数据。

   年份: [2023, 2024]
   竖仓: [1.2, 2.4]
   平仓: [1.5, 2.0]
   临时仓: [5.0, 0.0]
   

 🌟感谢支持 听忆.-CSDN博客

🎈众口难调🎈从心就好