# Java String split() : comment diviser des chaînes de caractères en Java ?

La méthode Java `split()` est utilisée pour diviser des chaînes de caractères (*strings*) en plusieurs sous-chaînes. Pour cela, un paramètre est défini, qui fait office de séparateur. Un paramètre optionnel détermine le nombre de sous-chaînes. Découvrez dans notre article comment utiliser cette méthode.

## Java String `split()` : à quoi sert la méthode ?

Une [chaîne ou string Java](https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/java-strings/) concatène plusieurs caractères, chiffres ou caractères spéciaux. Elle existe en tant qu’objet dans la classe *java.lang* et est créée et traitée avec la classe *String*. Ce langage de programmation Web vous offre également la possibilité de séparer ces chaînes en plusieurs sous-chaînes. La méthode Java `split()` est utilisée lorsque vous souhaitez simplement **extraire certaines parties de la chaîne entière** ou la diviser en ses **parties individuelles**. Nous allons vous montrer les différentes possibilités offertes par cette méthode.

Si vous utilisez Java String `split()`, vous obtenez en retour un tableau de plusieurs chaînes. Celui-ci devient alors la valeur de retour.

## Syntaxe et fonctionnement de la méthode

La syntaxe de la méthode Java String `split()` est très simple, mais elle peut être complétée par un paramètre optionnel. Voici la variante de base :

```java
String[] split(String regex)
```

Le **retour se fait sous la forme d’un tableau**. `regex` est un paramètre d’entrée par lequel vous déterminez à quels endroits la chaîne doit être divisée. Vous n’êtes pas obligé d’utiliser ce paramètre, mais nous vous recommandons de le faire. Avec le paramètre optionnel `limit`, la syntaxe est la suivante :

```java
String[] split(String regex, int limit)
```

`limit` indique combien de sous-chaînes doivent être créées. Sa valeur est un entier. Si elle est négative ou égale à 0, toutes les sous-chaînes seront affichées dans la sortie. Si vous choisissez une valeur positive, seules les sous-chaînes correspondantes seront affichées.

## Exemple de méthode avec un espace comme séparateur

La meilleure façon de comprendre Java String `split()` est de voir son utilisation dans un exemple pratique. Pour cela, nous créons une chaîne composée de quatre mots : « Ceci est un exemple ». Vous pouvez maintenant diviser cette chaîne. La séparation la plus évidente est celle qui suit les délimitations déjà existantes, créées par les **espaces entre les mots**. Le code suivant permet d’effectuer cette séparation :

```java
public class Main {
    public static void main(String[] args) {
        String x = "Ceci est un exemple";
        String[] resultat = x.split(" ");
        for (String y : resultat) {
            System.out.println(y);
        }
    }
}
```

Une variable String « x » est alors initialisée. Ensuite, Java applique la méthode `split()` à x. Le paramètre `regex` recherche les espaces dans la chaîne de caractères et la divise à ces endroits. Ensuite, le résultat est stocké dans un tableau appelé « Output ». La boucle `for` permet de lister ces sous-chaînes. En utilisant la commande Java `System.out.println`, vous obtenez la sortie suivante :

```java
Ceci
est
un
exemple
```

## La virgule comme séparateur : avec et sans espace

Vous pouvez également utiliser la méthode pour **subdiviser des listes** séparées par des virgules et stockées sous forme de chaîne de caractères. Pour cela, vous devez toutefois utiliser une petite astuce qui montre directement comment vos instructions sont mises en œuvre. Imaginons une liste des jours de la semaine, séparés par des virgules. Ces virgules seraient en fait un bon paramètre auquel `regex` pourrait se référer. Si vous initiez cela de cette manière, le code se présente comme suit :

```java
public class Main {
    public static void main(String[] args) {
        String x = "Lundi, Mardi, Mercredi, Jeudi, Vendredi, Samedi, Dimanche";
        String[] resultat = x.split(",");
        for (String y : resultat) {
            System.out.println(y);
        }
    }
}
```

Si vous faites cela, la sortie ne sera pas idéale :

```java
Lundi
 Mardi
 Mercredi
 Jeudi
 Vendredi
 Samedi
 Dimanche
```

