By riyana

2010-08-14 03:01:53 8 Comments

I have a string, "004-034556", that I want to split into two strings:


That means the first string will contain the characters before '-', and the second string will contain the characters after '-'. I also want to check if the string has '-' in it. If not, I will throw an exception. How can I do this?


@Jamith Nimantha 2018-12-07 08:48:00

you can use the method split

public class Demo {
    public static void main(String args[]){
        String str ="004-034556";
            String[] temp=str.split("-");
            for(String part:temp){
            System.out.println(str+" does not contain \"-\".");


@rghome 2018-11-20 12:08:47

There are only two methods you really need to consider.

Use String.split if a one character delimeter or you don't care about performance

If performance is not an issue, or if the delimeter is a single character that is not a regular expression special character (i.e., not one of .$|()[{^?*+\) then you can use String.split.

String[] results = input.split(",");

The split method has an optimization to avoid using a regular expression if the delimeter is a single character and not in the above list. Otherwise, it has to compile a regular expression and this is not ideal.

Use Pattern.split and precompile the pattern if using a complex delimeter and you care about performance

If performance is an issue and your delimeter is not one of the above, you should pre-compile a regular expression pattern which you can then re-use.

// Save this somewhere
Pattern pattern = Pattern.compile("[,;:]");

/// ... later
String[] results = pattern.split(input);

This last option still creates a new Matcher object. You can also cache this object and reset it for each input for maximum performance, but that is somewhat more complicated and not thread-safe.

@KIBOU Hassan 2018-03-08 14:28:00

To split a string, uses String.split(regex). Review the following examples :

String data = "004-034556";
String[] output = data.split("-");



Note This split (regex) takes a regex as an argument, remember to escape the regex special characters, like period/dot.

@Vitalii Fedorenko 2015-05-13 13:38:57

For simple use cases String.split() should do the job. If you use guava, there is also a Splitter class which allows chaining of different string operations and supports CharMatcher:


@None 2018-01-10 06:28:08

I just wanted to write an algorithm instead of using Java built-in functions:

public static List<String> split(String str, char c){
    List<String> list = new ArrayList<>();
    StringBuilder sb = new StringBuilder();

    for (int i = 0; i < str.length(); i++){
        if(str.charAt(i) != c){
            if(sb.length() > 0){
                sb = new StringBuilder();

    if(sb.length() >0){
    return list;

@Dmytro Shvechikov 2017-12-13 14:20:01

To summarize: there are at least five ways to split a string in Java:

  1. String.split():

    String[] parts ="10,20".split(",");
  2. Pattern.compile(regexp).splitAsStream(input):

    List<String> strings = Pattern.compile("\\|")
  3. StringTokenizer (legacy class):

    StringTokenizer strings = new StringTokenizer("Welcome to EXPLAINJAVA.COM!", ".");
        String substring = strings.nextToken();
  4. Google Guava Splitter:

    Iterable<String> result = Splitter.on(",").split("1,2,3,4");
  5. Apache Commons StringUtils:

    String[] strings = StringUtils.split("1,2,3,4", ",");

So you can choose the best option for you depending on what you need, e.g. return type (array, list, or iterable).

Here is a big overview of these methods and the most common examples (how to split by dot, slash, question mark, etc.)

@Aditya Singh 2017-09-22 17:27:45

 String string = "004^034556-34";
 String[] parts = string.split(Pattern.quote("^"));

If you have a special character then you can use Patter.quote. If you simply have dash (-) then you can shorten the code:

 String string = "004-34";
 String[] parts = string.split("-");

If you try to add other special character in place of dash (^) then the error will generate ArrayIndexOutOfBoundsException. For that you have to use Pattern.quote.

@james.garriss 2017-10-30 16:54:58

Please don't post answers that simply repeat existing answers.

@user7973776 2017-05-14 12:12:42

From the documentation:

public String[] split(String regex,int limit) Splits this string around matches of the given regular expression. The array returned by this method contains each substring of this string that is terminated by another substring that matches the given expression or is terminated by the end of the string. The substrings in the array are in the order in which they occur in this string. If the expression does not match any part of the input then the resulting array has just one element, namely this string.

Basically you can do something like this:

String s = "123-456-789-123"; // The String to be split
String[] array = s.split("-"); // Split according to the hyphen and put them in an array
for(String subString : array){ // Cycle through the array



@Rohit-Pandey 2017-04-17 03:53:52

You can simply use StringTokenizer to split a string in two or more parts whether there are any type of delimiters:

StringTokenizer st = new StringTokenizer("004-034556", "-");

@KIBOU Hassan 2017-04-07 21:57:09

To split a string, use String.split(regex):

String phone = "004-034556";
String[] output = phone.split("-");



@Akshay Gaikwad 2017-03-03 09:39:15

Here are two ways two achieve it.

WAY 1: As you have to split two numbers by a special character you can use regex

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class TrialClass
    public static void main(String[] args)
        Pattern p = Pattern.compile("[0-9]+");
        Matcher m = p.matcher("004-034556");


WAY 2: Using the string split method

public class TrialClass
    public static void main(String[] args)
        String temp = "004-034556";
        String [] arrString = temp.split("-");
        for(String splitString:arrString)

@Akshay Gaikwad 2019-02-07 09:09:22

Thanks Peter for editing it in right manner

@Sarat Chandra 2017-01-09 17:28:01

You can use Split():


public class Splitting

    public static void main(String args[])
        String Str = new String("004-034556");
        String[] SplittoArray = Str.split("-");
        String string1 = SplittoArray[0];
        String string2 = SplittoArray[1];

Else, you can use StringTokenizer:

import java.util.*;
public class Splitting
    public static void main(String[] args)
        StringTokenizer Str = new StringTokenizer("004-034556");
        String string1 = Str.nextToken("-");
        String string2 = Str.nextToken("-");

@Akhilesh Dhar Dubey 2014-03-15 18:17:18

public class SplitTest {

    public static String[] split(String text, String delimiter) {
        java.util.List<String> parts = new java.util.ArrayList<String>();

        text += delimiter;

        for (int i = text.indexOf(delimiter), j=0; i != -1;) {
            String temp = text.substring(j,i);
            if(temp.trim().length() != 0) {
            j = i + delimiter.length();
            i = text.indexOf(delimiter,j);

        return parts.toArray(new String[0]);

    public static void main(String[] args) {
        String str = "004-034556";
        String delimiter = "-";
        String result[] = split(str, delimiter);
        for(String s:result)

@BalusC 2010-08-14 03:05:34

Just use the appropriate method: String#split().

String string = "004-034556";
String[] parts = string.split("-");
String part1 = parts[0]; // 004
String part2 = parts[1]; // 034556

Note that this takes a regular expression, so remember to escape special characters if necessary.

there are 12 characters with special meanings: the backslash \, the caret ^, the dollar sign $, the period or dot ., the vertical bar or pipe symbol |, the question mark ?, the asterisk or star *, the plus sign +, the opening parenthesis (, the closing parenthesis ), and the opening square bracket [, the opening curly brace {, These special characters are often called "metacharacters".

So, if you want to split on e.g. period/dot . which means "any character" in regex, use either backslash \ to escape the individual special character like so split("\\."), or use character class [] to represent literal character(s) like so split("[.]"), or use Pattern#quote() to escape the entire string like so split(Pattern.quote(".")).

String[] parts = string.split(Pattern.quote(".")); // Split on period.

To test beforehand if the string contains certain character(s), just use String#contains().

if (string.contains("-")) {
    // Split it.
} else {
    throw new IllegalArgumentException("String " + string + " does not contain -");

Note, this does not take a regular expression. For that, use String#matches() instead.

If you'd like to retain the split character in the resulting parts, then make use of positive lookaround. In case you want to have the split character to end up in left hand side, use positive lookbehind by prefixing ?<= group on the pattern.

String string = "004-034556";
String[] parts = string.split("(?<=-)");
String part1 = parts[0]; // 004-
String part2 = parts[1]; // 034556

In case you want to have the split character to end up in right hand side, use positive lookahead by prefixing ?= group on the pattern.

String string = "004-034556";
String[] parts = string.split("(?=-)");
String part1 = parts[0]; // 004
String part2 = parts[1]; // -034556

If you'd like to limit the number of resulting parts, then you can supply the desired number as 2nd argument of split() method.

String string = "004-034556-42";
String[] parts = string.split("-", 2);
String part1 = parts[0]; // 004
String part2 = parts[1]; // 034556-42

@Crowie 2013-08-01 08:56:08

Why do you use hash symbols to delimit String's methods?

@BalusC 2013-08-01 12:04:18

@Crowie: javadoc-style.

@klimat 2016-05-23 12:36:35

Corner case: if it cannot find reugalr expression it returns one element array with whole string.

@Alberto Acuña 2018-08-28 10:05:19

@BalusC what about go back?, join? thanks

@BalusC 2018-08-28 11:09:28

@AlbertoAcuña, yes indeed, just use join method.

@KYHSGeekCode 2018-10-30 15:21:36

You saved my time, I forgot to quote the dot(.)!

@David 2019-01-17 23:38:57

Cann't believe the most voted version is like this. 1) part2 is not what the poster want if the original string contains two "-" 2) No error handling as mentioned in the question. 3) Low efficienty. A single character search needs regular expression construction and matching. Extra array created, etc.

@BalusC 2019-01-18 09:11:28

@David: 1) That's not covered in the question. 2) It doesn't throw exceptions. 3) OP asks how to split, not how to substring. 4) Take a break, breathe deeply and trash all the negativeness in your head :)

@Rob Hague 2010-08-14 11:28:39

An alternative to processing the string directly would be to use a regular expression with capturing groups. This has the advantage that it makes it straightforward to imply more sophisticated constraints on the input. For example, the following splits the string into two parts, and ensures that both consist only of digits:

import java.util.regex.Pattern;
import java.util.regex.Matcher;

class SplitExample
    private static Pattern twopart = Pattern.compile("(\\d+)-(\\d+)");

    public static void checkString(String s)
        Matcher m = twopart.matcher(s);
        if (m.matches()) {
            System.out.println(s + " matches; first part is " + +
                               ", second part is " + + ".");
        } else {
            System.out.println(s + " does not match.");

    public static void main(String[] args) {

As the pattern is fixed in this instance, it can be compiled in advance and stored as a static member (initialised at class load time in the example). The regular expression is:


The parentheses denote the capturing groups; the string that matched that part of the regexp can be accessed by the method, as shown. The \d matches and single decimal digit, and the + means "match one or more of the previous expression). The - has no special meaning, so just matches that character in the input. Note that you need to double-escape the backslashes when writing this as a Java string. Some other examples:

([A-Z]+)-([A-Z]+)          // Each part consists of only capital letters 
([^-]+)-([^-]+)            // Each part consists of characters other than -
([A-Z]{2})-(\d+)           // The first part is exactly two capital letters,
                           // the second consists of digits

@ptstone 2017-07-13 04:28:03

This is a great solution, however the first part should be, the second part, since actually returns the full matching pattern. I think i also remember group(0) used to be the first match instead of the full pattern, maybe this changed in a recent java version update.

@Rob Hague 2017-07-17 16:09:05

Thanks. Looking at…, you're right — in line with most other regexp libraries, group 0 is the full match, and the captured groups start at 1. As you say, I suspect that this may have changed since I originally wrote the answer, but in any case I'll update it to reflect current behaviour.

@Somaiah Kumbera 2016-12-01 09:32:05

With Java 8:

    List<String> stringList = Pattern.compile("-")

    stringList.forEach(s -> System.out.println(s));

@Roland 2017-03-10 15:11:32

If you want to remove whitespace add .map(String::trim) after the split

@SAM Jr 2017-02-24 10:12:25

String s="004-034556";
for(int i=0;i<s.length();i++)

As mentioned by everyone, split() is the best option which may be used in your case. An alternative method can be using substring().

@Shivanandam 2016-11-20 04:43:14

String str="004-034556"
String[] sTemp=str.split("-");// '-' is a delimiter

string1=004 // sTemp[0];

@Ravi Pandey 2016-10-02 03:31:26


public class BreakString {

  public static void main(String args[]) {

    String string = "004-034556-1234-2341";
    String[] parts = string.split("-");

    for(int i=0;i<parts.length;i++) {

@Sombriks 2016-10-02 03:51:30

if i may share advice, how your answer brings more value than the already accepted solution? on such situations you may cast vote on the existing solution, specially if this is a clear trivial case like that one.

@Divyesh Kanzariya 2016-05-09 13:36:05

Check out the split() method in the String class on javadoc.

String data = "004-034556-1212-232-232";
int cnt = 1;
for (String item : data.split("-")) {
        System.out.println("string "+cnt+" = "+item);

Here many examples for split string but I little code optimized.

@i_am_zero 2016-05-18 05:17:37

Please don't use StringTokenizer class as it is a legacy class that is retained for compatibility reasons, and its use is discouraged in new code. And we can make use of the split method as suggested by others as well.

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

And as expected it will print:

[004, 034556]

In this answer I also want to point out one change that has taken place for split method in Java 8. The String#split() method makes use of Pattern.split, and now it will remove empty strings at the start of the result array. Notice this change in documentation for Java 8:

When there is a positive-width match at the beginning of the input sequence then an empty leading substring is included at the beginning of the resulting array. A zero-width match at the beginning however never produces such empty leading substring.

It means for the following example:

String[] sampleTokensAgain = "004".split("");

we will get three strings: [0, 0, 4] and not four as was the case in Java 7 and before. Also check this similar question.

@Ravindra babu 2015-12-02 11:07:20

String Split with multiple characters using Regex

public class StringSplitTest {
     public static void main(String args[]) {
        String s = " ;String; String; String; String, String; String;;String;String; String; String; ;String;String;String;String";
        //String[] strs = s.split("[,\\s\\;]");
        String[] strs = s.split("[,\\;]");
        System.out.println("Substrings length:"+strs.length);
        for (int i=0; i < strs.length; i++) {


Substrings length:17
Str[2]: String
Str[3]: String
Str[4]: String
Str[5]: String
Str[6]: String
Str[10]: String
Str[11]: String

But do not expect the same output across all JDK versions. I have seen one bug which exists in some JDK versions where the first null string has been ignored. This bug is not present in the latest JDK version, but it exists in some versions between JDK 1.7 late versions and 1.8 early versions.

@jjnguy 2010-08-14 03:06:09

String[] result = yourString.split("-");
if (result.length != 2) 
     throw new IllegalArgumentException("String not in correct format");

This will split your string into 2 parts. The first element in the array will be the part containing the stuff before the -, and the 2nd element in the array will contain the part of your string after the -.

If the array length is not 2, then the string was not in the format: string-string.

Check out the split() method in the String class.

@Michael Konietzka 2010-08-14 06:36:31

This will accept "-555" as input and returns [, 555]. The requirements aren't defined that clear, if it would be valid to accept this. I recommend writing some unit-tests to define the desired behaviour.

@Uncle Iroh 2014-02-10 16:53:31

Probly safest to change (result.length != 2) to (result.length < 2)

@Keshav Pradeep Ramanath 2015-10-04 18:24:32

One way to do this is to run through the String in a for-each loop and use the required split character.

public class StringSplitTest {

    public static void main(String[] arg){
        String str = "004-034556";
        String split[] = str.split("-");
        System.out.println("The split parts of the String are");
        for(String s:split)


The split parts of the String are:

@sandeep vanama 2014-07-01 04:35:19

Use org.apache.commons.lang.StringUtils' split method which can split strings based on the character or string you want to split.

Method signature:

public static String[] split(String str, char separatorChar);

In your case, you want to split a string when there is a "-".

You can simply do as follows:

String str = "004-034556";

String split[] = StringUtils.split(str,"-");



Assume that if - does not exists in your string, it returns the given string, and you will not get any exception.

@user2045376 2013-02-07 05:24:11

Sometimes if you want to split string containing + then it won't split; instead you will get a runtime error. In that case, first replace + to _ and then split:

 this.text=text.replace("/", "_");
            String temp[]=text.split("_");

@Max 2013-03-27 16:49:33

This is because the argument to split is a regular expression. A better solution is to correctly escape the regular expression.

@Michael Konietzka 2010-08-14 06:57:10

The requirements left room for interpretation. I recommend writing a method,

public final static String[] mySplit(final String s)

which encapsulate this function. Of course you can use String.split(..) as mentioned in the other answers for the implementation.

You should write some unit-tests for input strings and the desired results and behaviour.

Good test candidates should include:

 - "0022-3333"
 - "-"
 - "5555-"
 - "-333"
 - "3344-"
 - "--"
 - ""
 - "553535"
 - "333-333-33"
 - "222--222"
 - "222--"
 - "--4555"

With defining the according test results, you can specify the behaviour.

For example, if "-333" should return in [,333] or if it is an error. Can "333-333-33" be separated in [333,333-33] or [333-333,33] or is it an error? And so on.

@Chris Mountford 2014-08-24 22:43:32

Useful advice, but not actually an answer to the question. If you're supporting another answer's with detail a comment is preferred.

@Ryan Augustine 2018-09-20 11:02:04

Use : split ( String regex, int limit ) and NOT split( String regex) for reference visit

@RajeshVijayakumar 2014-09-01 13:39:36

You can split a string by a line break by using the following statement:

String textStr[] = yourString.split("\\r?\\n");

You can split a string by a hyphen/character by using the following statement:

String textStr[] = yourString.split("-");

@Mnyikka 2012-11-16 06:30:54

// This leaves the regexes issue out of question
// But we must remember that each character in the Delimiter String is treated
// like a single delimiter        

public static String[] SplitUsingTokenizer(String subject, String delimiters) {
   StringTokenizer strTkn = new StringTokenizer(subject, delimiters);
   ArrayList<String> arrLis = new ArrayList<String>(subject.length());


   return arrLis.toArray(new String[0]);

@bvdb 2013-09-09 07:07:11

The JavaDoc clearly states: "StringTokenizer is a legacy class that is retained for compatibility reasons although its use is discouraged in new code. It is recommended that anyone seeking this functionality use the split method of String or the java.util.regex package instead."

@eis 2014-03-25 06:43:17

Assuming, that

  • you don't really need regular expressions for your split
  • you happen to already use apache commons lang in your app

The easiest way is to use StringUtils#split(java.lang.String, char). That's more convenient than the one provided by Java out of the box if you don't need regular expressions. Like its manual says, it works like this:

A null input String returns null.

 StringUtils.split(null, *)         = null
 StringUtils.split("", *)           = []
 StringUtils.split("a.b.c", '.')    = ["a", "b", "c"]
 StringUtils.split("a..b.c", '.')   = ["a", "b", "c"]
 StringUtils.split("a:b:c", '.')    = ["a:b:c"]
 StringUtils.split("a b c", ' ')    = ["a", "b", "c"]

I would recommend using commong-lang, since usually it contains a lot of stuff that's usable. However, if you don't need it for anything else than doing a split, then implementing yourself or escaping the regex is a better option.

Related Questions

Sponsored Content

36 Answered Questions

[SOLVED] How do I check if a string contains a specific word?

59 Answered Questions

[SOLVED] How do I read / convert an InputStream into a String in Java?

43 Answered Questions

[SOLVED] How do I convert a String to an int in Java?

81 Answered Questions

[SOLVED] How do I make the first letter of a string uppercase in JavaScript?

78 Answered Questions

[SOLVED] Is Java "pass-by-reference" or "pass-by-value"?

47 Answered Questions

19 Answered Questions

[SOLVED] Why is char[] preferred over String for passwords?

17 Answered Questions

[SOLVED] Does Python have a string 'contains' substring method?

57 Answered Questions

[SOLVED] What is the difference between String and string in C#?

31 Answered Questions

[SOLVED] endsWith in JavaScript

Sponsored Content