1. Overview
In this quick tutorial, let’s explore how to convert an array of String into an array of int in Java.
2. Introduction to the Problem
First of all, let’s see a String array example:
String[] stringArray = new String[] { "1", "2", "3", "4", "5", "6", "42" };
We’ve created stringArray with seven strings. Now, we need to convert stringArray into an integer array:
int[] expected = new int[] { 1, 2, 3, 4, 5, 6, 42 };
As the example above shows, the requirement is pretty straightforward. However, in the real world, the string array may come from different sources, such as user input or another system. Therefore, the input array may contain some values that are not in valid number formats, for instance:
String[] stringArrayWithInvalidNum = new String[] { "1", "2", "hello", "4", "world", "6", "42" };
The “hello” and “world” elements aren’t valid numbers, though the others are. Usually, when these kinds of values are detected in an actual project, we’ll follow special error handling rules — for instance, aborting the array conversion, taking a particular integer as a fallback, and so on.
In this tutorial, we will use Java’s minimum integer as the fallback for invalid string elements:
int[] expectedWithInvalidInput = new int[] { 1, 2, Integer.MIN_VALUE, 4, Integer.MIN_VALUE, 6, 42 };
Next, let’s start with the string array with all valid elements and then extend the solution with the error-handling logic.
For simplicity, we’ll use unit test assertions to verify if our solutions work as expected.
3. Using the Stream API
Let’s first convert the string array with all valid elements using the Stream API:
int[] result = Arrays.stream(stringArray).mapToInt(Integer::parseInt).toArray();
assertArrayEquals(expected, result);
As we can see, the Arrays.stream() method turns the input string array into a Stream. Then, the mapToInt() intermediate operation converts our stream to an IntStream object.
We’ve used Integer.parseInt() to convert strings to integers. Finally, toArray() converts the IntStream object back to an array.
So, next, let’s look at the elements in an invalid number format scenario.
Suppose the input string’s format is not a valid number, in which case the Integer.parseInt() method throws NumberFormatException.
Therefore, we need to replace the method reference Integer::parseInt in the mapToInt() method with a lambda expression and handle the NumberFormatException exception in the lambda expression:
int[] result = Arrays.stream(stringArrayWithInvalidNum).mapToInt(s -> {
try {
return Integer.parseInt(s);
} catch (NumberFormatException ex) {
// logging ...
return Integer.MIN_VALUE;
}
}).toArray();
assertArrayEquals(expectedWithInvalidInput, result);
Then, if we run the test, it passes.
As the code above shows, we’ve only changed the implementation in the mapToInt() method.
It’s worth mentioning that Java Stream API is available on Java 8 and later versions.
4. Implementing the Conversion in a Loop
We’ve learned how the Stream API solves the problem. However, if we’re working with an older Java version, we need to solve the problem differently.
Now that we understand Integer.parseInt() does the main conversion job, we can loop through the elements in the array and call the Integer.parseInt() method on each string element:
int[] result = new int[stringArray.length];
for (int i = 0; i < stringArray.length; i++) {
result[i] = Integer.parseInt(stringArray[i]);
}
assertArrayEquals(expected, result);
As we can see in the implementation above, we first create an integer array with the same length as the input string array. Then, we perform the conversion and fill the result array in the for loop.
Next, let’s extend the implementation to add the error-handling logic. Similar to the Stream API approach, just wrapping the conversion line by a try-catch block can solve the problem:
int[] result = new int[stringArrayWithInvalidNum.length];
for (int i = 0; i < stringArrayWithInvalidNum.length; i++) {
try {
result[i] = Integer.parseInt(stringArrayWithInvalidNum[i]);
} catch (NumberFormatException exception) {
// logging ...
result[i] = Integer.MIN_VALUE;
}
}
assertArrayEquals(expectedWithInvalidInput, result);
The test passes if we give it a run.
5. Conclusion
In this article, we’ve learned two ways to convert a string array to an integer array through examples. Moreover, we’ve discussed handling the conversion when the string array contains invalid number formats.
If our Java version is 8 or later, the Stream API would be the most straightforward solution to the problem. Otherwise, we can loop through the string array and convert each string element to an integer.
As usual, all code snippets presented in the article are available over on GitHub.
