Partner – Moderne – NPI EA (cat=Spring Boot)
announcement - icon

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Course – Black Friday 2026 – NPI EA – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

1. Introduction

In this article, we will look into the different ways we can convert a given ArrayList<Object> to an ArrayList<String>.

2. Problem Statement

Let’s understand the problem statement here. Suppose we have an ArrayList<Object> where the objects can be of any type, ranging from auto-boxed primitive types such as Integer, Float, or Boolean, to non-primitive reference types such as String, ArrayList, HashMap, or even custom-defined classes. We have to write code to convert the said list into an ArrayList<String>. Let’s look at a few examples:

Example 1: [1, 2, 3, 4, 5]
Output 1: ["1", "2", "3", "4", "5"]

Example 2: ["Hello", 4.9837, -19837338737, true]
Output 2: ["Hello", "4.9837", "-19837338737", "true"]

Example 3: [new Node(1,4), new Double(7699.05), new User("John Doe")]
Output 3: ["Node (x=1, y=4)", "7699.05", "User (full name=John Doe)"]

We can provide a host of different objects in the input list, including objects of custom-defined classes like User and Node shown below. It is assumed that these classes have an overridden toString() method. In case the method is not defined, the Object class’s toString() will be invoked, which will generate an output like:

Node@f6d9f0, User@u8g0f9

The above examples contain instances of custom-defined classes such as User and Node:

public class User {
    private final String fullName;

    // getters and setters

   @Override
    public String toString() {
        return "User (" + "full name='" + fullName + ')';
    }
}
public class Node {
    private final int x;
    private final int y;

    // getters and setters

    @Override
    public String toString() {
        return "Node (" + "x=" + x + ", y=" + y + ')';
    }
}

Finally, let’s assume that in the remaining sections, the variables inputList and expectedStringList contain a reference to our desired input and output lists:

List<Object> inputList = List.of(
                        1,
                        true,
                        "hello",
                        Double.valueOf(273773.98),
                        new Node(2, 4),
                        new User("John Doe")
                    );
List<String> expectedStringList = List.of(
                        "1",
                        "true",
                        "hello",
                        Double.toString(273773.98),
                        new Node(2, 4).toString(),
                        new User("John Doe").toString()
                    );

3. Conversion Using Java Collections For-Each Loop

Let’s try to use Java Collections to solve our problem. The idea is to iterate through the elements of the list and convert each element into a String. Once done, we have a list of String objects. In the following code, we iterate through the given list using a for-each loop and explicitly convert every object to a String by calling toString() on it:

List<String> outputList = new ArrayList<>(inputList.size());
for(Object obj : inputList){
    outputList.add(obj.toString());
}
Assert.assertEquals(expectedStringList, outputList);

This solution works for all combinations of objects in the input list and works on all Java versions above Java 5. However, the above solution is not immune to null objects in the input and will throw a NullPointerException whenever it encounters a null. A simple enhancement utilizes the toString() method provided by the Objects utility class introduced in Java 7 and is null-safe:

List<String> outputList = new ArrayList<>(inputList.size());
for(Object obj : inputList){
    outputList.add(Objects.toString(obj, null));
}
Assert.assertEquals(expectedStringList, outputList);

4. Conversion Using Java Streams

We can leverage the Java Streams API to solve our problem as well. We first convert the inputList, our data source, to a stream by applying the stream() method. Once we have a stream of elements, which are of type Object, we need an intermediate operation, which in our case is to do the object-to-string conversion, and finally, a terminal operation, which is to collect the results into another list of type String.

The intermediate operation in our case is a map() operation that takes a lambda expression:

(obj) -> Objects.toString(obj, null)

Finally, our stream needs a terminal operation to compile and return the desired list. In the subsequent subsections, we discuss the different terminal operations available at our disposal.

4.1. Collectors.toList() as a Terminal Operation

In this approach, we use Collectors.toList() to collect the stream generated by the intermediate operation into an output list:

List<String> outputList;
outputList = inputList
    .stream()
    .map((obj) -> Objects.toString(obj, null))
    .collect(Collectors.toList());
Assert.assertEquals(expectedStringList, outputList);

This approach works well for Java 8 and above as the Streams API was introduced in Java 8. The list produced as output here is a mutable list, which means we can add elements to it. The output list can contain null values as well.

4.2. Collectors.toUnmodifableList() as a Terminal Operation – Java 10 Compatible Approach

If we want to produce an output list of String objects that is unmodifiable, we can leverage the Collectors.toUnmodifableList() implementation introduced in Java 10:

List<String> outputList;
outputList = inputList
    .stream()
    .filter(Objects::nonNull)
    .map((obj) -> Objects.toString(obj, null))
    .collect(Collectors.toUnmodifiableList());
Assert.assertEquals(expectedStringListWithoutNull, outputList);

An important caveat here is that the list cannot contain null values and, hence, if the inputList contains a null, this code produces a NullPointerException. This is why we add a filter to select only nonNull elements from the stream before applying our operation. The outputList is immutable and will produce an UnsupportedOperationException if there is an attempt to modify it later.

4.3. toList() as a Terminal Operation – Java 16 Compatible Approach

In case we want to directly create an unmodifiable list from the input Stream, but we want to allow null values in the resulting list, we can use the toList() method that was introduced in the Stream interface in Java 16:

List<String> outputList;
outputList = inputList
    .stream()
    .map((obj) -> Objects.toString(obj, null))
    .toList();
Assert.assertEquals(expectedStringList, outputList);

5. Conversion Using Guava

We can use the Google Guava Library to transform the input list of objects into a new list of String.

5.1. Maven Configuration

To use the Google Guava library, we need to include the corresponding Maven dependency in pom.xml:

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>33.0.0-jre</version>
    <scope>test</scope>
</dependency>

The latest version of the dependency can be obtained from Maven Central.

5.2. Using Lists.transform()

We can use the transform() method in the Google Guava Lists class. It takes in the inputList and the aforementioned lambda expression to generate the outputList of String objects:

List<String> outputList;
outputList = Lists.transform(inputList, obj -> Objects.toString(obj, null));
Assert.assertEquals(expectedStringList, outputList);

With this method, the output list can contain null values.

6. Conclusion

In this article, we looked into a few different ways an ArrayList of Object elements can be converted into an ArrayList of String. We explored different implementations from a for-each loop-based approach to a Java Streams-based approach. We also looked at different implementations specific to different Java versions, as well as one from Guava.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.
Partner – Moderne – NPI EA (tag=Refactoring)
announcement - icon

Modern Java teams move fast — but codebases don’t always keep up. Frameworks change, dependencies drift, and tech debt builds until it starts to drag on delivery. OpenRewrite was built to fix that: an open-source refactoring engine that automates repetitive code changes while keeping developer intent intact.

The monthly training series, led by the creators and maintainers of OpenRewrite at Moderne, walks through real-world migrations and modernization patterns. Whether you’re new to recipes or ready to write your own, you’ll learn practical ways to refactor safely and at scale.

If you’ve ever wished refactoring felt as natural — and as fast — as writing code, this is a good place to start.

Course – Black Friday 2026 – NPI EA – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW