The Java Spliterator, introduced in Java 8, powers the Stream API by providing sophisticated traversal and partitioning capabilities. This enables both sequential and parallel stream processing with optimal performance across diverse data sources.

What Is a Spliterator?

A Spliterator (split + iterator) traverses elements while supporting data partitioning for concurrent processing. Unlike traditional Iterator, its trySplit() method divides data sources into multiple Spliterators, making it perfect for parallel streams.

Spliterator's Role in Stream API

Stream API methods like collection.stream() and collection.parallelStream() internally call the collection's spliterator() method. The StreamSupport.stream(spliterator, parallel) factory creates the stream pipeline.

Enabling Parallel Processing

The Fork/Join framework uses trySplit() to recursively partition data across threads. Each split creates smaller Spliterators processed independently, then results merge efficiently.

Core Spliterator Methods

Spliterator Characteristics

Characteristics describe data source properties, optimizing stream execution:

These flags enable Stream API optimizations like skipping redundant operations based on source properties.

Custom Spliterator Example: Square Generator

Here's a production-ready custom Spliterator that generates squares of numbers in a range, with full parallel execution support:

import java.util.Spliterator;
import java.util.function.Consumer;
import java.util.stream.StreamSupport;

/**
 * A Spliterator that generates squares of numbers in a range.
 * This implementation properly supports parallel execution because
 * each element can be computed independently without shared mutable state.
 */
public class SquareSpliterator implements Spliterator<Integer> {
    private int start;
    private final int end;

    public SquareSpliterator(int start, int end) {
        this.start = start;
        this.end = end;
    }

    @Override
    public boolean tryAdvance(Consumer<? super Integer> action) {
        if (start >= end) {
            return false;
        }
        int value = start * start;
        action.accept(value);
        start++;
        return true;
    }

    @Override
    public Spliterator<Integer> trySplit() {
        int remaining = end - start;

        // Only split if we have at least 2 elements
        if (remaining < 2) {
            return null;
        }

        // Split the range in half
        int mid = start + remaining / 2;
        int oldStart = start;
        start = mid;

        // Return a new spliterator for the first half
        return new SquareSpliterator(oldStart, mid);
    }

    @Override
    public long estimateSize() {
        return end - start;
    }

    @Override
    public int characteristics() {
        return IMMUTABLE | SIZED | SUBSIZED | NONNULL | ORDERED;
    }

    public static void main(String[] args) {
        System.out.println("=== Sequential Execution ===");
        var sequentialStream = StreamSupport.stream(new SquareSpliterator(1, 11), false);
        sequentialStream.forEach(n -> System.out.println(
            Thread.currentThread().getName() + ": " + n
        ));

        System.out.println("\n=== Parallel Execution ===");
        var parallelStream = StreamSupport.stream(new SquareSpliterator(1, 11), true);
        parallelStream.forEach(n -> System.out.println(
            Thread.currentThread().getName() + ": " + n
        ));

        System.out.println("\n=== Computing Sum in Parallel ===");
        long sum = StreamSupport.stream(new SquareSpliterator(1, 101), true)
                .mapToLong(Integer::longValue)
                .sum();
        System.out.println("Sum of squares from 1² to 100²: " + sum);

        System.out.println("\n=== Finding Max in Parallel ===");
        int max = StreamSupport.stream(new SquareSpliterator(1, 51), true)
                .max(Integer::compareTo)
                .orElse(0);
        System.out.println("Max square (1-50): " + max);

        System.out.println("\n=== Filtering Even Squares in Parallel ===");
        long countEvenSquares = StreamSupport.stream(new SquareSpliterator(1, 21), true)
                .filter(n -> n % 2 == 0)
                .count();
        System.out.println("Count of even squares (1-20): " + countEvenSquares);
    }
}

Key Features Demonstrated:

• Perfect parallel splitting via balanced trySplit()
• Thread-independent computation (no shared mutable state)
• Rich characteristics enabling Stream API optimizations
• Real-world stream operations: sum, max, filter, count

Sample Output shows different threads processing different ranges, proving effective parallelization.

Why Spliterators Matter

Spliterators provide complete control over stream data sources. They enable:

• Custom data generation (ranges, algorithms, files, networks)
• Optimal parallel processing with balanced workload distribution
• Metadata-driven performance tuning through characteristics

