Using Java 8 Supplier in streams to achieve lazy evaluation

Question

I am trying to achieve lazy evaluation using Supplier in a stream like this

public static void main(String[] args) {

        Supplier<List<String>> expensiveListSupplier= getExpensiveList();
        getList().stream()
                .filter(s -> expensiveListSupplier.get().contains(s))
                .forEach(System.out::println);
    }

    private static Supplier<List<String>> getExpensiveList() {
        return () -> Stream
                .of("1", "2", "3")
                .peek(System.out::println)
                .collect(Collectors.toList());
    }

    private static List<String> getList() {
        return Stream.of("2", "3")
                .collect(Collectors.toList());
    }

But this will call getExpensiveList() method for every element in the list. I am trying not to be verbose and don't want to write something like this ie to add not empty checks and stuff.

public static void main(String[] args) {

        Supplier<List<String>> expensiveListSupplier = getExpensiveList();
        List<String> list = getList();
        if (!list.isEmpty()) {
            List<String> expensiveList = expensiveListSupplier.get();
            list.stream()
                    .filter(expensiveList::contains)
                    .forEach(System.out::println);
        }    
    }

    private static Supplier<List<String>> getExpensiveList() {
        return () -> Stream
                .of("1", "2", "3")
                .peek(System.out::println)
                .collect(Collectors.toList());
    }

    private static List<String> getList() {
        return Stream.of("2", "3")
                .collect(Collectors.toList());
    }

what exactly is your question? Can you simplify .. *I am trying not to be verbose and don't want to write something like this ie to add not empty checks and stuff* ? — Naman, Aug 21 '18 at 03:53
Can you just call `Set expensiveStuff = new HashSet<>(getExpensiveList().get());`. Using a set would scale up to any practical size with constant runtime. — Bohemian, Aug 21 '18 at 04:25
A small note: supplier instance after it's been used, prevents it from being garbage collected and for parallel execution of streams, you can check this link https://www.logicbig.com/tutorials/core-java-tutorial/java-util-stream/lazy-evaluation.html As @Hoopje pointed better to go with your verbose code. — Prakhar Nigam, Aug 21 '18 at 06:15
What’s the point of using a `Supplier` here? You need to get the list for the first element already, so the laziness is tiny, compared to the complication of your code. — Holger, Aug 21 '18 at 07:13

score 3 · Answer 1 · answered Aug 21 '18 at 07:22

3

You second variant can be simplified to

List<String> list = getList();
if(!list.isEmpty()) {
    list.stream()
        .filter(getExpensiveList().get()::contains)
        .forEach(System.out::println);
}

It makes the use of a Supplier pointless, as even the call to getExpensiveList() will be done only when the list is non-empty. But on the other hand, that’s the maximum laziness you can get anyway, i.e. not to request the expensive list when the other list is empty. In either case, the expensive list will be requested for the first element already when the list is not empty.

If the expensive list can become large, you should use

List<String> list = getList();
if(!list.isEmpty()) {
    list.stream()
        .filter(new HashSet<>(getExpensiveList().get())::contains)
        .forEach(System.out::println);
}

instead, to avoid repeated linear searches. Or redesign getExpensiveList() to return a Set in the first place.

answered Aug 21 '18 at 07:22

Holger

285,553
42
434
765

The reason of adding the second code snippet was to explain my question(first snippet) and not for improvements in it. I think your answers does not add value to my intended question. Thanks anyway for answering. – Amardeep Aug 21 '18 at 09:27
Doesn't this make a call to `getExpensiveList().get()` for every element of the stream? – fps Aug 21 '18 at 15:02
1

@Amardeep I decided to provide an improved variant of your second code snippet, because it *looks* more complicated in your question while actually being simpler than your first variant. As already explained in my answer, your first variant does not provide any actual benefit, i.e. regarding the desired laziness. So there’s a variant which is simpler but still without any drawbacks compared to the others. If that’s not an answer, you are perhaps asking the wrong question. – Holger Aug 21 '18 at 15:05
1

@FedericoPeraltaSchaffner no, a method reference of the `expression::name` form will evaluate the expression once and capture the result. See also [What is the equivalent lambda expression for System.out::println](https://stackoverflow.com/a/28025717/2711488)… – Holger Aug 21 '18 at 15:06
@FedericoPeraltaSchaffner Yes it will as I have pointed out in my question as well. And in top of it all this was the reason for putting up this question. – Amardeep Aug 22 '18 at 00:23
@Amardeep no, it will not. That’s a fundamental difference between a method reference of the `getExpensiveList().get())::contains` form and a lambda expression like `s -> expensiveListSupplier.get().contains(s)`. – Holger Aug 22 '18 at 06:08
Is the condition `!list.isEmpty()` needed? – Thiyagu Sep 26 '18 at 12:55
@user7 not for the stream, but to avoid the invocation of `getExpensiveList()` and `getExpensiveList().get()`. A method reference of the form `expression::name`, like `getExpensiveList().get()::contains`, will evaluate `expression` immediately and capture the result, so it’s not executed for every stream element, but only once. But it also implies that it will be evaluated exactly once here, even when the list is empty—unless we wrap the entire statement with `if(!list.isEmpty())`. Of course, if the expression is cheap, like with `System.out::println`, we don’t need to care. – Holger Sep 26 '18 at 13:10
Got it. Thanks for the explanation :) – Thiyagu Sep 26 '18 at 13:31

score 2 · Answer 2 · answered Aug 21 '18 at 05:34

I don't think this is possible using only standard Java classes. But you could write your own lazy evaluator and use that, for example (untested):

public class LazyValue<T> implements Supplier<T> {
    private T value;
    private final Supplier<T> initializer;
    public LazyValue(Supplier<T> initializer) {
        this.initializer = initializer;
    } 
    public T get() {
        if (value == null) {
            value = initializer.get();
        }
        return value;
    }
}

There are other possibilities as well, see for example this question.

But beware! If you add lazy evaluation, you have a mutable data structure, so if you use it in a multithreaded environment (or a parallel stream), add synchronization.

But, I would use your verbose version. It's immediately clear what it does, and it is only four lines longer. (In real code I expect that those four lines are irrelevant.)

I thought so!!. Just wanted to check if someone has figured out a solution which is concise and functional. — Amardeep, Aug 21 '18 at 07:09

Using Java 8 Supplier in streams to achieve lazy evaluation

2 Answers2