Htykuut

How to find the first match or the last element in a list using java stream?

Which means if no element matches the condition，then return the last element.

eg:

OptionalInt i = IntStream.rangeClosed(1,5)

                         .filter(x-> x == 7)

                         .findFirst();

System.out.print(i.getAsInt());

What should I do to make it return 5;

Given the list

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

You could just do :

int value = list.stream().filter(x -> x == 2)

                         .findFirst()

                         .orElse(list.get(list.size() - 1));

Here if the filter evaluates to true the element is retrieved, else the last element in the last is returned.

If the list is empty you could return a default value, for example -1.

int value = list.stream().filter(x -> x == 2)

                         .findFirst()

                         .orElse(list.isEmpty() ? -1 : list.get(list.size() - 1));

You can use reduce() function like that:

OptionalInt i = IntStream.rangeClosed(1, 5)

        .reduce((first, second) -> first == 7 ? first : second);

System.out.print(i.getAsInt());

Basically I would use one of the following two methods or deviations thereof:

Stream variant:

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

}

non-stream variant:

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

}

Or as also Ilmari Karonen suggested in the comment with Iterable<T> you are then able to even call stream::iterator in case you really deal with a Stream instead of a List. Calling the shown methods would look as follows:

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

I wouldn't use reduce here because it sounds wrong to me in the sense, that it also goes through the whole entries even though the first entry could have matched already, i.e. it doesn't short-circuit anymore. Moreover for me it isn't as readable as filter.findFirst.orElse... (but that's probably just my opinion)

I probably would then even end up with something as follows:

<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...

so that calls would rather look like:

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(...)

if you want to do this in one pipeline then you could do:

int startInc = 1;

int endEx = 5;

OptionalInt first = 

       IntStream.concat(IntStream.range(startInc, endEx)

                .filter(x -> x == 7), endEx > 1 ? IntStream.of(endEx) : IntStream.empty())

                .findFirst();

but you're probably better off collecting the generated numbers into a list then operate on it as follows:

// first collect the numbers into a list

List<Integer> result = IntStream.rangeClosed(startInc,endEx)

                                   .boxed()

                                   .collect(toList());

    // then operate on it 

int value = result.stream()

                  .filter(x -> x == 7)

                  .findFirst()

                  .orElse(result.get(result.size() - 1)); 

Alternatively, if you want to make the latter return an empty Optional in the case of the source being empty (if that's a possible scenario) instead of an exception then you could do:

List<Integer> result = IntStream.rangeClosed(startInc,endEx)

                                .boxed()

                                .collect(toList());



Optional<Integer> first = 

         Stream.concat(result.stream().filter(x -> x == 7), result.isEmpty() ? 

                Stream.empty() : Stream.of(result.get(result.size() - 1)))

                .findFirst();

I am not sure why you really want to use streams for that, a simple for-loop would be enough:

public static <T> T getFirstMatchingOrLast(List<? extends T> source, Predicate<? super T> predicate){

    // handle empty case

    if(source.isEmpty()){

        return null;

    }

    for(T t : source){

        if(predicate.test(t)){

            return t;

        }

    }

    return source.get(source.size() -1);

} 

Which then can be called like:

Integer match = getFirstMatchingOrLast(ints, i -> i == 7);