This architecture makes Java Stream API uniquely scalable, from simple collections to complex distributed data processing pipelines.

Java Streams offer powerful ways to transform data, especially for one-to-many mappings. mapMulti, introduced in Java 16, provides an imperative alternative to the classic flatMap, optimizing performance by skipping intermediate Stream creation.

Core Distinctions

mapMulti uses a BiConsumer that receives the input element and a downstream Consumer, enabling direct emission of multiple (or zero) values without generating Streams per element. This reduces overhead, making it ideal for conditional expansions or small output sets. flatMap, in contrast, applies a Function returning a Stream for each input, then flattens them; it's elegant for functional styles but creates unnecessary Streams, even empties during filtering.

The imperative nature of mapMulti allows seamless integration of filtering and mapping logic in one step, streamlining pipelines.​

Practical Examples

Consider processing languages, expanding those containing 'o' to both original and uppercase forms.

With mapMulti (efficient, direct emission):

List<String> result = Stream.of("Java", "Groovy", "Clojure")
        .<String>mapMulti((lang, downstream) -> {
            if (lang.contains("o")) {
                downstream.accept(lang);
                downstream.accept(lang.toUpperCase());
            }
        })
        .toList();
IO.println(result);

With flatMap (functional, but with Stream overhead):

List<String> result = Stream.of("Java", "Groovy", "Clojure")
        .filter(lang -> lang.contains("o"))
        .flatMap(lang -> Stream.of(lang, lang.toUpperCase()))
        .toList();
IO.println(result);
// Output: ["Groovy", "GROOVY", "Clojure", "CLOJURE"]

Choosing the Right Tool

Select mapMulti for high-performance scenarios like microservices processing, where avoiding Stream instantiation boosts throughput, or for complex imperative conditions. Stick with flatMap for declarative codebases or transformations naturally producing Streams, such as string splitting.

Java method references, introduced in Java 8, offer a succinct and expressive way to refer to existing methods or constructors using the :: operator. They serve as a powerful alternative to verbose lambda expressions, helping developers write clearer and more maintainable code in functional programming contexts. This article covers the four types of method references.

Types of Java Method References

Java supports four main types of method references, grouped by the kind of method they refer to:

1. Reference to a Constructor
   References a constructor to create new objects or arrays.
   Syntax: ClassName::new
   Examples:

   List people = names.stream().map(Person::new).toList();

   Create new instances with constructor reference for each element in the stream.

   Additionally, constructor references can be used for arrays:

   import java.util.function.IntFunction;
   
   IntFunction arrayCreator = String[]::new;
   String[] myArray = arrayCreator.apply(5);
   System.out.println("Array length: " + myArray.length);  // Prints 5

   This is especially useful in streams to collect into arrays:

   String[] namesArray = names.stream().toArray(String[]::new);

2. Reference to a Static Method
   This refers to a static method in a class.
   Syntax: ClassName::staticMethodName
   Example:

   Arrays.sort(array, Integer::compare);

3. Reference to an Instance Method of a Particular Object (Bound Method Reference)
   This is a bound method reference, tied to a specific, existing object instance. The instance is fixed when the reference is created.
   Syntax: instance::instanceMethodName
   Example:

   List names = List.of("Alice", "Bob");
   names.forEach(System.out::println);  // System.out is a fixed object

   Here, System.out::println is bound to the particular System.out object.

4. Reference to an Instance Method of an Arbitrary Object of a Particular Type (Unbound Method Reference)
   This is an unbound method reference where the instance is supplied dynamically when the method is called.
   Syntax: ClassName::instanceMethodName
   Important Rule:
   The first parameter of the functional interface method corresponds to the instance on which the referenced instance method will be invoked. That is, the instance to call the method on is passed as the first argument, and any remaining parameters map directly to the method parameters.
   Example:

   List team = Arrays.asList("Dan", "Josh", "Cora");
   team.sort(String::compareToIgnoreCase);

   In this example, when the comparator functional interface’s compare method is called with two arguments (a, b), it is equivalent to calling a.compareToIgnoreCase(b) on the first parameter instance.

Summary

• Java method references simplify code by allowing concise references to methods and constructors.
• The first type—constructor references—express object and array instantiation clearly.
• The second type is referencing static methods.
• The third type—instance method reference of a particular object—is a bound method reference, fixed on a single object instance.
• The fourth type—instance method reference of an arbitrary object of a particular type—is an unbound method reference, where the instance is provided at call time.
• Constructor references are especially handy for arrays like String[].
• System.out::println is a classic example of a bound method reference.

