如何获取 Java Stream 中每种类型（按属性选择）的第一个对象（按函数排序）

想象一个具有 3 个属性的简单对象：

public class Obj {

    boolean toBeAdded;
    String type;
    int order;

    public Obj(boolean toBeAdded, String type, int order) {
        this.toBeAdded = toBeAdded;
        this.type = type;
        this.order = order;
    }

    public boolean isToBeAdded() {
        return toBeAdded;
    }

    public String getType() {
        return type;
    }

    public int getOrder() {
        return order;
    }

}

想象一下我有一个包含几个的列表Objs，具有不同类型：

import java.util.Arrays;
import java.util.List;

public class Utils {

    static List<Obj> createA(){
        List<Obj> list = Arrays.asList(
                new Obj(true, "A", 1),
                new Obj(false, "A", 2),
                new Obj(true, "A", 3),
                new Obj(false, "A", 4)
        );
        return list;
    }


    static List<Obj> createB(){
        List<Obj> list = Arrays.asList(
                new Obj(true, "B", 1),
                new Obj(false, "B", 2),
                new Obj(true, "B", 3),
                new Obj(false, "B", 4)
        );
        return list;
    }


    static List<Obj> createC(){
        List<Obj> list = Arrays.asList(
                new Obj(false, "C", 1),
                new Obj(false, "C", 2),
                new Obj(true, "C", 3),
                new Obj(true, "C", 4)
        );
        return list;
    }
}

我想以某种方式过滤这个列表并获得最新的Obj（最高order值）对于每个type可以添加（toBeAdded = true).

对于此示例，结果应该是一个包含以下内容的列表：

• Obj1：类型 1，顺序 3
• Obj2：类型 2，顺序 3
• Obj3：类型 3，顺序 4

我知道如何过滤和如何排序，但我仍然不明白如何获得每个子类型中的第一个。这是否反对Stream规则？因为我想做的基本上是解析N个不同的子流，对于N个不同的子流types?

到目前为止我可以做的是：

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

public class MainTest {

    public static void main(String[] args) {

        List<Obj> list = new ArrayList<>();
        list.addAll(Utils.createA());
        list.addAll(Utils.createB());
        list.addAll(Utils.createC());

        System.out.println(list);

        List<Obj> filteredList = list
                .stream()
                .filter(Obj::isToBeAdded)
                .sorted(Comparator.comparingInt(Obj::getOrder).reversed())
                .collect(Collectors.toList());

        System.out.println(filteredList);

    }


}

然而，这只是完成简单的部分——过滤和排序。我仍然需要做类似的事情findFirst()对于每个type。有什么办法可以做到这一点吗？

我是否必须执行 3 个不同的流（每种类型一个），然后合并列表？有没有办法在不知道我们将有多少类型的情况下做到这一点？ 我还读到collect(Collectors.groupingBy())但这会为每种类型创建不同的地图，这是我不想要的。

Using groupingBy可以与下游一起提供帮助minBy/maxBy。这将提供一个映射来查找过滤后的值是否存在于每种类型中。

Map<String, Optional<Obj>> groupMaxOrderByType = list.stream()
        .filter(Obj::isToBeAdded)
        .collect(Collectors.groupingBy(Obj::getType,
                Collectors.maxBy(Comparator.comparingInt(Obj::getOrder)))); //highest order

对这些对象的查找或访问将转换为如下内容：

Obj maxPerTypeA = groupMaxOrderByType.get("A").orElse.. // similar for each type

Edit：或者，如果您要将所有此类现有类型收集到最终结果中，您可以按照以下步骤访问Map.

List<Obj> result = groupMaxOrderByType.values().stream()
        .filter(Optional::isPresent)
        .map(Optional::get)
        .collect(Collectors.toList());

Edit：或者摆脱处理Optional， 您可以使用toMap with BinaryOperator.maxBy作为合并函数。

Map<String, Obj> groupMaxOrderByType = list.stream()
        .filter(Obj::isToBeAdded)
        .collect(Collectors.toMap(Obj::getType, Function.identity(), 
                BinaryOperator.maxBy(Comparator.comparingInt(Obj::getOrder))));
List<Obj> result = new ArrayList<>(groupMaxOrderByType.values());