How to Split a String in Java Using a Delimiter

By the end of this page, you will understand how to split a string in Java using a delimiter, how String.split() works, how to check whether a delimiter exists with contains() or indexOf(), and how to safely handle cases where the delimiter is missing or appears multiple times.

In Java, strings are instances of the String class, which provides built-in methods for searching and dividing text.

The main method used to split text is:

split()

It breaks a string into smaller pieces based on a separator, also called a delimiter.

For example:

String value = "004-034556";
String[] parts = value.split("-");

This produces an array containing:

• parts[0] → "004"
• parts[1] → "034556"

This matters because splitting strings is very common in real programs. Developers use it when working with:

• CSV data
• IDs like user-123
• file paths
• API responses
• configuration values
• logs and structured text

A related concept is checking whether the delimiter exists before splitting. In Java, you can do that with:

value.contains("-")

or:

Think of a string like a sentence written on a strip of paper, and the delimiter is a cut mark.

If the paper looks like this:

004-034556

then - is the place where you cut it into pieces:

• left side: 004
• right side: 034556

Before cutting, you may want to check whether the cut mark exists at all. If there is no -, there is nothing to split.

So the process is:

1. Look for the cut mark.
2. If it exists, split the text.
3. Read the pieces from the result array.

Basic syntax

String[] parts = text.split("-");

• text is the original string
• "-" is the delimiter
• the result is a String[] array

Example: split into two parts

String value = "004-034556";
String[] parts = value.split("-");

String part1 = parts[0];
String part2 = parts[1];

System.out.println(part1); // 004
System.out.println(part2); // 034556

This works because the string contains one -, so the split produces exactly two parts.

Example: check before splitting

String value = "004-034556";

if (value.contains("-")) {
    String[] parts = value.split();
    System.out.println( + parts[]);
    System.out.println( + parts[]);
}  {
    System.out.println();
}

Consider this code:

String value = "004-034556";

if (value.contains("-")) {
    String[] parts = value.split("-");
    String part1 = parts[0];
    String part2 = parts[1];

    System.out.println(part1);
    System.out.println(part2);
}

Step-by-step

1. value is assigned the text "004-034556".
2. value.contains("-") checks whether - exists in the string.
3. Since - is present, the if block runs.
4. value.split("-") cuts the string at the dash.
5. Java creates a String[] array with two values:
   • index 0 = "004"
   • index 1 =

Splitting strings by delimiters appears everywhere in Java programs.

Common examples

• User input parsing

  • Input like name:John can be split into key and value.

• Product or account codes

  • 004-034556 can be split into a category code and item number.

• CSV and text file processing

  • A line like Alice,24,London can be split by ,.

• Log processing

  • A log entry like ERROR|Database unavailable can be split into level and message.

• Configuration strings

  • A value like host=localhost can be split into setting name and setting value.

• URL or route parsing

  • Paths or slugs often need to be divided into segments.

In all of these cases, checking whether the delimiter exists first helps make the code more reliable.

In real projects, developers usually do more than just call split().

Common patterns

Guard clause before splitting

if (!value.contains("-")) {
    return;
}

This exits early if the input is not in the expected format.

Validation before using array indexes

String[] parts = value.split("-");
if (parts.length == 2) {
    String left = parts[0];
    String right = parts[1];
}

This prevents ArrayIndexOutOfBoundsException.

Split only once for structured values

String[] parts = value.split("-", 2);

This is common when the second part may contain the delimiter again.

Trimming spaces after splitting

String   ;
String[] parts = value.split();
   parts[].trim();
   parts[].trim();

1. Assuming the delimiter always exists

Broken code:

String value = "004034556";
String[] parts = value.split("-");
String part2 = parts[1];

Problem:

• If there is no -, parts will only have one element.
• Accessing parts[1] throws ArrayIndexOutOfBoundsException.

Fix:

if (value.contains("-")) {
    String[] parts = value.split("-");
    if (parts.length >= 2) {
        String part2 = parts[1];
    }
}

2. Forgetting that split() returns an array

Broken code:

String part  value.split();

split() vs indexOf() + substring()

contains() vs indexOf()

Quick reference

Check if delimiter exists

value.contains("-")

or

value.indexOf('-') != -1

Split by delimiter

String[] parts = value.split("-");

Access parts

String part1 = parts[0];
String part2 = parts[1];

Safer version

if (value.contains("-")) {
    String[] parts = value.split("-");
    if (parts.length >= 2) {
        String part1 = parts[0];
        String part2 = parts[1];
    }
}

Split only once

How do I split a string by - in Java?

Use split("-"):

String[] parts = value.split("-");

How can I check if a string contains a dash in Java?

Use either:

value.contains("-")

or:

value.indexOf('-') != -1

What happens if split() does not find the delimiter?

It returns an array with one element: the original string.

Why does split() return an array?

Because a string may be split into many parts, not just two.

Should I use split() or substring() in Java?

Use split() for simple delimiter-based splitting. Use indexOf() and substring() when you want precise control over one split point.

Can I split a string into only two parts?

• String.contains() — useful for checking whether a delimiter exists before splitting.
• String.indexOf() — helps find the position of a character or substring.
• String.substring() — useful for manually extracting text before or after a delimiter.
• String.trim() — removes unwanted spaces after splitting.
• Arrays in Java — split() returns an array, so you need to understand indexing.
• Regular expressions in Java — important because split() uses regex patterns.
• Input validation — helps ensure strings match the expected format before processing.