Fonction split() en Java

La fonction Java split() est utilisée pour diviser la chaîne en tableau de chaînes en fonction de l'expression régulière ou du délimiteur donné. L'objet résultant est un tableau contenant les chaînes divisées. Dans le tableau renvoyé résultant, nous pouvons transmettre la limite au nombre d'éléments.

PUBLICITÉ Cours populaire dans cette catégorie MAÎTRISÉE JAVA - Spécialisation | 78 séries de cours | 15 tests simulés

Voyons l'exemple,

• Chaîne : Java@SplitFunctions
• Expression régulière : @
• Résultat : « Java », « SplitFunctions »

L'exemple ci-dessus divise la chaîne en fonction des correspondances de l'expression régulière requise.

Syntaxe :

La syntaxe de la fonction split est la suivante,

public String[] split(String regex)

Ici, dans la signature ci-dessus, l'expression régulière est délimitante pour l'expression régulière. Il spécifie le caractère utilisé pour diviser la chaîne. Enfin, la valeur de retour résultante renvoie le tableau de chaînes qui divise la chaîne en fonction des correspondances de l'expression régulière.

Comment fonctionne la fonction split() en Java ?

Dans la fonction Java Split(), nous divisons la chaîne en utilisant différentes méthodes ; la classe string propose deux méthodes pour diviser les chaînes.

Voyons les signatures disponibles comme suit,

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

1. public String[] split (String regex)

Cette méthode divise la chaîne en utilisant l'expression régulière sur la chaîne donnée ; la chaîne entière divise la chaîne et le formulaire de retour résultant sous forme de chaîne de tableau. Dans Java 1.4, la méthode ci-dessus est introduite. Voyons l'exemple de fractionnement de la chaîne et la sortie résultante correspondante,

Code :

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

Sortie :

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

Nous utilisons cette méthode lorsque nous devons diviser une chaîne Java en un nombre limité de chaînes ; pour cela, nous optons pour cette méthode ; Voyons l'exemple de la chaîne qui a la variable chaîne contenant le nom et l'adresse avec le délimiteur sous forme de virgule, l'adresse suivante contenant les virgules, nous optons donc pour cette approche.

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

Le paramètre limit est facultatif. Un entier indiquant le nombre de fractionnements et les éléments situés après la limite de fractionnement ne seront pas inclus dans le tableau. La première méthode ci-dessus utilise la deuxième méthode en passant la limite à 0.

Code :

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

Exemples de fonction split()

Des exemples des éléments suivants sont donnés ci-dessous :

Exemple n°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);
}
}
}

Sortie :

En utilisant la fonction split() pour la chaîne qui doit fournir et diviser l'argument séparateur, nous allions utiliser le séparateur comme une virgule(,), et le résultat de retour sera la division du tableau. La sortie imprime chacune des chaînes appelées élément d'un tableau après chaque opération de division, comme indiqué ci-dessous,

Exemple n°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]);
}
}
}

Sortie :

Ici, nous passons split, qui se limite comme deuxième argument à cette fonction. Cela limite le nombre de chaînes divisées.

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

Sortie :

Méthode Split() avec le paramètre limit

La méthode Split() avec le paramètre limit divise les chaînes avec des nombres limités. La différence entre split() et split() avec le paramètre limit est qu'il limite le nombre de chaînes renvoyées après les fractionnements. Pour la limite, nous devons donner un paramètre d'entrée à la fonction split(). Voyons l'utilisation de la méthode split() avec le paramètre limit,

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

Ici, le paramètre regex délimite l'expression régulière, et la limite concerne le seuil résultant. Les limites sont de 3 valeurs, ce sont :

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!