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. 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.

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

2 Comments
Oldest
Newest