Splitting String into an int Array in Java

1. Overview

In many programming tasks, we often get data in string form. The data source can be user input or content from a file. When working with calculations and comparison operations, we need to change string values into numeric types.

In this tutorial, we’ll see how to use the Java splitting and storing operation to change text types. Specifically, we’ll convert a string of comma-separated numbers into an array of integers.

2. Understanding the Problem

By definition, a string in Java is a sequence of characters. In addition to that, strings are objects of the java.lang.String class. This class has many methods to work with strings.

Let’s take an example use case:

String input = "10, 20, 30, 40, 50";

In the above example, we’ve a string containing a list of numbers. These numbers are separated by commas. It’s important to note that 10 is a string here, not an integer. Thus, we can’t directly use it in any arithmetic operations.

So, we’ll split this string into individual elements. We then convert them into integers for use within an array.

3. Practical Implementation

Let’s take an example to see how we can split a string and store it within an int-type array:

public int[] convert(String numbers, String delimiterRegex) {
    if (numbers == null || numbers.isEmpty()) {
        return new int[0];
    }
    
    String[] parts = numbers.split(delimiterRegex);
    int[] intArray = new int[parts.length];
    for (int i = 0; i < parts.length; i++) {
        intArray[i] = Integer.parseInt(parts[i].trim());
    }

    return intArray;
}

The convert() method in the above converter performs several tasks:

1. Validates the input
2. Splits the given String by the chosen delimiter
3. Trims the element where needed
4. Parses each element into a primitive int array

As usual, we can verify the code above via the unit tests:

@Test
void givenCommaSeparatedString_whenConvert_thenReturnIntArray() {
    int[] result = converter.convert("10, 20, 30, 40, 50", ",");
    assertThat(result).containsExactly(10, 20, 30, 40, 50);
}

In the above test code, we’ve used the convert() method. It takes a comma-separated string.

Let’s see how the convert() method works. Inside this method, we use the split(“,”) method to break up the text wherever a comma comes:

["10", " 20", " 30", " 40", " 50"]

As a result, we get an integer array. This array now stores the values of the string numbers without any commas. Notably, apart from the first one, the above strings still have leading spaces.

In the next step, we trim each element to clear any leading or trailing white-space.

Finally, the resulting array is placed in an Int type Array. With the test code, we can see that the resulting array matches the expected integers.

4. Working With Different Delimiters

The same logic works with other separators. We now take an example that uses semicolons:

@Test
void givenSemicolonSeparatedString_whenConvert_thenReturnIntArray() {
    int[] result = converter.convert("10; 20; 30; 40; 50", ";");
    assertThat(result).containsExactly(10, 20, 30, 40, 50);
}

In this case, we just change the symbol from a comma to a semicolon. However, we get the same output.

It’s important to note that when working with regex characters, we should escape certain characters.

Let’s take a use case where we use the regex | pipe character:

@Test
void givenPipeSeparatedString_whenConvert_thenReturnIntArray() {
    int[] result = converter.convert("10|20|30|40|50", "\\|");
    assertThat(result).containsExactly(10, 20, 30, 40, 50);
}

Again, we get the same result. So, as a thumb rule, we use escaping with \\ backslashes for the regex characters. For multiple delimiters, the split() method combines all of them into a single pattern.

5. Conclusion

In this article, we saw how to use the split() method for splitting a string. We then convert it into an int array. First, we saw an example with simple delimiters, such as commas and semicolons. Then, we used the regex characters with the backslash escape character.

We can apply the same ways to other use cases:

• reading input from the user
• reading data from files
• handling large numeric datasets

By adjusting the delimiter, we can use the same method to process many data types with ease.

As always, the full code for the examples is available over on GitHub.