Convert a List of Integers to a List of Strings

1. Overview

Since version 5, Java has supported generics. One benefit Java generics bring us is type safety. For example, when we’ve declared a List object myList as List, we cannot put an element whose type is other than Integer to myList.

However, when we work with generic collections, we often want to convert Collection to Collection.

In this tutorial, we’ll take List as an example to explore how to convert List to List.

2. Preparing a List Object as an Example

For simplicity, we’ll use unit test assertions to verify whether our conversions work as expected. Therefore, let’s first initialize a list of integers:

List<Integer> INTEGER_LIST = Arrays.asList(1, 2, 3, 4, 5, 6, 7);

As the code above shows, we have seven integers in the INTEGER_LIST object. Now, our goal is to convert each integer element in INTEGER_LIST to a String, for example, 1 to “1”, 2 to “2”, and so on. Finally, the result should be equal to:

List<String> EXPECTED_LIST = Arrays.asList("1", "2", "3", "4", "5", "6", "7");

In this tutorial, we’ll address three different ways to do that:

• Using Java 8’s Stream API
• Using a Java for loop
• Using the Guava library

Next, let’s see them in action.

3. Using Java 8 Stream‘s map() Method

Java Stream API is available on Java 8 and later versions. It provides many convenient interfaces, allowing us to easily handle Collections as streams.

For example, *one typical method to convert List to List is Stream‘s map() method*:

theList.stream().map( .. the conversion logic.. ).collect(Collectors.toList());

So next, let’s see how to use the map() method to convert List to List:

List<String> result = INTEGER_LIST.stream().map(i -> i.toString()).collect(Collectors.toList());
assertEquals(EXPECTED_LIST, result);

As the code example above shows, we pass a lambda expression to map(), calling each element (Integer)’s toString() method to convert it to a String.

If we run it, the test passes. So, the Stream‘s map() method does the job.

4. Using a for Loop

We’ve seen that Stream‘s map() method can solve the problem. However, as we’ve mentioned, the Stream API is only available in Java 8 and later versions. Therefore, if we’re working with an older Java version, we need to solve the problem another way.

For example, we can do the conversion through a simple for loop:

List<String> result = new ArrayList<>();
for (Integer i : INTEGER_LIST) {
    result.add(i.toString());
}

assertEquals(EXPECTED_LIST, result);

The code above shows that we first created a new List object, result. Then, we iterate elements from the List list in a for loop, convert each Integer element to String, and add the string to the result list.

The test passes if we give it a run.

5. Using the Guava Library

As converting a collection’s type is a pretty standard operation when we work with collections, some popular external libraries have provided utility methods to do the conversion.

In this section, we’ll use Guava to show how to solve our problem.

First, let’s add the Guava library dependency in the pom.xml:

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>31.1-jre</version>
</dependency>

Of course, we can check for the latest version in the Maven Central repository.

Next, we can use Guava’s Lists.transform() method to solve our problem:

List<String> result = Lists.transform(INTEGER_LIST, Functions.toStringFunction());
assertEquals(EXPECTED_LIST, result);

The transform() method applies toStringFunction() on each element in INTEGER_LIST and returns the converted list.

The test passes if we run it.

6. Conclusion

In this short article, we’ve learned three ways to convert List to List. If our Java version is 8+, Stream API would be the most straightforward conversion method. Otherwise, we can apply the conversion through a loop or turn to an external library, such as Guava.

The source code is available over on GitHub.