收集列表，然后将其传递给lambda或Consumer Java 8

Question

Is it possible to collect to list using .collect(Collectors.toList()) and then pass this whole list (not like .forEach stuff) forward to some consumer or function if the list is not empty? I don't want to declare a list variable to pass it to my next method and use if braces for this.

Answer 1

It seems that you're thinking of doing something along the lines of this:

someMethod(...collect(Collectors.toList()));

But only invoke the someMethod if the passed in list is not empty while avoiding if statements and temporary variables.

Matter of fact is It's not possible to prevent the method invocation at the point of passing data in.

Your options are limited and they're as follows:

1. Store the list into a temporary variable before the call to someMethod , check if !tempList.isEmpty() and if that's true then invoke the method with the list else do nothing.
2. Do the handling as the first thing in the someMethod and exit the method immediately if the list is empty using return; if it's a void returning method else throw an exception or return some value to indicate the list cannot be processed.

Answer 2

Assuming you've got the following two methods:

private boolean canConsumeList(List<?> list) {
    return !list.isEmpty();
}

private <T> void consumeNonEmptyList(List<T> nonEmptyList) {
    // logic here
}

you could "hack" the Collector API like this:

public final class ExtraCollectors {

    public static <T, R> Collector<T, ?, ?> collectingAndConsuming(Collector<T, ?, R> downstream, Predicate<R> resultFilter, Consumer<R> resultConsumer) {
        return Collectors.collectingAndThen(downstream, result -> {
            if (resultFilter.test(result)) {
                resultConsumer.accept(result);
            }
            return null;
        });
    }
}

and then use it as follows:

Stream.of("a", "b").collect(ExtraCollectors.collectingAndConsuming(
        Collectors.toList(), this::canConsumeList, this::consumeNonEmptyList
));

Note, however, that such a solution isn't something I'd consider "clean code" (that's why I called it a "hack"). It may be unintuitive for other developers because collect collocates with obtaining some result (or, in other words, "collecting" the elements of the Stream into a single result). And here, there's no result (even my IDE complains that the "result of Stream.collect() is ignored").