Guava Streams.zip() method in Java

This post will discuss how to combine two streams into one in Java using Guava Streams.zip() method.

Sometimes you might want to combine two streams into one stream, such that each element of the resulting stream is a pair of elements from the original streams. In this post, we will show you how to use the zip() method of the Streams class in Guava to create a new stream that combines two streams into one stream by applying a function to each pair of elements. We will also explain why this method is useful, how it works internally, and what are some of the benefits and drawbacks of using it.

1. Overview of `zip()` method

The zip() method of the Streams class returns a new stream that contains the results of applying a function to pairs of elements from two input streams. The Streams.zip() method has the following signature:

1	public static <A extends @Nullable Object,B extends @Nullable Object,R extends @Nullable Object> Stream<R> zip(Stream<A> streamA, Stream<B> streamB, BiFunction<? super A,? super B,R> function)

The method takes three parameters: streamA and streamB are the two input streams that can have any type of elements. function is a function that takes two elements, one from each stream, and returns a new element of any type. The method returns a new stream of the same type as the return type of the function. The new stream has the same size as the smaller of the two input streams. If one of the input streams is longer than the other, its extra elements are ignored.

The function can be any instance of the BiFunction interface, which takes two input objects and returns one output object. For example, the following code zips two streams of names and ages to create a stream of persons.

import com.google.common.collect.Streams;

import java.util.stream.Stream;

class Person {

private String name;

private int age;

public Person(String name, int age) {

this.name = name;

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

@Override

public String toString() {

return "Person{" + "name='" + name + '\'' + ", age=" + age + '}';

}

class Main

{

public static void main(String[] args)

{

// Create two streams of names and ages

Stream<String> names = Stream.of("David", "Mia", "Michael");

Stream<Integer> ages = Stream.of(25, 30, 35);

// Create a stream of persons by zipping the names and ages

Stream<Person> persons = Streams.zip(names, ages, Person::new);

// Print the persons

persons.forEach(System.out::println);

}

Download Code

Output:

Person{name=’David’, age=25}
Person{name=’Mia’, age=30}
Person{name=’Michael’, age=35}

As you can see, the zip() method takes two streams and a BiFunction as arguments, and returns a stream that contains the results of applying the BiFunction to each pair of elements from the input streams.

2. Importance of `zip()` method

The zip() method is useful when you want to combine two streams into one stream by applying a custom function to each pair of elements. For example, you might want to:

Create a stream of objects by combining two streams of attributes, such as names and ages
Create a stream of pairs by combining two streams of values, such as keys and values
Create a stream of operations by combining two streams of operands, such as numbers and operators

All these scenarios can be handled using the zip() method, as it allows you to specify any function that returns a value from two input values. For example, the following code creates a stream of pairs by zipping two streams of keys and values:

import com.google.common.collect.Streams;

import org.javatuples.Pair;

import java.util.stream.Stream;

class Main {

public static void main(String[] args) {

Stream<String> keys = Stream.of("a", "b", "c");

Stream<Integer> values = Stream.of(1, 2, 3);

Stream<Pair<String, Integer>> pairs = Streams.zip(keys, values, Pair::new);

pairs.forEach(System.out::println); // [a, 1], [b, 2], [c, 3]

}

Download Code

The Streams.zip() method can be used for various other purposes, such as:

import com.google.common.collect.Streams;

import java.util.AbstractMap;

import java.util.Map;

import java.util.stream.Collectors;

import java.util.stream.Stream;

class Main {

public static void main(String[] args) {

// Example 1: Concatenating strings from two streams with a separator

Stream<String> streamA = Stream.of("a", "b", "c");

Stream<String> streamB = Stream.of("1", "2", "3");

Stream<String> result = Streams.zip(streamA, streamB, (a, b) -> a + ":" + b);

System.out.println(result.toList()); // [a:1, b:2, c:3]

// Example 2: Computing the dot product of two streams of numbers

Stream<Integer> stream3 = Stream.of(1, 2, 3);

Stream<Integer> stream4 = Stream.of(4, 5, 6);

int dotProduct = Streams.zip(stream3, stream4, (a, b) -> a * b)

.mapToInt(Integer::intValue)

.sum();

System.out.println(dotProduct); // 32 (1*4 + 2*5 + 3*6)

// Example 3: Creating a map from two streams of keys and values

Stream<String> stream5 = Stream.of("avocado", "banana", "carrot");

Stream<Integer> stream6 = Stream.of(10, 20, 30);

Map<String, Integer> map = Streams.zip(stream5, stream6, AbstractMap.SimpleEntry::new)

.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

System.out.println(map); // {banana=20, avocado=10, carrot=30}

}

Download Code

3. Internal working of `zip()` method

You might wonder how the zip() method works internally, and whether it affects the performance or memory usage of your program. The answer is that it depends on the characteristics and order of the input streams.

The zip() method creates an iterator that iterates over both input streams in parallel and applies the function to each pair of elements. The iterator then returns an element for each call to next(), or throws an exception if either input stream runs out of elements. The iterator also implements AutoCloseable, which means that it closes both input streams when it is closed.
The zip() method then creates a spliterator that wraps the iterator and supports sequential or parallel traversal. The spliterator has characteristics such as SIZED, SUBSIZED, ORDERED, NONNULL, and DISTINCT if both input spliterators have them. The spliterator also implements AutoCloseable, which means that it closes the iterator when it is closed.
The zip() method then creates a stream that wraps the spliterator and supports sequential or parallel processing. The stream also implements AutoCloseable, which means that it closes the spliterator when it is closed.

4. Benefits and drawbacks of using the `zip()` method

Using the zip() method of the Streams class in Guava has some benefits and drawbacks that you should be aware of before using it. Here are some of the benefits:

It is easy to use, as you only need to pass two streams and a function as arguments to create a zipped stream.
It is flexible and powerful, as you can use any function that suits your needs, and process the zipped stream in sequential or parallel mode.
It is consistent and thread-safe, as it preserves the characteristics and order of both input streams.

Here are some of the drawbacks of using the zip() method:

It may be confusing or surprising, as it returns a stream that contains the results of applying a function to pairs of elements, not the pairs themselves. This can lead to unexpected or inconsistent results if the function is not well-defined or consistent.
It may be less performant than a direct iteration in some cases, such as when using infinite or unordered streams, or when using a complex or slow function. This is because the zip() method may add some overhead to the iteration, such as creating intermediate objects or synchronizing threads.

5. Conclusion

In this post, we have covered how to use the zip() method of the Streams class in Guava to combine two streams into one stream by applying a function to each pair of elements. We have also explained why this method is useful, how it works internally, and what are some of the benefits and drawbacks of using it.

If you want to learn more about this method, you can check out the Guava documentation and its GitHub repository.

Guava Streams.zip() method in Java

1. Overview of zip() method

2. Importance of zip() method

3. Internal working of zip() method

4. Benefits and drawbacks of using the zip() method

5. Conclusion

Share this:

1. Overview of `zip()` method

2. Importance of `zip()` method

3. Internal working of `zip()` method

4. Benefits and drawbacks of using the `zip()` method