Java String split() Method

The split() method in Java splits a String into an array of substrings based on a delimiter. It is beneficial for breaking up Strings into parts for easier processing.

The split() method accepts a regular expression as a parameter and splits the string around matches of the regular expression. The resultant substrings are returned in an array.

For example, splitting a string on whitespace can be done like:

String str = "Hello World";
String[] parts = str.split("\\s+"); // split on whitespace

This would result in a String array with two elements, “Hello” and “World”.

Variants of the split() Method in Java

There are two main variants of split() in Java:

Variant 1:

public String[] split(String regex, int limit)

This variant allows for the specification of a limit on the number of splits performed.

Parameters:

• regex – A delimiting regular expression
• limit – The limit parameter controls the number of times the pattern is applied and, therefore, affects the length of the resulting array.

Returns:

An array of strings is computed by splitting the given string around matches of the given regular expression.

Exception Thrown:

• PatternSyntaxException – If the syntax of the regular expression is invalid

The limit parameter can take three possible values:

• Positive Limit – Splits up to the specified limit as many times as possible. The last element in the array may contain unmatched delimiter characters.
• Zero – Splits all matches of the delimiter. The returned array contains empty strings between contiguous matches of the delimiter.
• Negative Limit – Splits all matches of the delimiter with no limit.

Example:

public class SplitExample {
    public static void main(String[] args) {
        // Input string
        String str = "Hello-World-Java";

        // Example 1: Limit of 5
        String[] parts1 = str.split("-", 5);
        System.out.println("Example 1: Limit of 5");
        for (String part : parts1) {
            System.out.println(part);
        }
        // Output: ["Hello", "World", "Java"]
        
        // Example 2: Limit of 0 (default)
        String[] parts2 = str.split("-");
        System.out.println("\nExample 2: Limit of 0 (default)");
        for (String part : parts2) {
            System.out.println(part);
        }
        // Output: ["", "Hello", "World", "Java"]
        
        // Example 3: Negative Limit (no limit)
        String[] parts3 = str.split("-", -1);
        System.out.println("\nExample 3: Negative Limit (no limit)");
        for (String part : parts3) {
            System.out.println(part);
        }
        // Output: ["Hello", "World", "Java"]
    }
}

Output:

Example 1: Limit of 5
Hello
World
Java

Example 2: Limit of 0 (default)
Hello
World
Java

Example 3: Negative Limit (no limit)
Hello
World
Java

Variant 2:

public String[] split(String regex)

This variant only takes the regular expression to split on.

Parameters:

regex – A delimiting regular expression

Returns:

An array of strings is computed by splitting the input string around matches of the given regular expression.

Exception Thrown:

PatternSyntaxException – If the syntax of the regular expression is invalid.

This variant uses a default limit of 0, i.e. it splits all matches of the delimiter.

For example:

public class SplitExample {
    public static void main(String[] args) {
        // Input string
        String str = "Hello-World-Java";

        // Splitting the string using "-"
        String[] parts = str.split("-");

        // Output the resulting array
        for (String part : parts) {
            System.out.println(part);
        }
    }
}

Output:
Hello
World
Java

Examples of Using split() Method in Java

Example 1: Split with Small Limit

public class SplitExample {
  public static void main(String[] args) {
    String str = "apple#orange#banana";
    String[] fruits = str.split("#", 2); 

    for (String fruit : fruits) {
      System.out.println(fruit);
    }
  }
}

Output:
apple
orange#banana

Example 2: Split with Large Limit

public class SplitExample {
  public static void main(String[] args) {
    String str = "one-two-three-four-five";
    String[] parts = str.split("-", 10);

    for (String part : parts) {
      System.out.println(part);
    }
  }
}

Output:

one
two
three
four
five

Example 3: Split with Negative Limit

public class SplitExample {
  public static void main(String[] args) {
    String str = "a,b,c,d,e";
    String[] parts = str.split(",", -1);

    for (String part : parts) {
      System.out.println(part);
    }
  }
}

Output:
a
b
c
d
e

Example 4: Split with Regular Expression

public class SplitExample {
  public static void main(String[] args) {
    String str = "bread,milk,eggs";
    String[] items = str.split(",");

    for (String item : items) {
      System.out.println(item);
    }
  }
}

Output:
bread
milk
eggs

Example 5: Split with Regex and Negative Limit

public class SplitExample {
  public static void main(String[] args) {
    String str = "2022-11-02";
    String[] parts = str.split("-", -1);

    for (String part : parts) {
      System.out.println(part);
    }
  }
}

Output:
2022
11
02

Conclusion

In summary, Java’s split() method is a versatile tool for breaking down strings into substrings based on user-defined delimiters or regular expressions. This method encompasses two primary variants: one that allows you to specify a limit on the number of splits and the other that automatically sets the limit to 0 for maximum splitting.

By mastering these variants and exploring the examples provided, you can efficiently handle string manipulation in Java to cater to your specific processing requirements. Whether you need to split a string with a constrained limit, an extensive limit, a negative limit, or utilize regular expressions, the split() method empowers you with flexibility and adaptability in string processing.