1. Overview

In this tutorial, we’ll look at converting a comma-separated String into a List of strings. Additionally, we’ll transform a comma-separated String of integers to a List of Integers.

2. Dependencies

A few of the methods that we’ll use for our conversions require the Apache Commons Lang 3 and Guava libraries. So, let’s add them to our pom.xml file:

<dependency>
 <groupId>org.apache.commons</groupId>
 <artifactId>commons-lang3</artifactId>
 <version>3.14.0</version>
</dependency>
<dependency>
 <groupId>com.google.guava</groupId>
 <artifactId>guava</artifactId>
 <version>31.0.1-jre</version>
</dependency>

3. Defining Our Example

Before we start, let’s define two inputs strings that we’ll use in our examples. The first string, countries, contains several strings separated by a comma, and the second string, ranks, includes numbers separated by a comma:

String countries = "Russia,Germany,England,France,Italy";
String ranks = "1,2,3,4,5,6,7";

And, throughout this tutorial, we’ll convert the above strings into lists of strings and integers which we will store in:

List<String> convertedCountriesList;
List<Integer> convertedRankList;

Finally, after we perform our conversions, the expected outputs will be:

List<String> expectedCountriesList = Arrays.asList("Russia", "Germany", "England", "France", "Italy");
List<Integer> expectedRanksList = Arrays.asList(1, 2, 3, 4, 5, 6, 7);

4. Core Java

In our first solution, we’ll convert a string to a list of strings and integers using core Java.

First, we’ll split our string into an array of strings using split, a String class utility method. Then, we’ll use Arrays.asList on our new array of strings to convert it into a list of strings:

List<String> convertedCountriesList = Arrays.asList(countries.split(",", -1));

Let’s now turn our string of numbers to a list of integers.

We’ll use the split method to convert our numbers string into an array of strings. Then, we’ll convert each string in our new array to an integer and add it to our list:

String[] convertedRankArray = ranks.split(",");
List<Integer> convertedRankList = new ArrayList<Integer>();
for (String number : convertedRankArray) {
 convertedRankList.add(Integer.parseInt(number.trim()));
}

In both these cases, we use the split utility method from the String class to split the comma-separated string into a string array.

Note that the overloaded split method used to convert our countries string contains the second parameter limit, for which we provided the value as -1. This specifies that the separator pattern should be applied as many times as possible.

The split method we used to split our string of integers (ranks) uses zero as the limit, and so it ignores the empty strings, whereas the split used on the countries string retains empty strings in the returned array.

5. Java Streams

Now, we’ll implement the same conversions using the Java Stream API.

First, we’ll convert our countries string into an array of strings using the split method in the String class. Then, we’ll use the Stream class to convert our array into a list of strings:

List<String> convertedCountriesList = Stream.of(countries.split(",", -1))
 .collect(Collectors.toList());

Let’s see how to convert our string of numbers into a list of integers using a Stream.

Again, we’ll first convert the string of numbers into an array of strings using the split method and convert the resulting array to a Stream of String using the of() method in the Stream class.

Then, we’ll trim the leading and trailing spaces from each String on the Stream using map(String::trim).

Next, we’ll apply map(Integer::parseInt) on our stream to convert every string in our Stream to an Integer.

And finally, we’ll call collect(Collectors.toList()) on the Stream to convert it to an integer list:

List<Integer> convertedRankList = Stream.of(ranks.split(","))
 .map(String::trim)
 .map(Integer::parseInt)
 .collect(Collectors.toList());

6. Apache Commons Lang

In this solution, we’ll use the Apache Commons Lang3 library to perform our conversions. Apache Commons Lang3 provides several helper functions to manipulate core Java classes.

First, we’ll split our string into an array of strings using StringUtils.splitPreserveAllTokens. Then, we’ll convert our new string array into a list using Arrays.asList method:

List<String> convertedCountriesList = Arrays.asList(StringUtils.splitPreserveAllTokens(countries, ","));

Let’s now transform our string of numbers to a list of integers.

We’ll again use the StringUtils.split method to create an array of strings from our string. Then, we’ll convert each string in our new array into an integer using Integer.parseInt and add the converted integer to our list:

String[] convertedRankArray = StringUtils.split(ranks, ",");
List<Integer> convertedRankList = new ArrayList<Integer>();
for (String number : convertedRankArray) {
 convertedRankList.add(Integer.parseInt(number.trim()));
}

In this example, we used the splitPreserveAllTokens method to split our countries string, whereas we used the split method to split our ranks string.

Even though both these functions split the string into an array, the splitPreserveAllTokens preserves all tokens including the empty strings created by adjoining separators, while the split method ignores the empty strings.

So, if we have empty strings that we want to be included in our list, then we should use the splitPreserveAllTokens instead of split.

7. Guava

Finally, we’ll use the Guava library to convert our strings to their appropriate lists.

To convert our countries string, we’ll first call Splitter.on with a comma as the parameter to specify what character our string should be split on.

Then, we’ll use the trimResults method on our Splitter instance. This will ignore all leading and trailing white spaces from the created substrings.

Finally, we’ll use the splitToList method to split our input string and convert it to a list:

List<String> convertedCountriesList = Splitter.on(",")
 .trimResults()
 .splitToList(countries);

Now, let’s convert the string of numbers to a list of integers.

We’ll again convert the string of numbers into a list of strings using the same process we followed above.

Then, we’ll use the Lists.transform method, which accepts our list of strings as the first parameter an implementation of the Function interface as the second parameter.

The Function interface implementation converts each string in our list to an integer:

List<Integer> convertedRankList = Lists.transform(Splitter.on(",")
 .trimResults()
 .splitToList(ranks), new Function<String, Integer>() {
 @Override
 public Integer apply(String input) {
 return Integer.parseInt(input.trim());
 }
 });

8. Conclusion

In this article, we converted comma-separated Strings into a list of strings and a list of integers. However, we can follow similar processes to convert a String into a list of any primitive data types.