Adding two Java 8 streams, or an extra element to a stream

java

stream-engineering

java-8

best-practices

byAnton Shumikhin·Oct 5, 2024

Stream<T> combinedStream = Stream.concat(stream1, stream2); //How many streams could a Stream.concat concat if a Stream.concat could concat streams?
Stream<T> extendedStream = Stream.concat(stream1, Stream.of(newElement)); //Oh look, found a lone element. Let's invite it to the Stream party!

Priority goes to Stream.concat for smoothly merging streams, or adding an individual element. Just gift-wrap your single element into the stream using Stream.of. These code snippets might be small, but they're quite the heavy-duty workers for stream operations, with eliteness in ashiness and unrivaled in execution speed.

Unraveling `Stream.concat` and its Alternatives

The `Stream.concat` Breakdown

Using Stream.concat is often the best practice for combining just two streams because of its magical *efficiency and lazy execution traits (perfect for slow-cooking). It's an interesting guy, used to be an instance method but grew up into the mature static method it is now, thanks to null argument shenanigans raised by its early users.

Fine-tuned Performance with Alternatives

If dealing with a gang of streams, twist the plot with Stream.of(streams).flatMap(x -> x). It's a powerhouse combination that's got the right balance of mojo and precision:

Stream<T> combinedStreams = Stream.of(stream1, stream2, stream3).flatMap(Function.identity()); //Gotta catch 'em all, Pomemon!

Find peace in the chaos by using static imports, and custom static methods. Takeaways to remember:

Stream.concat to the rescue when combining exactly two streams.
Flex your coding muscles with static imports for readability, when you've got a Stream.concat and Stream.of marathon.
Building your own custom static methods is your secret weapon, if you're constantly manipulating streams.

3rd Party Stream-enhancers

For a little extra pizzazz or a splash of functionality, don't shy away from StreamEx library and Guava's Streams.concat. They're excellent wingmen while you go about your Java 8 Streaming adventures, bringing to the table methods like append and prepend.

Stream<T> combinedStream = StreamEx.of(stream1).append(stream2); //"append" sure sounds friendlier than "concat", doesn't it?

If you're into Guava, Streams.concat can give your code a scrumptious twist:

Stream<T> combinedStream = Streams.concat(stream1, stream2);  //Guava is love, Guava is life

For elegant and crisp stream flattening, import Function.identity() statically and show off your skills with a nifty flatMap operation.

The Art of `Stream.of` and `.flatMap(identity())`

There are times when Stream.of with .flatMap(identity()) could get you out of a jam, especially when juggling more than two streams or showing off a clean and modern code style. Consider leading your army of streams into a single stream:

List<Stream<T>> listOfStreams = Arrays.asList(stream1, stream2, stream3);
Stream<T> combinedStream = listOfStreams.stream().flatMap(Function.identity()); //Unleash the full force of the stream!

It makes your code stand tall and confident while being easy to maintain. Plus, believe me when I say, static importing the identity() can give your flatMap usage a badass twist.

Homemade Stream Operation Methods

Consistent stream operators, lend me your ears! If you're tired of writing similar code snippets every now and then, craft your custom static methods for all your stream operations:

public class StreamUtils {

    @SafeVarargs
    public static <T> Stream<T> concat(Stream<T>... streams) {
        return Arrays.stream(streams).flatMap(Function.identity()); //BOOM! Welcome to my home-made Stream.concat!
    }

    public static <T> Stream<T> append(Stream<T> stream, T element) {
        return Stream.concat(stream, Stream.of(element)); //Together forever! Well, at least until the garbage collector turns up...
    }
    
    // Additional utility methods...
}