Java如何对List<Grocery>按yr分组，同category的tag价格求和后降序排序

对List<Grocery>按以下规则分组合并：

• 首先按yr字段对列表分组
• 相同yr分组内的tag列表按相同category合并，累加同category对应的price值
• 最终每个yr分组下的tag列表按price降序排序

// 注：原定义中拼写错误HahsMap已修正为HashMap
List<Grocery> groceryList = new ArrayList<>();
Grocery grocery = new Grocery();
List<HashMap<String, Object>> tagList = new ArrayList<>();
HashMap<String, Object> tagMap = new HashMap<>();

数据填充示例 #

tagMap.put("category", "A");
tagMap.put("name", "Apple");
tagMap.put("price", 10);
tagList.add(tagMap);

grocery.setYr(String yr);
grocery.setTag(List<HashMap<String, Object>> tagList);
groceryList.add(grocery);

[
  {
    "yr": "2021",
    "tag": [
      {
        "Category": "A",
        "Name": "Apple",
        "Price": 10
      }
    ]
  },
  {
    "yr": "2021",
    "tag": [
      {
        "Category": "A",
        "Name": "Apple",
        "Price": 10
      }
    ]
  },
  {
    "yr": "2021",
    "tag": [
      {
        "Category": "B",
        "Name": "Banana",
        "Price": 5
      }
    ]
  },
  {
    "yr": "2020",
    "tag": [
      {
        "Category": "A",
        "Name": "Apple",
        "Price": 10
      }
    ]
  },
  {
    "yr": "2020",
    "tag": [
      {
        "Category": "B",
        "Name": "Banana",
        "Price": 30
      }
    ]
  },
  {
    "yr": "2020",
    "tag": [
      {
        "Category": "C",
        "Name": "Candy",
        "Price": 10
      }
    ]
  },
  {
    "yr": "2020",
    "tag": [
      {
        "Category": "C",
        "Name": "Candy",
        "Price": 30
      }
    ]
  },
  {
    "yr": "2020",
    "tag": [
      {
        "Category": "A",
        "Name": "Apple",
        "Price": 10
      }
    ]
  }
]

[
  {
    "yr": "2021",
    "tag": [
      {
        "Category": "A",
        "Name": "Apple",
        "Price": 20
      },
      {
        "Category": "B",
        "Name": "Banana",
        "Price": 5
      }
    ]
  },
  {
    "yr": "2020",
    "tag": [
      {
        "Category": "C",
        "Name": "Candy",
        "Price": 40
      },
      {
        "Category": "B",
        "Name": "Banana",
        "Price": 30
      },
      {
        "Category": "A",
        "Name": "Apple",
        "Price": 20
      }
    ]
  }
]

实现思路 #

1. 按yr字段对原始groceryList分组，得到Map<String, List<Grocery>>结构
2. 遍历每个yr分组，聚合该分组下所有tag的价格：用临时Map存储category对应的名称和总价格，累加同category的price值
3. 将聚合后的category数据转为tagMap，按price降序排序
4. 组装每个yr的聚合结果为新的Grocery对象，生成最终结果列表

代码实现 #

import java.util.*;
import java.util.stream.Collectors;

// Grocery类定义
class Grocery {
    private String yr;
    private List<HashMap<String, Object>> tag;

    public String getYr() { return yr; }
    public void setYr(String yr) { this.yr = yr; }
    public List<HashMap<String, Object>> getTag() { return tag; }
    public void setTag(List<HashMap<String, Object>> tag) { this.tag = tag; }
}

public class GroceryProcessor {
    public List<Grocery> process(List<Grocery> groceryList) {
        // 按yr字段分组
        Map<String, List<Grocery>> yrGroupMap = groceryList.stream()
                .collect(Collectors.groupingBy(Grocery::getYr));

        List<Grocery> result = new ArrayList<>();

        // 处理每个年份分组
        for (Map.Entry<String, List<Grocery>> entry : yrGroupMap.entrySet()) {
            String yr = entry.getKey();
            List<Grocery> sameYrGroceries = entry.getValue();

            // 临时Map聚合分类数据，key为分类值，value存储[分类名称, 总价格]
            Map<String, AbstractMap.SimpleEntry<String, Integer>> categoryAggMap = new HashMap<>();

            for (Grocery grocery : sameYrGroceries) {
                for (HashMap<String, Object> tag : grocery.getTag()) {
                    String category = (String) tag.get("Category");
                    String name = (String) tag.get("Name");
                    Integer price = (Integer) tag.get("Price");

                    if (categoryAggMap.containsKey(category)) {
                        // 分类已存在，累加价格
                        AbstractMap.SimpleEntry<String, Integer> exist = categoryAggMap.get(category);
                        categoryAggMap.put(category, new AbstractMap.SimpleEntry<>(name, exist.getValue() + price));
                    } else {
                        // 分类不存在，新增记录
                        categoryAggMap.put(category, new AbstractMap.SimpleEntry<>(name, price));
                    }
                }
            }

            // 转换为tag列表并按价格降序排序
            List<HashMap<String, Object>> sortedTagList = categoryAggMap.entrySet().stream()
                    .map(cateEntry -> {
                        HashMap<String, Object> tag = new HashMap<>();
                        tag.put("Category", cateEntry.getKey());
                        tag.put("Name", cateEntry.getValue().getKey());
                        tag.put("Price", cateEntry.getValue().getValue());
                        return tag;
                    })
                    .sorted((t1, t2) -> (Integer) t2.get("Price") - (Integer) t1.get("Price"))
                    .collect(Collectors.toList());

            // 组装结果对象
            Grocery resGrocery = new Grocery();
            resGrocery.setYr(yr);
            resGrocery.setTag(sortedTagList);
            result.add(resGrocery);
        }

        // 如需按年份倒序/正序排列可自行添加排序逻辑
        return result;
    }
}

内容的提问来源于stack exchange，提问作者steamworks99