Practice Now
Java
String Manipulation
split method
List
Programming Tutorial

How to split a delimited string to a ListString

Data Structures & Algorithms practice on Codemia

Step through 300 algorithm problems with animated visualisers that show the data structure changing as the code runs.

Practice algorithms
Data StructuresJava

Introduction

Splitting a delimited string into a List<String> is simple in Java until edge cases appear, such as empty tokens, extra spaces, or delimiters that are regex metacharacters. A robust approach should normalize values and make delimiter behavior explicit. This guide shows practical patterns you can run directly in a Java project.

Basic Split to List<String>

For plain delimiters such as comma, use String.split and wrap with Arrays.asList or streams.

java
1import java.util.Arrays;
2import java.util.List;
3
4public class SplitBasic {
5    public static void main(String[] args) {
6        String input = "red,green,blue";
7        List<String> parts = Arrays.asList(input.split(","));
8        System.out.println(parts);
9    }
10}

This works for clean input, but it keeps spaces and may drop trailing empty values depending on options.

Trim Tokens and Remove Empty Entries

Most real inputs need cleanup before use.

java
1import java.util.List;
2import java.util.stream.Collectors;
3import java.util.stream.Stream;
4
5public class SplitClean {
6    public static List<String> splitAndClean(String input) {
7        return Stream.of(input.split(","))
8                .map(String::trim)
9                .filter(s -> !s.isEmpty())
10                .collect(Collectors.toList());
11    }
12
13    public static void main(String[] args) {
14        String input = " red,  green ,, blue ,";
15        System.out.println(splitAndClean(input));
16    }
17}

This pattern removes accidental blank tokens and gives predictable output for user-entered data.

Keep Trailing Empty Tokens When Needed

By default, split drops trailing empty tokens. If position matters, pass a negative limit.

java
1import java.util.Arrays;
2
3public class SplitWithLimit {
4    public static void main(String[] args) {
5        String input = "A,B,,";
6        String[] tokens = input.split(",", -1);
7        System.out.println(Arrays.toString(tokens));
8        // Output: [A, B, , ]
9    }
10}

Use this when tokens map to fixed columns or configuration slots.

Escape Regex Delimiters Correctly

split treats the delimiter as a regex pattern. Characters such as dot or pipe must be escaped.

java
1import java.util.Arrays;
2
3public class SplitRegexDelim {
4    public static void main(String[] args) {
5        String dotted = "api.v1.users";
6        System.out.println(Arrays.toString(dotted.split("\.")));
7
8        String piped = "alpha|beta|gamma";
9        System.out.println(Arrays.toString(piped.split("\|")));
10    }
11}

If delimiters are dynamic, use Pattern.quote to avoid accidental regex behavior.

java
1import java.util.Arrays;
2import java.util.regex.Pattern;
3
4public class SplitQuoted {
5    public static void main(String[] args) {
6        String input = "left||middle||right";
7        String delimiter = "||";
8        String[] tokens = input.split(Pattern.quote(delimiter));
9        System.out.println(Arrays.toString(tokens));
10    }
11}

When Input Is CSV, Use a CSV Parser

If values may contain quoted commas, plain split(",") is not sufficient. Use a CSV library.

java
1import com.opencsv.CSVParser;
2import com.opencsv.CSVParserBuilder;
3
4public class CsvExample {
5    public static void main(String[] args) throws Exception {
6        String row = "alpha,"beta,gamma",delta";
7        CSVParser parser = new CSVParserBuilder().withSeparator(',').build();
8        String[] values = parser.parseLine(row);
9        for (String v : values) {
10            System.out.println(v);
11        }
12    }
13}

CSV parsing avoids subtle bugs when user data includes delimiters inside quoted fields.

Return Immutable Lists for Safer APIs

If a split helper is shared across services, returning an immutable list prevents accidental mutation by callers. This is useful when tokens represent configuration values that should not change after parsing.

java
1import java.util.List;
2
3List<String> values = List.of("alpha", "beta", "gamma");
4// values.add("delta");  // throws UnsupportedOperationException
5
6System.out.println(values);

You can also wrap parsed output with List.copyOf(parsed) before returning it from utility methods.

Common Pitfalls

  • Forgetting that split uses regex rules, not literal delimiter matching.
  • Losing trailing empty values because split limit was not set.
  • Not trimming tokens before validation or comparison.
  • Using plain split for CSV-like data that contains quoted delimiters.
  • Returning mutable lists from utility methods when callers expect immutability.

Summary

  • Start with split for clean simple input.
  • Add trim and empty-token filtering for user-entered strings.
  • Use split(delimiter, -1) when positional empties must be preserved.
  • Escape regex delimiters or use Pattern.quote for dynamic delimiters.
  • Switch to a CSV parser when quoting rules are part of the format.
Related reading
Course
Intermediate
27 lessons
15 hours
DSA Fundamentals

Master algorithmic patterns and data structures through hands-on LeetCode-style problems - from arrays and hashing to dynamic programming and advanced graphs.

View the course
Track what you have practised

A free account saves your progress, solutions and study plan across every problem on Codemia.

Data Structures & Algorithms practice on Codemia

Step through 300 algorithm problems with animated visualisers that show the data structure changing as the code runs.

Practice algorithms
Codemia
© 2026 Codemia
Resources
Legal
Social
All Rights Reserved.