Java continues evolving to meet the needs of developers—from beginners learning the language to pros writing quick scripts. Java 25 introduces Compact Source Files, a feature that lets you write Java programs without explicit class declarations, coupled with Instance Main Methods which allow entry points that are instance-based rather than static. This combination significantly reduces boilerplate, simplifies small programs, and makes Java more approachable while preserving its power and safety.

What Are Compact Source Files?

Traditionally, a Java program requires a class and a public static void main(String[] args) method. However, this requirement adds ceremony that can be cumbersome for tiny programs or for learners.

Compact source files lift this restriction by implicitly defining a final top-level class behind the scenes to hold fields and methods declared outside any class. This class:

• Is unnamed and exists in the unnamed package.
• Has a default constructor.
• Extends java.lang.Object and implements no interfaces.
• Must contain a launchable main method, which can be an instance method (not necessarily static).
• Cannot be referenced by name in the source.

This means a full Java program can be as simple as:

void main() {
    IO.println("Hello, World!");
}

The new java.lang.IO class introduced in Java 25 provides simple convenient methods for console output like IO.println().

Implicit Imports for Compact Source Files

To keep programs concise, compact source files automatically import all public top-level classes and interfaces exported by the java.base module. This includes key packages such as java.util, java.io, java.math, and java.lang. So classes like List or BigDecimal are immediately available without import declarations.

Modules outside java.base require explicit import declarations.

Limitations and Constraints

Compact source files have some structural constraints:

• The implicit class cannot be named or explicitly instantiated.
• No package declarations are allowed; the class is always in the unnamed package.
• Static members cannot be referenced via method references.
• The IO class’s static methods require qualification.
• Complex multi-class or modular programs should evolve into regular class-based files with explicit imports and package declarations.

This feature targets small programs, scripts, and educational use while preserving Java’s rigorous type safety and tooling compatibility.

Using Command-Line Arguments in a Compact Source File

Compact source files support standard command-line arguments passed to the main method as a String[] parameter, just like traditional Java programs.

Here is an example that prints provided command-line arguments:

void main(String[] args) {
    if (args.length == 0) {
        IO.println("No arguments provided.");
        return;
    }
    IO.println("Arguments:");
    for (var arg : args) {
        IO.println(" - " + arg);
    }
}

Save this as PrintArgs.java, then run it with:

java PrintArgs.java apple banana cherry

Output:

textArguments:
 - apple
 - banana
 - cherry

This shows how you can easily handle inputs in a script-like manner without boilerplate class syntax.

Growing Your Program

If your program outgrows simplicity, converting from a compact source file to a named class is straightforward. Wrap methods and fields in a class declaration and add imports explicitly. For instance:

import module java.base;

class PrintArgs {
    void main(String[] args) {
        if (args.length == 0) {
            IO.println("No arguments provided.");
            return;
        }
        IO.println("Arguments:");
        for (var arg : args) {
            IO.println(" - " + arg);
        }
    }
}

The logic inside main remains unchanged, enabling an easy migration path.

Conclusion

Java 25’s compact source files paired with instance main methods introduce a fresh, lightweight way to write Java programs. By reducing ceremony and automatically importing core APIs, they enable rapid scripting, teaching, and prototyping, while maintaining seamless interoperability with the full Java platform. Handling command-line arguments naturally fits into this new model, encouraging exploration and productivity in a familiar yet simplified environment.

This innovation invites developers to write less, do more, and enjoy Java’s expressive power with less friction.

With the release of Java 25, scoped values come out of preview and enter the mainstream as one of the most impactful improvements for concurrency and context propagation in Java’s recent history. Designed to address the perennial issue of safely sharing context across method chains and threads, scoped values deliver a clean, immutable, and automatically bounded solution that dethrones the error-prone ThreadLocal for most scenarios.

Rethinking Context: Why Scoped Values?

For years, Java developers have used ThreadLocal to pass data down a call stack—such as security credentials, logging metadata, or request-specific state. While functional, ThreadLocal suffers from lifecycle ambiguity, memory leaks, and incompatibility with lightweight virtual threads. Scoped values solve these problems by making context propagation explicit in syntax, immutable in nature, and automatic in cleanup.