La liste obtenue est claire, mais toutes les valeurs à partir de « Mardi » ont un espace comme premier caractère. Comme la séparation a toujours été effectuée directement après la virgule, Java String `split()` prend cet espace comme première position dans la sous-chaîne. Si vous souhaitez contourner ce problème, il suffit de modifier la méthode en ajoutant un **espace supplémentaire comme séparateur**. Voici le code correspondant :

```java
public class Main {
    public static void main(String[] args) {
        String x = "Lundi, Mardi, Mercredi, Jeudi, Vendredi, Samedi, Dimanche";
        String[] resultat = x.split(", ");
        for (String y : resultat) {
            System.out.println(y);
        }
    }
}
```

La sortie est désormais beaucoup plus ordonnée.

```java
Lundi
Mardi
Mercredi
Jeudi
Vendredi
Samedi
Dimanche
```

## Séparer les chaînes de chiffres

Une autre possibilité de séparation existe pour les longues chaînes de chiffres. Imaginons par exemple une longue clé divisée par des points et un double point. Si vous souhaitez séparer les chiffres **après les deux points**, voici le code approprié :

```java
public class Main {
    public static void main(String[] args) {
        String x = "194.518.552.1.17:6339";
        String[] resultat = x.split(":");
        for (String y : resultat) {
            System.out.println(y);
        }
    }
}
```

La sortie est alors la suivante :

```java
194.518.552.1.17
6339
```

## La méthode Java String `split()` avec le paramètre `limit`

Comme mentionné plus tôt, Java `split()` s’utilise aussi avec le paramètre optionnel `limit`. Celui-ci limite le nombre de chaînes partielles qui sont créées avec la méthode. Pour cela, vous avez trois possibilités : une valeur inférieure à 0, une valeur égale à 0 ou une valeur supérieure à 0.

### `limit` : valeur inférieure à 0

Si vous choisissez une valeur pour `limit` inférieure à 0, l’expression régulière **sans restriction est appliquée à toute la chaîne de caractères**. Le tableau qui en résulte peut être de n’importe quelle longueur. Le code ressemble par exemple à ceci :

```java
public class Main {
    public static void main(String[] args) {
        String x = "Lundi, Mardi, Mercredi, Jeudi, Vendredi, Samedi, Dimanche ";
        String[] resultat = x.split(", ", -3);
        for (String y : resultat) {
            System.out.println(y);
        }
    }
}
```

Comme il y a encore un espace après le dernier terme « Dimanche », le tableau se termine par une chaîne vide. La sortie correspondante est celle-ci :

```java
Lundi
Mardi
Mercredi
Jeudi
Vendredi
Samedi
Dimanche
```

### `limit` : valeur égale à 0

Si vous choisissez la valeur 0 pour le paramètre `limit`, l’expression régulière sera également utilisée **aussi souvent que possible**. La longueur du tableau n’est pas non plus limitée. Mais si le dernier élément est une chaîne vide, elle ne sera pas prise en compte pour le tableau final.

```java
public class Main {
    public static void main(String[] args) {
        String x = "Lundi, Mardi, Mercredi, Jeudi, Vendredi, Samedi, Dimanche ";
        String[] resultat = x.split(", ", 0);
        for (String y  : resultat) {
            System.out.println(y);
        }
    }
}
```

La sortie est identique, mais la dernière chaîne est rejetée.

```java
Lundi
Mardi
Mercredi
Jeudi
Vendredi
Samedi
Dimanche
```

### `limit` : valeur supérieure à 0

Les différences sont évidentes lorsque vous donnez à `limit` une valeur supérieure à 0. Cela détermine le nombre de sous-chaînes qui seront éditées. Pour notre exemple, cela ressemble à ceci :

```java
public class Main {
    public static void main(String[] args) {
        String x = "Lundi, Mardi, Mercredi, Jeudi, Vendredi, Samedi, Dimanche ";
        String[] resultat = x.split(", ", 3);
        for (String y : resultat) {
            System.out.println(y);
        }
    }
}
```

Nous obtenons maintenant une sortie qui se distingue déjà au premier coup d’œil des deux précédentes :

```java
Lundi
Mardi
Mercredi, Jeudi, Vendredi, Samedi, Dimanche
```


This is a markdown version of: [https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/java-string-split/](https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/java-string-split/) for AI/LLM consumption.