java流找到匹配还是最后一个？

Question

如何使用java流查找列表中的第一个匹配项或最后一个元素？

这意味着如果没有元素匹配条件,则返回最后一个元素.

例如:

OptionalInt i = IntStream.rangeClosed(1,5)
                         .filter(x-> x == 7)
                         .findFirst();
System.out.print(i.getAsInt());

我该怎么办才能让它返回5;

Answer 1

鉴于清单

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);

你可以这样做:

int value = list.stream().filter(x -> x == 2)
                         .findFirst()
                         .orElse(list.get(list.size() - 1));

这里,如果过滤器的计算结果为true,则检索该元素,否则返回最后一个元素.

如果列表为空,则可以返回默认值,例如-1.

int value = list.stream().filter(x -> x == 2)
                         .findFirst()
                         .orElse(list.isEmpty() ? -1 : list.get(list.size() - 1));

Answer 2

你可以使用这样的reduce()功能:

OptionalInt i = IntStream.rangeClosed(1, 5)
        .reduce((first, second) -> first == 7 ? first : second);
System.out.print(i.getAsInt());

Answer 3

基本上我会使用以下两种方法之一或其偏差:

流变体:

<T> T getFirstMatchOrLast(List<T> list, Predicate<T> filter, T defaultValue) {
    return list.stream()
            .filter(filter)
            .findFirst()
            .orElse(list.isEmpty() ? defaultValue : list.get(list.size() - 1));
}

非流式变体:

<T> T getFirstMatchOrLast(Iterable<T> iterable, Predicate<T> filter, T defaultValue) {
    T relevant = defaultValue;
    for (T entry : iterable) {
        relevant = entry;
        if (filter.test(entry))
            break;
    }
    return relevant;
}

或者正如Ilmari Karonen在评论中建议的那样,Iterable<T>你甚至可以打电话stream::iterator,以防你真的处理一个Stream而不是一个List.调用显示的方法如下所示:

getFirstMatchOrLast(Arrays.asList(1, 20, 3), i -> i == 20, 1); // returns 20
getFirstMatchOrLast(Collections.emptyList(), i -> i == 3, 20); // returns 20
getFirstMatchOrLast(Arrays.asList(1, 2, 20), i -> i == 7, 30); // returns 20
// only non-stream variant: having a Stream<Integer> stream = Stream.of(1, 2, 20)
getFirstMatchOrLast(stream::iterator, i -> i == 7, 30); // returns 20

我不会reduce在这里使用,因为在某种意义上我听起来不对,即使第一个条目已经匹配,它也会遍历整个条目,即它不再短路.而且对我来说它不像filter.findFirst.orElse...... 那么可读(但这可能只是我的意见)

我可能会最终得到如下内容:

<T> Optional<T> getFirstMatchOrLast(Iterable<T> iterable, Predicate<T> filter) {
    T relevant = null;
    for (T entry : iterable) {
        relevant = entry;
        if (filter.test(entry))
            break;
    }
    return Optional.ofNullable(relevant);
}
// or transform the stream variant to somethinng like that... however I think that isn't as readable anymore...

所以电话看起来像:

getFirstMatchOrLast(Arrays.asList(1, 2, 3, 5), i -> i == 7).orElseThrow(...)
getFirstMatchOrLast(Arrays.asList(1, 2, 3, 5), i -> i == 7).orElse(0);
getFirstMatchOrLast(Arrays.asList(1, 2, 3, 5), i -> i == 7).orElseGet(() -> /* complex formula */);
getFirstMatchOrLast(stream::iterator, i -> i == 5).ifPresent(...)