split() Fungsi dalam Java

Fungsi Java split() digunakan untuk memisahkan rentetan ke dalam tatasusunan rentetan berdasarkan ungkapan biasa atau pembatas yang diberikan. Objek terhasil ialah tatasusunan yang mengandungi rentetan berpecah. Dalam tatasusunan terhasil yang dikembalikan, kita boleh melepasi had kepada bilangan elemen.

IKLAN Kursus Popular dalam kategori ini JAVA MASTERY - Pengkhususan | 78 Siri Kursus | 15 Ujian Olok-olok

Mari kita lihat contoh,

• String: Java@SplitFunctions
• Ungkapan Biasa: @
• Hasil: “Java,” “SplitFunctions”

Contoh di atas membahagikan rentetan berdasarkan padanan ungkapan biasa yang diperlukan.

Sintaks:

Sintaks untuk fungsi split adalah seperti berikut,

public String[] split(String regex)

Di sini dalam tandatangan di atas, regex mengehadkan ungkapan biasa. Ia menentukan watak yang digunakan untuk membelah rentetan. Akhir sekali, nilai pulangan yang terhasil mengembalikan tatasusunan rentetan yang memisahkan rentetan berdasarkan padanan ungkapan biasa.

Bagaimanakah Fungsi split() berfungsi dalam Java?

Dalam fungsi Java Split(), kami membahagi rentetan menggunakan pelbagai kaedah; kelas rentetan membuat dua kaedah untuk membelah rentetan.

Mari lihat tandatangan yang tersedia seperti berikut,

• Rentetan awam[] pemisahan(regeks rentetan, had int)
• Rentetan awam[] pemisahan(regex rentetan)

1. awam String[] split(String regex)

Kaedah ini membelah rentetan menggunakan ungkapan biasa pada rentetan yang diberikan; keseluruhan rentetan membelah rentetan, dan bentuk pulangan yang terhasil sebagai rentetan tatasusunan. Dalam Java 1.4, kaedah di atas diperkenalkan. Mari lihat contoh untuk membelah rentetan dan output terhasil yang sepadan,

Kod:

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

Output:

2. rentetan awam[] pemisahan(regeks rentetan, had int)

Kami menggunakan kaedah ini apabila kami perlu memisahkan rentetan Java kepada bilangan rentetan yang terhad; untuk tujuan itu, kami pergi untuk kaedah ini; mari lihat contoh untuk rentetan yang mempunyai pembolehubah rentetan yang mengandungi nama dan alamat dengan pembatas sebagai koma, alamat berikut mempunyai koma di dalamnya, jadi kita pergi ke pendekatan ini.

Kod:

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

Parameter had adalah pilihan. Integer yang menunjukkan bilangan pemisahan dan item selepas had pemisahan tidak akan disertakan dalam tatasusunan. Kaedah pertama di atas menggunakan kaedah kedua dengan melepasi had sebagai 0.

Kod:

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

Contoh fungsi split()

Contoh yang berikut diberikan di bawah:

Contoh #1

Kod:

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:

Menggunakan fungsi split() untuk rentetan yang perlu menyediakan dan membahagikan hujah pemisah, kami akan menggunakan pemisah sebagai koma(,), dan hasil pulangan ialah pemisahan tatasusunan. Output mencetak setiap rentetan yang dipanggil elemen tatasusunan selepas setiap operasi pisah, seperti ditunjukkan di bawah,

Contoh #2

Kod:

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:

Di sini, kami meneruskan perpecahan, yang mengehadkan sebagai hujah kedua untuk fungsi ini. Ini mengehadkan bilangan rentetan belah.

Contoh #3

Kod:

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:

Kaedah Split() dengan parameter had

Kaedah Split() dengan parameter had memisahkan rentetan dengan nombor terhad. Perbezaan antara split() dan split() dengan parameter had ialah ia mengehadkan bilangan rentetan yang dikembalikan selepas pemisahan. Untuk had, kita perlu memberikan parameter input kepada fungsi split(). Mari lihat penggunaan kaedah split() dengan parameter had,

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

Di sini parameter regex mengehadkan ungkapan biasa dan had adalah untuk ambang yang terhasil. Hadnya ialah 3 nilai, iaitu:

• 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:

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.

Atas ialah kandungan terperinci split() Fungsi dalam Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!