The Mental Model

Imagine code execution as moving through a series of rooms, each with its unique lighting. A scoped value is like setting the lighting for a room—within its boundaries, everyone sees the same illumination (data value), but outside those walls, the setting is gone. Each scope block clearly defines where the data is available and safe to access.

How Scoped Values Work

Scoped values require two ingredients:

• Declaration: Define a ScopedValue as a static final field, usually parameterized by the intended type.
• Binding: Use ScopedValue.where() to create an execution scope where the value is accessible.

Inside any method called within the binding scope—even dozens of frames deep—the value can be retrieved by .get(), without explicit parameter passing.

Example: Propagating User Context Across Methods

// Declare the scoped value
private static final ScopedValue<String> USERNAME = ScopedValue.newInstance();

public static void main(String[] args) {
    ScopedValue.where(USERNAME, "alice").run(() -> entryPoint());
}

static void entryPoint() {
    printCurrentUser();
}

static void printCurrentUser() {
    System.out.println("Current user: " + USERNAME.get()); // Outputs "alice"
}

In this sample, USERNAME is accessible in any method within the binding scope, regardless of how far it’s called from the entry point.

Nested Binding and Rebinding

Scoped values provide nested rebinding: within a scope, a method can establish a new nested binding for the same value, which is then available only to its callees. This ensures truly bounded context lifetimes and avoids unintended leakage or overwrites.

// Declare the scoped value
private static final ScopedValue<String> MESSAGE = ScopedValue.newInstance();

void foo() {
    ScopedValue.where(MESSAGE, "hello").run(() -> bar());
}

void bar() {
    System.out.println(MESSAGE.get()); // prints "hello"
    ScopedValue.where(MESSAGE, "goodbye").run(() -> baz());
    System.out.println(MESSAGE.get()); // prints "hello"
}

void baz() {
    System.out.println(MESSAGE.get()); // prints "goodbye"
}

Here, the value "goodbye" is only visible within the nested scope inside baz, while "hello" remains for bar outside that sub-scope.openjdk

Thread Safety and Structured Concurrency

Perhaps the biggest leap: scoped values are designed for modern concurrency, including Project Loom’s virtual threads and Java's structured concurrency. Scoped values are automatically inherited by child threads launched within the scope, eliminating complex thread plumbing and ensuring correct context propagation.

// Declare the scoped value
private static final ScopedValue<String> REQUEST_ID = ScopedValue.newInstance();

public static void main(String[] args) throws InterruptedException {
    String requestId = "req-789";
    usingVirtualThreads(requestId);
    usingStructuredConcurrency(requestId);
}

