Mapping an Array of Integers to Strings Using Java Streams

1. Introduction

In this tutorial, we’ll look at how we can convert an array of Integers into Strings using Java Streams.

We’ll compare the approaches we need to take depending on if we have an array of Integers or primitive int values. For Integers, we’ll utilize Stream<Integer> and the methods Integer inherits from Object for the conversion. For int, we’ll use the specialized IntStream.

2. Creating a Stream From an Array

Let’s start by converting our array into a Stream. We can use the same method for Integers and primitive integers here, but the return types will be different. If we have an array of Integers, we’ll get a Stream<Integer>:

Integer[] integerArray = { 1, 2, 3, 4, 5 };
Stream<Integer> integerStream = Arrays.stream(integerArray);

If we instead start with an array of primitive integers, we’ll get an IntStream:

int[] intArray = { 1, 2, 3, 4, 5 };
IntStream intStream = Arrays.stream(intArray);

IntStream gives us its own set of methods we can work with that we’ll use for our type conversions later.

3. Converting From Integers

With a Stream<Integer> ready, we can go ahead and convert the Integers into Strings. As Integer gives us access to all of the methods from Object, we can use Object.toString() along with map():

String[] convertToStringArray(Integer[] input) {
    return Arrays.stream(input)
      .map(Object::toString)
      .toArray(String[]::new);
}

Let’s then use convertToStringArray() to convert an array of Integers and confirm that the returned array of Strings appears as we’d expect:

@Test
void whenConvertingIntegers_thenHandleStreamOfIntegers() {
    Integer[] integerNumbers = { 1, 2, 3, 4, 5 };
    String[] expectedOutput = { "1", "2", "3", "4", "5" };

    String[] strings = convertToStringArray(integerNumbers);

    Assert.assertArrayEquals(expectedOutput, strings);
}

4. Converting From Primitive Integers

Let’s now look at how to handle the IntStream that starting with an array of integers gives us.

4.1. Returning an Array

With an IntStream ready, we can use IntStream.mapToObj() for our conversion:

String[] convertToStringArray(int[] input) {
    return Arrays.stream(input)
      .mapToObj(Integer::toString)
      .toArray(String[]::new);
}

The mapToObj() method returns an object-valued Stream using the Integer.toString() method we gave it. So, after that stage in our method, we have a Stream<String> to work with that we can simply collect the contents from using toArray().

We can then again check that using convertToStringArray() gives us an array of Strings matching the input array of integers:

@Test
void whenConvertingInts_thenHandleIntStream() {
    int[] intNumbers = { 1, 2, 3, 4, 5 };
    String[] expectedOutput = { "1", "2", "3", "4", "5" };

    String[] strings = convertToStringArray(intNumbers);

    Assert.assertArrayEquals(expectedOutput, strings);
}

Additionally, if we want to use any of the benefits that come with the Integer type mid-stream, we can use boxed():

String[] convertToStringArrayWithBoxing(int[] input) {
    return Arrays.stream(input)
      .boxed()
      .map(Object::toString)
      .toArray(String[]::new);
}

4.2. Returning a Single String

Another potential use case is converting our integer array into a single String. We can reuse much of the above code for this along with Stream.collect() to reduce the Stream into a String. The collect() method is versatile and lets us terminate our Streams into a wide range of types. Here, we’ll pass it Collectors.joining(“, “) so each element in the array will be concatenated into a single String with a comma between them:

String convertToString(int[] input){
    return Arrays.stream(input)
      .mapToObj(Integer::toString)
      .collect(Collectors.joining(", "));
}

We can then test that the returned String looks as we’d expect:

@Test
void givenAnIntArray_whenUsingCollectorsJoining_thenReturnCommaSeparatedString(){
    int[] intNumbers = { 1, 2, 3, 4, 5 };
    String expectedOutput = "1, 2, 3, 4, 5";

    String string = convertToString(intNumbers);

    Assert.assertEquals(expectedOutput, string);
}

5. Conclusion

In this article, we learned how to convert arrays of Integers or primitive integers into Strings using Java Streams. We saw that when dealing with Integers, we need to expect a Stream<Integer>. However, when dealing with primitive integers instead, we expect an IntStream.

We then looked at how to handle the two Stream types to end up with an array of Strings. The map() method can be used for Stream<Integer> and mapToObj() for IntStreams. Finally, we saw how we could return a single String using Collectors.joining().