Guava Streams.mapWithIndex() method in Java

In this post, we will explain what the Guava Streams.mapWithIndex() method does, how to use it, and what benefits it offers over other solutions. We will also provide some examples and code snippets to demonstrate its usage in different scenarios.

The standard Java Stream API does not provide a built-in way to access the index of each element in a stream. You might have tried using a for loop, an AtomicInteger, or a custom collector, but none of these solutions are very elegant or concise. Fortunately, there is a better way to deal with this problem: using the Guava Streams.mapWithIndex() method.

1. Overview of `Streams.mapWithIndex()` method

The Guava Streams.mapWithIndex() method is a static method that takes two parameters: a stream of elements and a function that accepts an element and its index as arguments and returns a new element. The method returns a new stream consisting of the results of applying the function to each element and its index in the original stream. The signature of the method is as follows:

1 2	public static <T,R> Stream<R> mapWithIndex(Stream<T> stream, BiFunction<? super T,Long,? extends R> function)

The first parameter is a Stream<T> that represents the source stream of elements. The second parameter is a BiFunction<? super T,Long,? extends R> that represents the mapping function. The BiFunction interface is a functional interface that takes two arguments and returns a result. In this case, the first argument is an element of type T (or any supertype of T), the second argument is a long value that represents the index of the element in the stream (starting from 0), and the result is an element of type R (or any subtype of R). The return type of the method is a Stream<R> that represents the new stream of elements after applying the mapping function.

2. Usage of `Streams.mapWithIndex()` method

To use the Guava Streams.mapWithIndex() method, you need to have Guava in your classpath. Then, you can import the Streams class from com.google.common.collect package. Now, you can use the Streams.mapWithIndex() method on any stream of elements. For example, suppose you have a stream of strings, you can use Streams.mapWithIndex() to append the index to each string:

import com.google.common.collect.Streams;

import java.util.stream.Stream;

class Main {

public static void main(String[] args) {

Stream<String> myStream = Stream.of("one", "two", "three");

Stream<String> result = Streams.mapWithIndex(myStream,

(str, index) -> str + ":" + index);

System.out.println(result.toList()); // [one:0, two:1, three:2]

}

Download Code

You can also use Streams.mapWithIndex() to filter out elements based on their indexes. For example, you can keep only the elements that have even indexes:

import com.google.common.collect.Streams;

import java.util.Objects;

import java.util.stream.Stream;

class Main {

public static void main(String[] args) {

Stream<String> myStream = Stream.of("one", "two", "three");

Stream<String> result = Streams.mapWithIndex(myStream,

(str, index) -> index % 2 == 0 ? str : null)

.filter(Objects::nonNull);

System.out.println(result.toList()); // [one, three]

}

Download Code

You can also use Streams.mapWithIndex() to create a map with the index as the key and the element as the value. For example, you can collect the stream into a LinkedHashMap:

import com.google.common.collect.Maps;

import com.google.common.collect.Streams;

import java.util.LinkedHashMap;

import java.util.Map;

import java.util.stream.Collectors;

import java.util.stream.Stream;

class Main {

public static void main(String[] args) {

Stream<String> myStream = Stream.of("one", "two", "three");

Map<Long, String> result = Streams.mapWithIndex(myStream,

(str, index) -> Maps.immutableEntry(index, str))

.collect(Collectors.toMap(Map.Entry::getKey,

Map.Entry::getValue,

(a, b) -> b,

LinkedHashMap::new));

System.out.println(result); // {0=one, 1=two, 2=three}

}

Download Code

3. Benefits of using `Streams.mapWithIndex()` method

There are several benefits of using Guava Streams.mapWithIndex() method over other solutions for accessing indexes in streams:

It is concise and expressive. You don’t need to write extra code to maintain an index variable or use a wrapper class. You can simply pass a lambda expression that takes an element and its index as arguments and returns a new element.
It is consistent and compatible. You can use it with any stream of elements, regardless of the source or the intermediate operations. You can also chain it with other stream methods, such as filter(), map(), flatMap(), sorted(), distinct(), limit(), skip(), etc.
It is parallel-friendly and lazy. You can use it with parallel streams without worrying about thread-safety or synchronization issues. The mapping function will be applied to each element and its index only when the stream is consumed, not when the method is called.

4. Conclusion

In this post, we have learned how to use Guava Streams.mapWithIndex() method in Java. We have seen what the method does, how to use it, and what benefits it offers over other solutions. We have also provided some examples and code snippets to demonstrate its usage in different scenarios.

If you are interested in learning more about this method, you can check out the Guava official website or its GitHub repository.

Guava Streams.mapWithIndex() method in Java

1. Overview of Streams.mapWithIndex() method

2. Usage of Streams.mapWithIndex() method

3. Benefits of using Streams.mapWithIndex() method

4. Conclusion

Share this:

1. Overview of `Streams.mapWithIndex()` method

2. Usage of `Streams.mapWithIndex()` method

3. Benefits of using `Streams.mapWithIndex()` method