Stream through collection and filter using a priority

I am trying to filter a collection based on a certain priority.
The collection consists of entities with fields of a certain type.

So, I would like to do the following:
Iterate/Stream through the collection and

1. Find the first entity which has a getType = "type1". If this entity has a price > 0 then return this entity. Otherwise

2. Find the next entity which has a getType = "type2". If this has a price > 0 then return this. Otherwise

3. Find the next entity which has a getType = "type3". If this has a price > 0 then return this.

4. Find the next entity which has a getType = "type4". If this has a price > 0 then return this.

5. Find the next entity which has a getType = "type5". If this has a price > 0 then return this.

6. Otherwise return.

I am trying to do this using stream but the filter step is where I am unable to create this priority type of filtering. I also tried to loop through the collection using a for, however not sure how to implement findFirst entity of type1, then type2 etc..

If you rephrase the requirement a bit, it makes the translation to a series of operations of a stream much clearer - you should return the first item with price > 0 that has the minimal type:

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

Original - Invalid reduction Approach

One option is to flip the order of operations. Ex: filter where 'price > 0' and then reduce the stream as elements are encountered. Ex:

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

Edit - More correct reduction approach

In general, it is best to keep stream operations stateless. Because of this creating a function which handles iterating through the list and returning the result may be a more correct approach. Using streams, a custom 'reducer' may be defined which keeps track of the prior type checked to determine if the next result is a possible valid match. Once a valid match is found, it is always returned.

    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); }
}

Edit - Alternative approach using filter

A filter may be created which does something similar to the reduce approach, and will have the benefit of short circuiting when calling 'findFirst'. In the below, the first filter only allows the first encounter with a given type (in order) to pass through. The second filter confirms it is valid.

    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;
}
}

Based on a clarification by Andreas and a strict interpretation of the requirements as presently stated, this should work.

• I basically streamed the types and then substreamed the list.
• The inner stream is checked for each type in priority order.
• if the first one found has a positive price it is returned.
• else the next type is checked and the process repeated
• In the event nothing matches, a special object is returned.

Class used to verify.

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);
}
}

Data

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" };

Solution

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);

Prints

[10, Type2]
</details>
# 答案4
**得分**: 0
```java
我可以考虑使用流来首先根据类型（假设类型为小写）进行排序，然后使用过滤器来过滤掉负价格，然后使用findFirst来将其存储在Optional实体中。
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()); // 测试以验证
}

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 
}