使用流按多个属性分组和排序：Java 8

问题描述

我有 MainEntity

的列表

public class MainEntity {
private String keyword;
private double cost;
private String company;
}

我有 CompanyEntity

public class CompanyEntity {
    private double cost;
    private String company;
    }

我正在尝试将列表转换成Map<String,List<CompanyEntity>>，其中键将为keyword，而List<CompanyEntity>将具有所有成本的平均值，并且也将其排序。我正在尝试在流和Java 8中实现。

对于输入的特定关键字，我正在这样做。

List<MainEntity> entityList = keyWordMap.get(entity.getKeyword());
        entityList.add(entity);
        keyWordMap.put(entity.getKeyword(),entityList);

Map<String,Double> average = (keyWordMap.get(keyword)).stream()
            .collect(groupingBy(MainEntity::getCompany,Collectors.averagingDouble(MainEntity::getCtr)));
    result.put(keyword,new ArrayList<>());

    for (Map.Entry<String,Double> entity : average.entrySet()) {
        result.get(keyword).add(new CompanyEntity(entity.getKey(),entity.getValue()));
    }

但是我试图为所有关键字创建一个地图。是否可能或再次遍历整个列表有意义？ 当前keyowordMap的类型为Map<String,MainEntity>，我通过迭代MainEntity的列表来做到这一点，但是我想要Map<String,List<MainEntity>>。

解决方法

首先，制作一个keyWordMap

Map<String,List<MainEntity>> keyWordMap = 
            mainEntityList
            .stream()
            .collect(Collectors.groupingBy(MainEntity::getKeyword));

然后迭代地图，对于每个关键字，您可以直接获取按平均值排序的CompanyEntity列表，并使用map()转换数据并收集为List，然后放入{{1 }}

result

或者您想一次性完成

Map<String,List<CompanyEntity>> result = ....
for (Map.Entry<String,List<MainEntity> entry : keyWordMap.entrySet()) {
    List<CompanyEntity> list = entry.getValue().stream()
                .collect(groupingBy(MainEntity::getCompany,Collectors.averagingDouble(MainEntity::getCtr)))
                .entrySet()
                .stream()
                .sorted(Comparator.comparing(e -> e.getValue()))
                .map(e -> new CompanyEntity(e.getKey(),e.getValue()))
                .collect(Collectors.toList());
    result.put(entry.getKey(),list);
}

,

在最初误解了该问题之后，另一个答案完全改变了答案，并以良好的StackOverflow精神吸引了第一个赞，因此现在被接受并被最高赞。但这在代码中显示了正在发生的事情的更多步骤：

这应该为您带来结果：

import java.io.IOException;
import java.util.AbstractMap.SimpleEntry;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import lombok.Value;

public class CompanyEntityStackOverflowQuestion {

    public static void main(String[] args) throws IOException {

        //setup test data
        MainEntity one = new MainEntity("key1",10D,"company1");
        MainEntity two = new MainEntity("key2",5D,"company2");
        MainEntity three = new MainEntity("key1",7D,"company3");
        MainEntity four = new MainEntity("key2",3D,"company4");
        List<MainEntity> mainEntityList = List.of(one,two,three,four);

        //group list by keyword
        Map<String,List<MainEntity>> mainEntityByKeyword = mainEntityList.stream()
            .collect(Collectors.groupingBy(MainEntity::getKeyword));

        //map to companyEntity object
        Stream<SimpleEntry<String,List<CompanyEntity>>> mapped = mainEntityByKeyword.entrySet().stream()
            .map(entry -> new SimpleEntry<>(entry.getKey(),entry.getValue().stream().map(
                getCompanyListFunction()).collect(Collectors.toList())));

        //sort and calculate average
        Stream<SimpleEntry<String,CompanyEntityListWithStats>> mappedToListWithStats = mapped
            .map(entry -> new SimpleEntry<>(entry.getKey(),new CompanyEntityListWithStats(entry.getValue().stream().mapToDouble(company -> company.cost).average().orElse(0D),//or use Collectors.averagingDouble(company -> company.cost))
                    sortList(entry.getValue()))));

        //collect back to map
        Map<String,CompanyEntityListWithStats> collect = mappedToListWithStats
            .collect(Collectors.toMap(Entry::getKey,Entry::getValue));

        //show result
        System.out.println(collect);
    }

    //sort by cost
    private static List<CompanyEntity> sortList(List<CompanyEntity> list) {
        list.sort(Comparator.comparing(company -> company.cost));
        return list;
    }

    //map MainEntity to CompanyEntity
    private static Function<MainEntity,CompanyEntity> getCompanyListFunction() {
        return mainEntity -> new CompanyEntity(mainEntity.cost,mainEntity.company);
    }

    @Value
    public static class MainEntity {

        public String keyword;
        public double cost;
        public String company;
    }

    @Value
    public static class CompanyEntity {

        public double cost;
        public String company;
    }

    @Value
    public static class CompanyEntityListWithStats {

        public double average;
        public List<CompanyEntity> companyList;
    }


}

输出：{key1=CompanyEntityStackOverflowQuestion.CompanyEntityListWithStats(average=8.5,companyList=[CompanyEntityStackOverflowQuestion.CompanyEntity(cost=7.0,company=company3),CompanyEntityStackOverflowQuestion.CompanyEntity(cost=10.0,company=company1)]),key2=CompanyEntityStackOverflowQuestion.CompanyEntityListWithStats(average=4.0,companyList=[CompanyEntityStackOverflowQuestion.CompanyEntity(cost=3.0,company=company4),CompanyEntityStackOverflowQuestion.CompanyEntity(cost=5.0,company=company2)])}

您也许可以跳过一些步骤，只需快速输入即可。当然，您可以内联东西以使其看起来更短/更干净，但是这种格式可以显示正在发生的事情。