EDUCBA

Home Software Development Software Development Tutorials Java Tutorial split() Function in Java

split() Function in Java

By Priya PedamkarPriya Pedamkar

split() Function in Java

Introduction on split() Function in Java

Java split() function is used to splitting the string into the string array based on the regular expression or the given delimiter. The resultant object is an array contains the split strings. In the resultant returned array, we can pass the limit to the number of elements.

Let’s see the example,

Start Your Free Software Development Course

Web development, programming languages, Software testing & others

  • String: [email protected]
  • Regular Expression: @
  • Result: “Java”, “SplitFunctions”

In the above example, it splits the string based on the matches of the required regular expression.

Syntax:

The syntax for the split function as follows,

public String[] split(String regex)

Here in the above signature, regex is delimiting for the regular expression. It specifies the character which is used for splitting the string. Finally, the resultant return value returns the array of string which splits the string based on the matches of the regular expression.

How does the split() Function work in Java?

In Java Split() function, we split the string using various methods; the string class makes two methods to split the strings.

Let’s see the available signatures as follows,

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

1. public String[] split(String regex)

This method splits the string by using the regular expression on the given string; the entire string splits the string, and the resultant return form as an array string. In Java 1.4, the above method is introduced. Let’s see the example for splitting the string and the corresponding resultant output,

Code:

String string_1="JavaProgram";
System.out.println(Arrays.toString(s.split("a")));

Output:

split() Function

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

This method is used when the java string must be split into a limited number of strings; for that purpose, we go for this method; let’s see the example for the string which has the string variable contains the name and address with the delimiter as a comma, the following address having the commas in it, so we go for this approach

Code:

String s = "Spencer Plaza, New York, USA";
String[] data = s.split(",", 2);
System.out.println("Name = "+data[0]); // Spencer Plaza
System.out.println("Address = "+data[1]); //New York,USA

The limit parameter is optional. An integer that indicates the number of splits and the items after the split limit will not be included in the array. Here the first method above actually makes use of the second method by passing the limit as 0.

Code:

public String[] split(String regex) {
return split(regex, 0);
}

Examples of split() Function

The examples of the following are given below:

Example #1

Code:

import java.io.*;
public class Program_1
{
public static void main(String args[]) {
String string_1 = new String("Welcome-to-JavaProgramming");
System.out.println("Output Value :" );
for (String res: string_1.split("-"))
{
System.out.println(res);
}
}
}

Output:

split() Function

Using the split() function for the string that needs to provide and divided the separator argument, we were going to use the separator as comma(,), and the return result will be the array split. The output prints each of the string called the element of an array after each split operations as shown below,

Example #2

Code:

import java.io.*;
class Program_2
{
public static void main(String []args)
{
String string_1 = "String, Functions, Split, Methods, Demo";
String[] split_array = string_1.split(", ");
for (int i=0; i < split_array.length; i++)
{
System.out.println(split_array [i]);
}
}
}

Output:

split() Function

Here, we are passing split, which limits as a second argument to this function. This limits the number of split strings.

Example #3

Code:

import java.io.*;
public class Program_3
{
public static void main(String[] args)
{
String string_1 = "JavatSplittFunction";
System.out.println("Result:");
String[] arrSplit = string_1.split("t", 0);
for (String a : arrSplit)
{
System.out.println(a);
}
System.out.println("Length of Split Array: "+ arrSplit.length);
}
}

Output:

public static void

Split() Method with the limit parameter

The Split() method with the limit parameter is used to split the strings with limited numbers. The difference between the split() and split() with the limit parameter is that it limits the number of strings returned after split-ups. In this, for the limit, we need to give an input parameter to the split() function. Let’s see the usage of the split() method with the limit parameter,

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

Here the parameter regex to delimiting the regular expression, and the limit is for the resulting threshold. The limits are of 3 values, they are:

  • limit > 0: If the limit is set as >0, the resultant array length must not greater than n, and this applied at most limit-1 times. The last entry contains input with the last matched delimiter.
  • limit < 0:If the limit is set as <0, the resultant array with any number of lengths, and we can apply the pattern with as many times as possible.
  • limit = 0: If the limit is set as equal to 0, the resulting array has any number of length, but the empty string will be discarded, and this limit is functional as many times as possible.

This parameter’s return value will be an array of string objects by splitting the given string accords to the limit parameter. The PatternSyntacException will occur if the given regular expression syntax is invalid while executing the code. Let’s see the example program for the split() method on string with the limit parameter.

Example #4

Code:

public class Program_4
{
public static void main(String args[])
{
String string_1 = "238-347-9288";
String[] stringArray = string_1.split("8",2);
System.out.println("Split() Method with the Limit Parameter");
System.out.println("\nLimit Value is +ve");
System.out.println("Sub-Strings: "+stringArray.length);
for(int i=0; i<stringArray.length; i++)
{  System.out.println("string_1["+i+"] : "+stringArray[i]);
}
String[] stringArray2 = string_1.split("8",-3);
System.out.println("Limit Value is -ve");
System.out.println("Sub-Strings: "+stringArray2.length);
for(int i=0; i<stringArray2.length; i++)
{
System.out.println("string_1["+i+"] : "+stringArray2[i]);
}
String[] stringArray3 = string_1.split("8",0);
System.out.println("Limit Value is 0");
System.out.println("Sub-Strings: "+stringArray3.length);
for(int i=0; i<stringArray3.length; i++)
{
System.out.println("string_1["+i+"] : "+stringArray3[i]);
}
}
}

Output:

System.out.print

The above program shows that the split() method works by the specified limit parameter like as seen by the output:

  1. The number of substrings in the resulting array is two when the limit is 2.
  2. If the limit is set to -3, the resultant string splits into 4 substrings, including the trailing spaces.
  3. If the limit is set to 0, here, the trailing spaces are eliminated, so the resultant input string is split into 2 substrings.

Conclusion

At the end of the ‘Split() Function in Java’ article, we learned how to split strings using the split() method in different Java approaches. I hope in this article you are understandable with all that has been shared with examples.

Recommended Articles

This is a guide to split() Function in Java. Here we discuss the introduction, How does the split() Function work in Java, along with the respective examples. You can also go through our other related articles to learn more–

  1. Regular Expressions in Java
  2. JavaScript String Length
  3. Private in Java
  4. Java Stream Filter
quiz