Updated July 28, 2023
Introduction to 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 containing the split strings. In the resultant returned array, we can pass the limit to the number of elements.
Let’s see the example,
- String: Java@SplitFunctions
- Regular Expression: @
- Result: “Java,” “SplitFunctions”
The above example splits the string based on the matches of the required regular expression.
Syntax:
The syntax for the split function is 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 strings 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 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:
2. public String[] split(String regex, int limit)
We use this method when we need to split a Java string 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 containing 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,USAThe 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. The first method above uses the second method by passing the limit as 0.
Code:
public String[] split(String regex) {
return split(regex, 0);
}Examples of split() Function
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:
Using the split() function for the string that needs to provide and divide the separator argument, we were going to use the separator as a comma(,), and the return result will be the array split. The output prints each of the strings called the element of an array after each split operation, 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:
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:
Split() Method with the limit parameter
The Split() method with the limit parameter splits 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. 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 delimits 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 be more significant than n, which is 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 can apply the pattern as many times as possible.
- limit = 0: If the limit is set as equal to 0, the resulting array has any number of lengths, 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 a 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:
The above program shows that the split() method works by the specified limit parameter, as seen by the output:
- The number of substrings in the resulting array is two when the limit is 2.
- Setting the limit to -3 causes the string to split into 4 substrings, including the trailing spaces.
- If you set the limit to 0, it eliminates the trailing spaces. As a result, the input string splits 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 understand everything 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–
