Comment Diviser Une Chaîne en Java

Quelquefois, on doit diviser une chaîne en programmation. Nous suggestons les méthodes String.split (), StringTokenizer, et Pattern.compile ().

Diviser Une Chaîne en Java

public class StringSplitTest {
    public static void main(String[] arg) {
        String str = "Bienvenu:cher invité";
        String[] arrOfStr = str.split(":");
        for (String a: arrOfStr)
            System.out.println(a);
    }
}

La sortie pour cela sera comme le suivant:

Résultat

Bienvenu
cher invité

Remarque: Changez regex pour arriver au résultat différent:
E.g. pour ("e") regex le résultat sera comme cela:

Il y a beaucoup de moyens de diviser une chaîne en Java. La méthode la plus commune consiste à l’utilisation de la méthode split() qui est utilisée pour diviser une chaîne en un tableau de sous-chaînes et renvoie le nouveau tableau.

1. Utiliser String.split ()

La méthode de string split() rompt une chaîne donnée autour des correspondances de l’expression régulière donnée. Il y a deux variantes de la méthode split() en Java:

String split publique(String regex)

Cette méthode prend une expression régulière comme paramètre et rompt la chaîne donnée autour des correspondances de cette expression régulière. Ici, la limite par défaut est 0.

Le paramètre pour cela est: regex (une expression régulière de délimitation).

Il retourne un tableau de chaînes calculé en divisant la chaîne donnée.

Exemple

W
lcom
:d
ar gu
st

String split publique (String regex, int limit)

Les paramètres pour cela sont: regex (l'expression régulière de délimitation) et limit (contrôle le nombre de fois où le motif est appliqué et affecte donc la longueur du tableau résultant).

Cela retourne le tableau des chaînes comptées en divisant cette chaîne autour des correspondances de l'expression régulière donnée.

Exemple

public class StringSplitTest { 
public static void main(String[] arg){ 
String str = "Hello:world:hello"; 
String split[] = str.split("e", 5); 
for(String s:split) 
System.out.println(s); } }

Le résultat de l'exemple donné sera comme ça:

Résultat

H
llo:world:h
llo

Remarque: Changez regex et limit pour avoir les différents résultats: e.g. (":", 2)-sortie sera {Hello, world:hello}; (":", -2)-{Hello, world, hello}, etc.

Voyons un autre exemple:

Exemple

public class StringSplitTest { 
public static void main(String[] arg){ 
String str = "Que tu fais aujourd'hui?"; 
String split[] = str.split(" ", 0); 
for(String s:split) 
System.out.println(s); } }

Le résultat sera comme le suivant:

Résultat

Que
tu
fais
aujourd'hui?

Remarque: Changez regex et limit pour avoir un autre sortie: e.g. (" ", 2) – le résultat sera comme ça:

Résultat

Que
tu fais aujourd'hui?

Définissez le zéro limite pour renvoyer toutes les chaînes correspondant à l'expression régulière.

Vous pouvez également utiliser String Split avec plusieurs caractères en utilisant regex.

Exemple

public class StringSplitTest { 
      public static void main(String args[]) { 
   String s = " ;String; String; String; String, String; String;;String;String; String; String; ;String;String;String;String"; //String[] strs = s.split("[,\\s\\;]"); 
         String[] strs = s.split("[,\\;]"); 
         System.out.println("Substrings length:"+strs.length); 
         for (int i=0; i < strs.length; i++) { 
          System.out.println("Str["+i+"]:"+strs[i]); 
     }
   }
}

La sortie pour cela sera:

Résultat

Substrings length:17
Str[0]: 
Str[1]:String
Str[2]: String
Str[3]: String
Str[4]: String
Str[5]: String
Str[6]: String
Str[7]:
Str[8]:String
Str[9]:String
Str[10]: String
Str[11]: String
Str[12]: 
Str[13]:String
Str[14]:String
Str[15]:String
Str[16]:String

2. Utiliser StringTokenizer

En Java, la chaîne tokenizer permet de casser une chaîne en jetons. Vous pouvez également obtenir le nombre de jetons à l'intérieur d'un objet chaîne.

Exemple

import java.util.StringTokenizer;

public class StringTokenizerExample {
    public static void main(String[] args) {
        StringTokenizer st =
            new StringTokenizer("A StringTokenizer sample");

        // get how many tokens are inside st object
        System.out.println("Tokens count: " + st.countTokens());

        // iterate st object to get more tokens from it
        while (st.hasMoreElements()) {
            String token = st.nextElement().toString();
            System.out.println("Token = " + token);
        }
    }
}

Résultat

Tokens count: 3
Token = A
Token = StringTokenizer
Token = sample

Remarque: Vous pouvez spécifier le délimiteur utilisé pour diviser la chaîne. Dans l'exemple donné, nous avons défini le délimiteur comme un espace (”).

Il est également possible d'utiliser StringTokenizer avec plusieurs délimiteurs.

Exemple

import java.util.StringTokenizer;

public class StringTokenizerExample {
    public static void main(String[] args) {
       String url = "http://www.w3docs.com/learn-javascript.html";
StringTokenizer multiTokenizer = new StringTokenizer(url, "://.-");
while (multiTokenizer.hasMoreTokens())
{
    System.out.println(multiTokenizer.nextToken());
}
    }
}

Résultat

http
www
w3docs
com
learn
javascript
html

Remarque: Dans l’exemple ci-dessus les délimiteurs :, //, ., - sont utilisés.

3. Utiliser Pattern.compile ()

Cette méthode divise la séquence d'entrée donnée autour des correspondances du modèle. Le paramètre pour cela est: input - la séquence de caractères à diviser.

Il retourne le tableau de chaînes calculé en divisant l'entrée autour des correspondances du motif.

Exemple

import java.util.regex.Pattern;

public class PatternDemo {
   private static String REGEX = ":";
   private static String INPUT = "bonjour:cher:invité";

   public static void main(String[] args) {
      Pattern pattern = Pattern.compile(REGEX);

      String[] result = pattern.split(INPUT);
      for(String data:result){
         System.out.println(data); 
      }
   }
}

Cela va produire le résultat suivant:

Résultat

bonjour
cher
invité