split()-Funktion in Java

Die Java-Split()-Funktion wird verwendet, um die Zeichenfolge basierend auf dem regulären Ausdruck oder dem angegebenen Trennzeichen in das Zeichenfolgenarray aufzuteilen. Das resultierende Objekt ist ein Array, das die geteilten Zeichenfolgen enthält. Im resultierenden zurückgegebenen Array können wir die Begrenzung der Anzahl der Elemente übergeben.

Sehen wir uns das Beispiel an

• String: Java@SplitFunctions
• Regulärer Ausdruck: @
• Ergebnis: „Java“, „SplitFunctions“

Das obige Beispiel teilt die Zeichenfolge basierend auf den Übereinstimmungen des erforderlichen regulären Ausdrucks auf.

Syntax:

Die Syntax für die Split-Funktion lautet wie folgt:

public String[] split(String regex)

Hier in der obigen Signatur begrenzt Regex den regulären Ausdruck. Es gibt das Zeichen an, das zum Teilen der Zeichenfolge verwendet wird. Schließlich gibt der resultierende Rückgabewert das String-Array zurück, das den String basierend auf den Übereinstimmungen des regulären Ausdrucks aufteilt.

Wie funktioniert die Funktion split() in Java?

In der Java Split()-Funktion teilen wir die Zeichenfolge mit verschiedenen Methoden; Die String-Klasse erstellt zwei Methoden zum Teilen der Strings.

Sehen wir uns die verfügbaren Signaturen wie folgt an:

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

1. public String[] split(String regex)

Diese Methode teilt die Zeichenfolge mithilfe des regulären Ausdrucks für die angegebene Zeichenfolge auf. Die gesamte Zeichenfolge wird in die Zeichenfolge aufgeteilt und das Ergebnis wird als Array-Zeichenfolge zurückgegeben. In Java 1.4 wird die obige Methode eingeführt. Sehen wir uns das Beispiel für die Aufteilung der Zeichenfolge und die entsprechende resultierende Ausgabe an,

Code:

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

Ausgabe:

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

Wir verwenden diese Methode, wenn wir einen Java-String in eine begrenzte Anzahl von Strings aufteilen müssen; Zu diesem Zweck wählen wir diese Methode. Sehen wir uns das Beispiel für die Zeichenfolge an, bei der die Zeichenfolgenvariable den Namen und die Adresse mit dem Trennzeichen als Komma enthält, wobei die folgende Adresse die Kommas enthält, also wählen wir diesen Ansatz.

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

Der Grenzwertparameter ist optional. Eine Ganzzahl, die die Anzahl der Teilungen angibt, und die Elemente nach dem Teilungslimit werden nicht in das Array aufgenommen. Die erste Methode oben verwendet die zweite Methode, indem sie den Grenzwert als 0 übergibt.

Code:

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

Beispiele für die Funktion „split()“

Beispiele für Folgendes sind unten aufgeführt:

Beispiel #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);
}
}
}

Ausgabe:

Mit der Funktion „split()“ für die Zeichenfolge, die das Trennzeichenargument bereitstellen und teilen muss, wollten wir das Trennzeichen als Komma(,) verwenden und das Rückgabeergebnis wird die Array-Splittung sein. Die Ausgabe gibt nach jedem Teilungsvorgang jede der Zeichenfolgen aus, die als Element eines Arrays bezeichnet werden, wie unten gezeigt,

Beispiel #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]);
}
}
}

Ausgabe:

Hier übergeben wir Split, das als zweites Argument diese Funktion einschränkt. Dadurch wird die Anzahl der geteilten Zeichenfolgen begrenzt.

Beispiel #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);
}
}

Ausgabe:

Split()-Methode mit dem Limit-Parameter

Die Split()-Methode mit dem limit-Parameter teilt die Zeichenfolgen mit begrenzter Anzahl. Der Unterschied zwischen split() und split() mit dem limit-Parameter besteht darin, dass er die Anzahl der nach Aufteilungen zurückgegebenen Zeichenfolgen begrenzt. Für den Grenzwert müssen wir der Funktion split() einen Eingabeparameter übergeben. Sehen wir uns die Verwendung der Methode split() mit dem Parameter limit an,

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

Hier begrenzt der Parameter Regex den regulären Ausdruck und die Grenze gilt für den resultierenden Schwellenwert. Die Grenzwerte bestehen aus 3 Werten:

• 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]);
}
}
}

Nach dem Login kopieren

Output:



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

1. The number of substrings in the resulting array is two when the limit is 2.
2. Setting the limit to -3 causes the string to split into 4 substrings, including the trailing spaces.
3. 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.

Das obige ist der detaillierte Inhalt vonsplit()-Funktion in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!