使用优先级通过集合和过滤器进行流式传输

Question

我正在尝试根据特定优先级过滤集合。 该集合由具有特定类型字段的实体组成。

所以，我想做以下事情： 通过集合迭代/流式传输和

1. 找到第一个具有 getType = "type1" 的实体。如果此实体的价格 > 0，则返回此实体。否则

2. 查找下一个具有 getType = "type2" 的实体。如果它的价格 > 0，则返回它。否则

3. 查找下一个具有 getType = "type3" 的实体。如果它的价格 > 0，则返回它。

4. 查找下一个具有 getType = "type4" 的实体。如果它的价格 > 0，则返回它。

5. 查找下一个具有 getType = "type5" 的实体。如果它的价格 > 0，则返回它。

6. 否则返回。

我正在尝试使用流来执行此操作，但过滤步骤是我无法创建这种优先级过滤类型的地方。我还尝试使用 for 遍历集合，但不确定如何实现 type1 的 findFirst 实体，然后是 type2 等。

Answer 1

如果你稍微改一下这个要求，它会使流的一系列操作的转换更加清晰 - 你应该返回第一个带有 price > 0 的项目，它具有最小的 type：

MyEntity result = myList.stream()
                        .filter(e -> e.getPrice() > 0)
                        .min(Compartor.comparing(MyEntity::getType))
                        .orElse(null);

Answer 2

原始 - 无效的缩减方法

一种选择是翻转操作顺序。例如：过滤“价格> 0”的位置，然后在遇到元素时减少流。例如：

stream.filter(elem -> elem.price > 0)
    .reduce((elem1, elem2) -> elem1.type.compareTo(elem2.type) < 0 ? elem1 : elem2)

编辑 - 更正确的缩减方法

一般来说，最好保持流操作无状态。因此，创建一个处理遍历列表并返回结果的函数可能是一种更正确的方法。使用流，可以定义一个自定义的“reducer”，它跟踪检查的先前类型以确定下一个结果是否是可能的有效匹配。一旦找到一个有效的匹配，它总是被返回。

    public static void main(String[] args)
    {
        List<Entity> data = Arrays.asList(eee(2, 6), eee(1, 0), eee(1, 10), eee(3, 7), eee(2, 0), eee(3, 5), eee(4, 0), eee(5, 0));
        System.out.println(data.stream().reduce(new Reducer()).filter(entity -> entity != Reducer.NO_MATCH));
    }

    /*Once a match is found, always use it. For a given type, only the first found entity of that type will be used*/
    public static final class Reducer implements BinaryOperator<Entity>
    {
        private int priorValidType;
        Reducer(){ this.priorValidType = 0; }

        @Override
        public Entity apply(Entity result, Entity newElem)
        {
            int nextValidType = priorValidType + 1;
            if(priorValidType > 0 && result != NO_MATCH) return result; /*Match already found, use it*/
            if(result.type == nextValidType && result.price > 0) { priorValidType = nextValidType; return result; } /*result is a match*/
            if(newElem.type == nextValidType && newElem.price > 0) { priorValidType = nextValidType; return newElem; } /*newElem is a match*/
            if(result.type == nextValidType || newElem.type == nextValidType) { priorValidType = nextValidType; }
            return NO_MATCH; /*No match has been found*/
        }

        public static final Entity NO_MATCH = new Entity(-1, -1);
    }

    public static final class Entity
    {
        private final int price, type;
        Entity(int type, int price){ this.price = price; this.type = type; }
        public String toString(){ return "(" + type + ", " + price + ")"; }
        int getPrice(){ return price; }
        int getType(){ return type; }
        public static Entity eee(int type, int price){ return new Entity(type, price); }
    }

编辑 - 使用过滤器的替代方法

可以创建一个过滤器，它执行类似于reduce 方法的操作，并且在调用“findFirst”时具有短路的好处。在下面，第一个过滤器只允许第一次遇到给定类型（按顺序）通过。第二个过滤器确认它是有效的。

    public static void main(String[] args)
    {
        List<Entity> data = Arrays.asList(eee(2, 6), eee(1, 0), eee(1, 10), eee(3, 7), eee(2, 0), eee(3, 5), eee(4, 0), eee(5, 0));
        System.out.println(data.stream().filter(new FirstTypeMatch()).filter(entity -> entity.price > 0).findFirst());
    }

    /*Filter where the element is the first of the given type*/
    public static final class FirstTypeMatch implements Predicate<Entity>
    {
        private int priorValidType = 0;
        @Override
        public boolean test(Entity nextElem)
        {
            if(nextElem.type == (priorValidType + 1)){ priorValidType++; return true; }
            return false;
        }
    }

Answer 3

根据Andreas 的澄清和对目前所述要求的严格解释，这应该可行。

• 我基本上是流式传输types，然后再传输list。
• 按优先级顺序检查每个类型的内部流。
• 如果找到的第一个价格为正值，则将其退回。
• 否则检查下一个类型并重复该过程
• 如果没有匹配项，则返回一个特殊对象。

用于验证的类。

class MyClass {
    private int price;
    private String type;
    
    public MyClass(int price, String type) {
        this.price = price;
        this.type = type;
    }
    
    public int getPrice() {
        return price;
    }
    
    public String getType() {
        return type;
    }
    
    public String toString() {
        return String.format("[%s, %s]", price, type);
    }
}

数据

List<MyClass> list = List.of(new MyClass(0, "Type1"),
        new MyClass(10, "Type2"), new MyClass(2, "Type1"),
        new MyClass(2, "Type4"), new MyClass(2, "Type5"),
        new MyClass(2, "Type2"), new MyClass(10, "Type1"),
        new MyClass(1, "Type2"), new MyClass(2, "Type5"));

String[] types =
        { "Type1", "Type2", "Type3", "Type4", "Type5" };

解决方案

MyClass selected = Arrays.stream(types)
        .map(type -> list.stream()
                .filter(obj -> obj.getType().equals(type))
                .findFirst()
                .orElse(null))
        .filter(a -> a != null && a.getPrice() > 0)
        .findFirst().orElse(new MyClass(-1, "Empty"));

System.out.println(selected);

打印

[10, Type2]

Answer 4

我可以考虑使用stream先根据Type（假设type为小写）进行排序，然后使用filter过滤掉负价格，然后使用findFirst将其存储在Optional Entity中

Optional<Entity> entity = list.stream().sorted(Comparator.comparing(Entity::getType))
.filter( e -> e.price > 0 ).findFirst();
     

if(entity.isPresent()){
    System.out.println(entity.get().getType()); // test to verify 
}