Generating lazy streams from fixed expressions in Java: Supplier-based practice

This article details how to create a lazy-evaluated stream from a set of fixed expressions in Java using the `Supplier` interface and the `Stream.of()` method. By encapsulating each expression as a `Supplier` instance and constructing a `Stream `, we are able to effectively delay the execution of expressions until a terminal operation in the stream pipeline is triggered, enabling performance optimization and resource management.

In Java 8 and above, the Stream API provides powerful and flexible tools for data processing. However, when we need to create a stream from a series of fixed expressions, the common Stream.of(expression1(), expression2(), ...) method will immediately execute these expressions and use their results as elements of the stream. For expressions that are computationally expensive or resource-intensive, this behavior of immediate evaluation can result in unnecessary performance overhead or wasted resources. In order to achieve lazy evaluation, that is, to only execute expressions when needed, we can cleverly combine the Supplier interface.

Core concepts: Supplier and lazy evaluation

java.util.function.Supplier is a functional interface that does not accept any parameters but returns a result of type T. Its core method is T get(). The power of Supplier is that it encapsulates a "future" calculation, and the actual calculation will only occur when the get() method is called. This is the key to implementing lazy evaluation.

Build a lazy stream: Stream

To generate a lazy stream from a fixed number of expressions, we don't put the results of the expressions directly into the stream, but instead put Supplier instances that encapsulate those expressions into the stream. The Stream.of() method can accept any type of object as its element, so it can accept Supplier instances.

Suppose we have three expressions expression1(), expression2() and expression3(), all of which return objects of type MyClass. We can build a Stream> like this:

 import java.util.function.Supplier;
import java.util.stream.Stream;

public class LazyStreamExample {

    // Assume MyClass and its expression static class MyClass {
        private String id;
        public MyClass(String id) {
            this.id = id;
            System.out.println("MyClass " id " created."); // Simulate time-consuming operations}
        public String getId() {
            return id;
        }
    }

    // Simulate time-consuming expression private static MyClass expression1() {
        return new MyClass("One");
    }

    private static MyClass expression2() {
        return new MyClass("Two");
    }

    private static MyClass expression3() {
        return new MyClass("Three");
    }

    public static void main(String[] args) {
        System.out.println("--- Start building lazy stream---");
        Stream<supplier>&gt; lazyStream = Stream.of(
            () -&gt; expression1(),
            () -&gt; expression2(),
            () -&gt; expression3()
        );
        System.out.println("--- Lazy stream construction is completed, expression has not been executed yet---");

        // At this time, the console will not output information such as "MyClass One created."
        // Because methods such as expression1() have not been called yet.
    }
}</supplier>

In the above code, when Stream.of() is called, it only creates three Supplier objects and uses them as elements of the stream. The expression1(), expression2(), and expression3() methods themselves are not executed, so their internal time-consuming operations (such as the constructor of MyClass) are not triggered.

Delayed evaluation and processing

Once we have a Stream>, we can trigger the get() methods of these Suppliers on demand in subsequent operations of the stream pipeline, thereby achieving delayed evaluation of expressions. This is usually done via map operations:

 import java.util.function.Supplier;
import java.util.stream.Stream;

public class LazyStreamExample {

    // ... (MyClass and expression1/2/3 methods are the same as above) ...

    public static void main(String[] args) {
        System.out.println("--- Start building lazy stream---");
        Stream<supplier>&gt; lazyStream = Stream.of(
            () -&gt; expression1(),
            () -&gt; expression2(),
            () -&gt; expression3()
        );
        System.out.println("--- Lazy stream construction is completed, expression has not been executed yet---");

        // Example: Find the first MyClass object that meets the condition System.out.println("\n--- Start processing lazy stream---");
        MyClass result = lazyStream.map(Supplier::get) // Call Supplier::get here to trigger expression execution.filter(myObj -&gt; {
                                       System.out.println("Filter object: " myObj.getId());
                                       return myObj.getId().equals("Two"); // Assumptions})
                                   .findFirst()
                                   .orElse(null); // or orElseThrow()

        if (result != null) {
            System.out.println("\n--- Found the result: " result.getId() " ---");
        } else {
            System.out.println("\n--- No results satisfying the conditions were found---");
        }

        System.out.println("\n--- Process the lazy stream again and verify the lazy properties---");
        // Note: Stream is consumed in a single time. This is only for demonstration. In actual applications, the stream needs to be rebuilt // Suppose we rebuild a stream for demonstration Stream<supplier>&gt; anotherLazyStream = Stream.of(
            () -&gt; expression1(),
            () -&gt; expression2(),
            () -&gt; expression3()
        );
        anotherLazyStream.map(Supplier::get)
                         .filter(myObj -&gt; {
                             System.out.println("Filter objects again: " myObj.getId());
                             return myObj.getId().equals("Three");
                         })
                         .findFirst();
        System.out.println("--- Processing completed again---");
    }
}</supplier></supplier>

Running the above code, you will observe the following behavior:

1. When lazyStream is built, there will not be any output of MyClass created.
2. When lazyStream.map(Supplier::get) is called, the Supplier::get method will be called, thus triggering the execution of expression1(), expression2() and other methods.
3. Due to the short-circuit characteristics of filter and findFirst, once an object that meets the condition (such as "Two") is found, the subsequent Supplier (such as expression3()) will not be called, and its corresponding MyClass will not be created. This fully demonstrates the advantages of lazy evaluation.

Advantages and Considerations

Advantages:

• Performance optimization: unnecessary calculations are avoided. Expressions that are expensive to compute can significantly improve application performance by executing them only when their results are actually needed.
• Resource saving: If the expression involves resource-intensive operations such as file I/O, network requests, or database queries, lazy evaluation can ensure that these resources are occupied and released only when necessary.
• Handling potential errors: If an expression might throw an exception, lazy evaluation can delay the occurrence of the exception until an actual attempt is made to obtain its result.

Things to note:

• Works with a fixed number of expressions: This method works best with a fixed set of expressions that are known in advance.
• Differences from Stream.generate(): For scenarios where you need to generate an infinite stream or dynamically generate elements based on some logic, Stream.generate(Supplier s) is a more appropriate choice. It calls the Supplier's get() method every time it requests an element. And Stream> is a stream for a fixed number of "future values".
• Single-time consumption characteristics of streams: Java's Stream is single-time consumption. Once a stream's terminal operation is performed, the stream can no longer be used. If you need to process the same set of lazy expressions multiple times, you need to rebuild the Stream.

Summarize

By encapsulating the expression in a Supplier and constructing a Stream, we can generate a lazy stream from a fixed expression in Java. This pattern effectively separates the definition of an expression from its actual execution, resulting in significant performance and resource management benefits. Understanding and properly using the combination of Supplier and Stream API is one of the key skills for writing efficient and robust Java applications.

The above is the detailed content of Generating lazy streams from fixed expressions in Java: Supplier-based practice. For more information, please follow other related articles on the PHP Chinese website!