Exploring Different Ways to Split Strings in Java

Splitting strings is a fundamental operation in Java programming, commonly used in data processing, text manipulation, and parsing structured content like CSV files or logs. Whether you need to break down user input, process API responses, or extract values from a large text, Java provides multiple ways to efficiently split strings based on a delimiter.

Each method has its own strengths and weaknesses, affecting performance, flexibility, and ease of use. Some methods, like String.split(), are straightforward and built-in, while others, such as using StringTokenizer or Scanner, offer more control. Additionally, modern approaches like Java Streams provide a functional alternative for handling string splitting with filtering capabilities.

Output

Overview of the Code

1. Using String.split() Method

The simplest way to split a string is by using the built-in split() method of the String class. This method takes a
regular expression as a delimiter and returns an array of substrings.

1 2 3 4

public static String[] splitM1(String input, String delimiter) {     if (input == null || delimiter == null) return new String[0];     return input.split(Pattern.quote(delimiter)); }

Explanation

• Pattern.quote(delimiter): Escapes special characters in the delimiter to ensure correct splitting.
• Returns an array of substrings split by the delimiter.
2. Using StringTokenizer

The StringTokenizer class is an older method to split strings. It tokenizes a string based on a given delimiter.

1 2 3 4 5 6 7 8 9 10

public static String[] splitM2(String input, String delimiter) {     if (input == null || delimiter == null) return new String[0];          StringTokenizer tokenizer = new StringTokenizer(input, delimiter);     List<String> list = new ArrayList<>();     while (tokenizer.hasMoreTokens()) {         list.add(tokenizer.nextToken());     }     return list.toArray(new String[0]); }

Explanation

• StringTokenizer iterates over tokens split by the delimiter.
• Tokens are stored in an ArrayList and then converted to an array.
• Note: StringTokenizer does not support regular expressions.
3. Using indexOf() and substring() (Manual Approach)

For full control over the splitting process, you can manually extract substrings using indexOf() and substring().

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

public static String[] splitM3(String input, String delimiter) {     if (input == null || delimiter == null) return new String[0];          List<String> list = new ArrayList<>();     int index = 0;     do {         int lastIndex = index;         index = input.indexOf(delimiter, index + 1);         if (lastIndex != index) {             String element = input.substring(                 lastIndex == 0 ? 0 : lastIndex + delimiter.length(),                 index > 0 ? index : input.length()             );             if (!element.equals(delimiter) && !element.isEmpty()) {                 list.add(element);             }         }     } while (index >= 0);          return list.toArray(new String[0]); }

Explanation

• Uses indexOf() to find the next occurrence of the delimiter.
• Extracts substrings using substring().
• More efficient than split() if working with large strings.
4. Using Pattern.split()

The Pattern class provides a way to split strings using compiled regular expressions.

1 2 3 4

public static String[] splitM4(String input, String delimiter) {     if (input == null || delimiter == null) return new String[0];     return Pattern.compile(Pattern.quote(delimiter)).split(input); }

Explanation

• Pattern.compile(Pattern.quote(delimiter)): Compiles a pattern for efficient splitting.
• This is a good alternative to String.split() when the same delimiter is used multiple times.
5. Using Scanner

Java’s Scanner class provides another way to tokenize a string.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

public static String[] splitM5(String input, String delimiter) {     if (input == null || delimiter == null) return new String[0];          List<String> list = new ArrayList<>();     try (Scanner scanner = new Scanner(input)) {         scanner.useDelimiter(Pattern.quote(delimiter));         while (scanner.hasNext()) {             String element = scanner.next();             if (!element.isEmpty()) {                 list.add(element);             }         }     }     return list.toArray(new String[0]); }

Explanation

• Uses Scanner to iterate through tokens separated by the delimiter.
• More flexible than StringTokenizer since it allows regex-based delimiters.
6. Using Java Streams

The Java 8 Streams API offers a functional approach to string splitting.

1 2 3 4 5 6 7

public static String[] splitM6(String input, String delimiter) {     if (input == null || delimiter == null) return new String[0];          return Stream.of(input.split(Pattern.quote(delimiter)))                  .filter(s -> !s.isEmpty())                  .toArray(String[]::new); }

Explanation

• Uses Stream.of() to create a stream from the split string.
• Filters out empty strings.
• Useful when combined with other stream operations.

Conclusion

Each method of splitting strings in Java has its own advantages:

• split() (splitM1) and Pattern.split() (splitM4) are easy to use and handle
  regex.
• StringTokenizer (splitM2) is lightweight but lacks regex support.
• indexOf() and substring() (splitM3) provide a manual approach with more control.
• Scanner (splitM5) is useful when processing structured input.
• Streams (splitM6) offer a functional, concise approach.

Choosing the right method depends on the use case, performance needs, and complexity of the delimiter.