private static void usingVirtualThreads(String requestId) {
    try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
        // Launch multiple concurrent virtual threads, each with its own scoped value binding
        Future<?> taskA = executor.submit(() ->
                ScopedValue.where(REQUEST_ID, requestId).run(() -> processTask("Task VT A"))
        );
        Future<?> taskB = executor.submit(() ->
                ScopedValue.where(REQUEST_ID, requestId).run(() -> processTask("Task VT B"))
        );
        Future<?> taskC = executor.submit(() ->
                ScopedValue.where(REQUEST_ID, requestId).run(() -> processTask("Task VT C"))
        );

        // Wait for all tasks to complete
        try {
            taskA.get();
            taskB.get();
            taskC.get();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

private static void usingStructuredConcurrency(String requestId) {
    ScopedValue.where(REQUEST_ID, requestId).run(() -> {
        try (var scope = StructuredTaskScope.open()) {
            // Launch multiple concurrent virtual threads
            scope.fork(() -> {
                processTask("Task SC A");
            });
            scope.fork(() -> {
                processTask("Task SC B");
            });
            scope.fork(() -> {
                processTask("Task SC C");
            });

            scope.join();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException(e);
        }
    });
}

private static void processTask(String taskName) {
    // Scoped value REQUEST_ID is automatically visible here
    System.out.println(taskName + " processing request: " + REQUEST_ID.get());
}

No need for explicit context passing—child threads see the intended value automatically.

Key Features and Advantages

• Immutability: Values cannot be mutated within scope, preventing accidental overwrite and race conditions.
• Automatic Cleanup: Context disappears at the end of the scope, eliminating leaks.
• No Boilerplate: No more manual parameter threading across dozens of method signatures.
• Designed for Virtual Threads: Plays perfectly with Java’s latest concurrency primitives.baeldung+2

Use Cases

• Securely propagate authenticated user or tracing info in web servers.
• Pass tenant, locale, metrics, or logger context across libraries.
• Enable robust structured concurrency with context auto-inheritance.

Java's CompletableFuture provides a powerful and flexible framework for asynchronous programming. Introduced in Java 8, it allows writing non-blocking, event-driven applications with simple and readable code. With Java 21 and Project Loom, virtual threads can be combined with CompletableFutures to achieve highly scalable concurrency with minimal overhead. This article explores the core usage patterns of CompletableFuture and how to leverage virtual threads effectively.

Basics of CompletableFuture Usage

At its simplest, a CompletableFuture represents a future result of an asynchronous computation. You can create one that runs asynchronously using the supplyAsync() or runAsync() methods.

• supplyAsync() runs a background task that returns a result.
• runAsync() runs a background task with no returned result.

Example:

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello World");
System.out.println(future.get());  // Blocks until the result is ready

In this example, the supplier runs asynchronously, and the main thread waits for its result using get(). The computation executes in the common ForkJoinPool by default.

Chaining and Composing Tasks

CompletableFuture excels at composing asynchronous tasks without nested callbacks:

• thenApply() transforms the result of a completed future.
• thenAccept() consumes the result without returning anything.
• thenRun() runs a task once the future is complete.
• thenCombine() combines results of two independent futures.
• thenCompose() chains dependent futures for sequential asynchronous steps.

Example of chaining:

CompletableFuture.supplyAsync(() -> 10)
    .thenApply(result -> result + 20)
    .thenAccept(result -> System.out.println("Result: " + result));

Example of combining:

CompletableFuture<Integer> f1 = CompletableFuture.supplyAsync(() -> 10);
CompletableFuture<Integer> f2 = CompletableFuture.supplyAsync(() -> 20);
CompletableFuture<Integer> combined = f1.thenCombine(f2, Integer::sum);
System.out.println(combined.get());  // 30

These patterns allow building complex, non-blocking workflows with clean and expressive code.

Exception Handling

CompletableFuture allows robust error handling without complicating the flow:

• Use exceptionally() to recover with a default value on error.
• Use handle() to process outcome result or exception.
• Use whenComplete() to perform an action regardless of success or failure.

Example:

CompletableFuture.supplyAsync(() -> {
    if (true) throw new RuntimeException("Failure");
    return "Success";
}).exceptionally(ex -> "Recovered from " + ex.getMessage())
  .thenAccept(System.out::println);  // Outputs: Recovered from java.lang.RuntimeException: Failure

Waiting for Multiple Futures

The allOf() method is used to wait for multiple CompletableFutures to finish:

List<CompletableFuture<String>> futures = List.of(
    CompletableFuture.completedFuture("A"),
    CompletableFuture.completedFuture("B"),
    CompletableFuture.completedFuture("C"));

CompletableFuture<Void> allDone = CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]));
allDone.join();  // Wait until all futures complete

This enables executing parallel asynchronous operations efficiently.

Using CompletableFuture with Virtual Threads

Java 21 introduces virtual threads, lightweight threads that allow massive concurrency with minimal resource consumption. To use CompletableFutures on virtual threads, create an executor backed by virtual threads and pass it to async methods.

Example:

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
        System.out.println("Running in virtual thread: " + Thread.currentThread());
        try { Thread.sleep(1000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
        System.out.println("Task completed");
    }, executor);

    future.join();
}

• The executor is created with Executors.newVirtualThreadPerTaskExecutor().
• Async tasks run on virtual threads, offering high scalability.
• The executor must be closed to release resources and stop accepting tasks; using try-with-resources is recommended.

All operations such as thenApplyAsync() or thenCombineAsync() can similarly take the virtual thread executor to keep subsequent stages on virtual threads.

Summary

• CompletableFuture allows flexible, readable asynchronous programming.
• Tasks can be created, chained, combined, and composed easily.
• Robust exception handling is built-in.
• allOf() allows waiting on multiple futures.
• With virtual threads, CompletableFuture scales brilliantly by offloading async tasks to lightweight threads.
• Always close virtual thread executors to properly release resources.

Using CompletableFuture with virtual threads simplifies asynchronous programming and enables writing performant scalable Java applications with clean and maintainable code.