How to String Split Example in Java - Tutorial

String Split Example Java

Let's see an example of splitting string in Java by using split() function:

//split string example

String assetClasses = "Gold:Stocks:Fixed Income:Commodity:Interest Rates";

String[] splits = asseltClasses.split(":");

System.out.println("splits.size: " + splits.length);

for(String asset: assetClasses){

System.out.println(asset);

}

OutPut

splits.size: 5

Gold

Stocks

Fixed Income

Commodity

Interest Rates

In above example we have provided delimiter or separator as “:” to split function which expects a regular expression and used to split the string.

Now let see another example of split using StringTokenizer

//string split example StringTokenizer

 

StringTokenizer stringtokenizer = new StringTokenizer(asseltClasses, ":");

while (stringtokenizer.hasMoreElements()) {

System.out.println(stringtokenizer.nextToken());

}

OutPut

Gold

Stocks

Fixed Income

Commodity

Interest Rates

How to Split Strings in Java – 2 Example

My personal favorite is String.split () because it’s defined in String class itself and its capability to handle regular expression which gives you immense power to split the string on any delimiter you ever need. Though it’s worth to remember following points about split method in Java

1) Some special characters need to be escaped while using them as delimiters or separators e.g. "." and "|".

 

//string split on special character “|”

 

String assetTrading = "Gold Trading|Stocks Trading|Fixed Income Trading|Commodity Trading|FX trading";

String[] splits = assetTrading.split("\\|");  // two \\ is required because "\"     itself require escaping

for(String trading: splits){

System.out.println(trading);

}

OutPut:

Gold Trading

Stocks Trading

Fixed Income Trading

Commodity Trading

FX trading

// split string on “.”

String smartPhones = "Apple IPhone.HTC Evo3D.Nokia N9.LG Optimus.Sony Xperia.Samsung Charge”;

String[] smartPhonesSplits = smartPhones.split("\\.");

for(String smartPhone: smartPhonesSplits){

System.out.println(smartPhone);

}

OutPut:

Apple IPhone

HTC Evo3D

Nokia N9

LG Optimus

Sony Xperia

Samsung Charge

2) You can control number of split by using overloaded version split (regex, limit). If you give limit as 2 it will only creates two strings. For example in following example we could have total 4 splits but if we just want to create 2 we can use limit.

 

//string split example with limit

 

String places = "London.Switzerland.Europe.Australia";

String[] placeSplits = places.split("\\.",2);

 

System.out.println("placeSplits.size: " + placeSplits.length );

 

for(String contents: placeSplits){

System.out.println(contents);

}

Output:

placeSplits.size: 2

London

Switzerland.Europe.Australia

To conclude the topic StringTokenizer is old way of tokenizing string and with introduction of split since JDK 1.4 its usage is discouraged. No matter what kind of project you work you often need to split string in Java so better get familiar with these API.

The String class has a split() (since 1.4) method that will return a String array.

public class StringSplit {
  public static void main(String args[]) throws Exception{
    String testString = "Real-How-To";
    System.out.println(
        java.util.Arrays.toString(
        testString.split("-")
    ));

    // output : [Real, How, To]
    }

split() is based on regex expression, a special attention is needed with some characters which have a special meaning in a regex expression.

For example :

public class StringSplit {
  public static void main(String args[]) throws Exception{
    String testString = "Real.How.To";
    // bad
    System.out.println(java.util.Arrays.toString(
        testString.split(".")
    ));
    // output : []

    // good
    System.out.println(java.util.Arrays.toString(
      testString.split("\\.")
    ));
    // output : [Real, How, To]
  }
}

And

public class StringSplit {
  public static void main(String args[]) throws Exception{
    String testString = "Real|How|To";
    // bad
    System.out.println(java.util.Arrays.toString(
        testString.split("|")
    ));
    // output : [, R, e, a, l, |, H, o, w, |, T, o]

    // good
    System.out.println(java.util.Arrays.toString(
      testString.split("\\|")
    ));
    // output : [Real, How, To]
  }
}

The special character needs to be escaped with a "\" but since "\" is also a special character in Java, you need to escape it again with another "\" !

---

Consider this example

public class StringSplit {
  public static void main(String args[]) throws Exception{
    String testString = "Real|How|To|||";
    System.out.println(
        java.util.Arrays.toString(
        testString.split("\\|")
    ));

    // output : [Real, How, To]
    }
}

The result does not include the empty strings between the "|" separator. To keep the empty strings :

public class StringSplit {
  public static void main(String args[]) throws Exception{
    String testString = "Real|How|To|||";
    System.out.println(
        java.util.Arrays.toString(
        testString.split("\\|", -1)
    ));

    // output : [Real, How, To, , , ]
    }
}

See split(String.int).

String.split() is only available since JDK 1.4.With previous version, java.util.StringTokeniser can be used.See this HowTo

---

Some notes from A. Gonzales about String.split()

Special cases using String.split():

public class StringSplit {
  public static void main(String args[]) throws Exception{
    System.out.println(
        java.util.Arrays.toString(
        "  s".split(" ")
    ));
    // output : [, , s]

    System.out.println(
        java.util.Arrays.toString(
        "".split("")
    ));
    // output : []

    System.out.println(
        java.util.Arrays.toString(
        "  ".split(" ")
    ));
    // output : []

    System.out.println(
        java.util.Arrays.toString(
        "      ".split(" ")
    ));
    // output : []

    System.out.println(
        java.util.Arrays.toString(
        " s ".split(" ")
    ));
    // output : [, s]
    }
}

---

It's important to note that an invocation like:

param = req.getParam(...);
String[] words = param.split(" ");
String firstWord = words[0];

will generate a NullPointerException if param.equals(" ").

---

Using split() with a space can be a problem. Consider the following :

public class StringSplit {
  public static void main(String args[]) throws Exception{
    String testString = "Real  How To";  // extra space

    System.out.println(
        java.util.Arrays.toString(
        testString.split(" ")
    ));
    // output : [Real, , How, To]
    }
}

We have an extra element. The fix is to specify a regular expression to match one or more spaces.

public class StringSplit {
  public static void main(String args[]) throws Exception{
    String testString = "Real  How To";

    System.out.println(
        java.util.Arrays.toString(
        testString.split("\\s+")
    ));
    // output : [Real, How, To]
    }
}

---

Since String.split() is based on regular expression, you can make some complex operations with a simple call!

    String testString = "{RealHowto}{java-0438.html}{usage of String.split()}";
    System.out.println(java.util.Arrays.toString(
        testString.split("[{}]")
    ));

    // output : [, RealHowto, , java-0438.html, , usage of String.split()]
    // note : extra empty elements :-(

---

To split a long string into into fixed-length parts. In this example, we split in groups of 3 characters :

    String testString = "012345678901234567890";
    System.out.println(java.util.Arrays.toString(
        testString.split("(?<=\\G.{3})")
    ));

    // output : [012, 345, 678, 901, 234, 567, 890]

---

To split but keep the separator :

   String testString = "RealHowto!java-0438.html!usage of String.split()!";
    System.out.println(java.util.Arrays.toString(
        testString.split("(?<=[!])")
    ));    // output : [RealHowto!, java-0438.html!, usage of String.split()!]
  }