CodeGym/Blog Java/France/La méthode String.split() en Java : diviser une chaîne en...
Auteur
Alex Vypirailenko
Java Developer at Toshiba Global Commerce Solutions

La méthode String.split() en Java : diviser une chaîne en parties

Publié dans le groupe France
membres
Parlons de la méthode String.split de Java : ce qu'elle fait et pourquoi elle est nécessaire. Il n'est pas difficile de deviner qu'elle divise une chaîne Java, mais comment fonctionne-t-elle en pratique ? Plongeons-nous en profondeur dans le fonctionnement de cette méthode et discutons de quelques détails moins évidents. Dans le même temps, apprenons combien il existe réellement de méthodes split pour String. Allons-y !

Description et signature pour String.split de Java (split Java)

En Java, la méthode split divise une chaîne en sous-chaînes à l'aide d'un séparateur défini à l'aide d'une expression régulière. Présentons la signature de la méthode et commençons notre plongée en profondeur :
String[] split(String regex)
Deux choses sont claires à partir de la signature :
  1. La méthode renvoie un tableau de chaînes.
  2. La méthode a un paramètre d'entrée de type String appelé regex.
Analysons chacun de ces éléments séparément en étudiant la description donnée ci-dessus.
  1. La méthode renvoie un tableau de chaînes.

    La déclaration contient les mots suivants : « En Java, la méthode split divise une chaîne en sous-chaînes. » La méthode recueille ces sous-chaînes dans un tableau qui devient la valeur de retour.

  2. La méthode a un paramètre d'entrée de type String appelé regex.

    Encore une fois, souviens-toi de la description : « divise une chaîne en sous-chaînes à l'aide d'un séparateur défini à l'aide d'une expression régulière. » Le paramètre d'entrée regex est une expression régulière qui est appliquée à la chaîne d'origine. Les caractères qui correspondent sont traités comme un séparateur.

La méthode split string de Java en pratique

Maintenant rapprochons-nous du point. Imaginons que nous avons une série de mots. Par exemple, comme ceci :
J'aime le Java
Nous devons diviser la chaîne en mots. Nous voyons que les mots de cette chaîne sont séparés les uns des autres par des espaces. Dans ce cas, un caractère espace est le candidat idéal pour notre séparateur. Le code pour résoudre notre tâche ressemblerait à ceci :
public class Main {
    public static void main(String[] args) {
        String str = "I love Java";
        String[] words = str.split(" ");
        for (String word : words) {
            System.out.println(word);
        }
    }
}
La sortie de la méthode main sera composée des lignes suivantes:
J'aime le Java
Voyons quelques exemples de plus du fonctionnement de la méthode split :
Chaîne Séparateur Résultat de la méthode
"J'aime le Java" " " (caractère espace) {"J'aime", "le", "Java"}
"192.168.0.1:8080" ":" {"192.168.0.1", "8080"}
"Rouge, orange, jaune" "," {"Rouge", " orange", " jaune"}
"Rouge, orange, jaune" ", " {"Rouge", "orange", "jaune"}
Note les différences entre les deux dernières lignes dans le tableau ci-dessus. Dans l'avant-dernière ligne, une virgule est utilisée comme séparateur. Par conséquent, lorsque la chaîne est divisée, certains mots ont des espaces en préfixe. Dans la dernière ligne, nous avons utilisé une virgule et un espace comme séparateur. C'est pourquoi il n'y avait pas de sous-chaînes avec des espaces en préfixe dans le tableau résultant. Ce n'est qu'un détail subtil qui démontre combien il est important de choisir soigneusement le bon séparateur.

Séparateur en début de chaîne

Voici une autre nuance importante. Si la chaîne d'origine commence par le séparateur, alors le premier élément du tableau résultant sera une chaîne vide. Par exemple, cela ressemblerait à ceci : Chaîne d'origine : " J'aime le Java" Séparateur : " " Tableau résultant : { "", "J'aime", "le", "Java" } Mais si la chaîne d'origine se termine par un séparateur plutôt que l'avoir au début, le résultat sera différent : Chaîne d'origine : "J'aime le Java " Séparateur : " " Tableau résultant : { "J'aime", "le", "Java" } Observe le code et note comment la méthode split fonctionne différemment avec un symbole séparateur à la fin et/ou au début de la chaîne d'origine :
public class Main {
    public static void main(String[] args) {
        print("I love Java".split(" "));
        print(" I love Java".split(" "));
        print("I love Java ".split(" "));
        print(" I love Java ".split(" "));
    }

    static void print(String[] arr) {
        System.out.println(Arrays.toString(arr));
    }
}
La sortie de la méthode main sera la suivante :
[J'aime, le, Java] [, J'aime, le, Java] [J'aime, le, Java] [, J'aime, le, Java]
Encore une fois, note le fait que lorsque le premier caractère de la chaîne d'origine est un caractère séparateur, le résultat est que le premier élément du tableau sera une chaîne vide.

Homologue surchargée

La classe String possède une autre méthode split avec la signature suivante :
String[] split(String regex, int limit)
Cette méthode a un paramètre limit supplémentaire : il détermine combien de fois le modèle regex sera appliqué à la chaîne d'origine. Plus d'explications ci-dessous :

limit > 0

Le modèle est appliqué limit-1 fois. De plus, la longueur du tableau retourné ne dépassera pas la valeur du paramètre limit. Le dernier élément du tableau sera la partie de la chaîne qui suit le dernier endroit où le séparateur a été trouvé. Exemple :
public class Main {
    public static void main(String[] args) {
        print("I love Java".split(" ", 1));
        print("I love Java".split(" ", 2));
        /*
         Output:
         [I love Java]
         [I, love Java]
        */
    }

    static void print(String[] arr) {
        System.out.println(Arrays.toString(arr));
    }
}

limit < 0

L'expression régulière du séparateur est appliquée à la chaîne autant de fois que possible. Le tableau qui en résulte peut avoir n'importe quelle longueur. Exemple :
public class Main {
    public static void main(String[] args) {
        // Note the space at the end of the string
        print("I love Java ".split(" ", -1));
        print("I love Java ".split(" ", -2));
        print("I love Java ".split(" ", -12));
        /*
         Output:
        [I, love, Java, ]
        [I, love, Java, ]
        [I, love, Java, ]

        Please note that the last element of the array is
        an empty string. This is caused by the whitespace
        at the end of the original string.
        */
    }

    static void print(String[] arr) {
        System.out.println(Arrays.toString(arr));
    }
}

limit = 0

Comme dans le cas où limit < 0, le modèle de séparateur est appliqué à la chaîne autant de fois que possible. Le tableau final peut avoir n'importe quelle longueur. Si les derniers éléments sont des chaînes vides, ils sont écartés du tableau final. Exemple :
public class Main {
    public static void main(String[] args) {
        // Note the space at the end of the string
        print("I love Java ".split(" ", 0));
        print("I love Java ".split(" ", 0));
        print("I love Java ".split(" ", 0));
        /*
         Output:
        [I, love, Java]
        [I, love, Java]
        [I, love, Java]
        Note the absence of empty strings at the end of the arrays
        */
    }

    static void print(String[] arr) {
        System.out.println(Arrays.toString(arr));
    }
}
Si nous jetons un œil à l'implémentation de la version à un seul paramètre de la méthode split, nous pouvons voir qu'elle est comme son homologue surchargée, mais avec le deuxième argument fixé à zéro :
public String[] split(String regex) {
    return split(regex, 0);
}

Divers exemples

Dans le monde réel, il arrive parfois que nous ayons des chaînes qui sont générées selon certaines règles. Une telle chaîne peut entrer dans notre programme de n'importe où :
  • d'un service tiers ;
  • d'une demande envoyée à notre serveur ;
  • d'un fichier de configuration ;
  • et ainsi de suite.
Dans ces situations, le programmeur connaît généralement les « règles du jeu ». Supposons qu'un programmeur sait qu'il traite des informations utilisateur stockées selon le modèle suivant :
id_utilisateur|identifiant_utilisateur|email_utilisateur
Prenons quelques valeurs spécifiques à titre d'exemple :
135|bender|bender@gmail.com
Supposons que la tâche du programmeur est d'écrire une méthode qui envoie un e-mail à l'utilisateur. Le programmeur a accès aux données des utilisateurs, qui sont enregistrées dans le format donné ci-dessus. La tâche secondaire que nous allons maintenant continuer à analyser consiste à découvrir comment isoler l'adresse e-mail du reste des données de l'utilisateur. Il s'agit d'un cas où la méthode split peut être utile. Après tout, si nous observons le modèle de données d'utilisateur, nous nous rendons compte que l'extraction de l'adresse e-mail de l'utilisateur du reste est aussi simple qu'un appel à la méthode split pour diviser la chaîne. L'adresse e-mail sera alors le dernier élément du tableau résultant. Voici un exemple d'une méthode qui prend une chaîne contenant des données d'utilisateur et renvoie l'adresse e-mail de l'utilisateur. Par souci de simplicité, disons que la chaîne de données est toujours dans le format que nous voulons :
public class Main {
    public static void main(String[] args) {
        String userInfo = "135|bender|bender@gmail.com";
        System.out.println(getUserEmail(userInfo));
        // Output: bender@gmail.com
    }

    static String getUserEmail(String userInfo) {
        String[] data = userInfo.split("\\|");
        return data[2]; // or data[data.length - 1]
    }
}
Note le séparateur : "\\|". Dans les expressions régulières, « | » est un caractère spécial avec une signification particulière, donc si nous voulons l'utiliser comme un caractère ordinaire (c'est-à-dire ce que nous voulons le trouver dans la chaîne d'origine), nous devons échapper le caractère avec deux barres obliques inverses. Prenons un autre exemple. Disons que nous avons des informations de commande qui sont structurées comme ceci :
numero_objet_1,nom_objet_1,prix_objet_1;numero_objet_2,nom_objet_2,prix_objet_2;...;numero_objet_n,nom_objet_n,prix_objet_n
Ou nous pouvons même adopter des valeurs spécifiques :
1,concombres,2.39;2,tomates,1.89;3,bacon,4.99
Notre tâche est de calculer le coût total de la commande. Ici, nous devrons appliquer la méthode split à plusieurs reprises. La première étape consiste à diviser la chaîne en utilisant « ; » comme séparateur afin de récupérer ses composants individuels. Chaque sous-chaîne résultante contiendra des informations sur un produit distinct, que nous pouvons traiter plus tard. Ensuite, pour chaque produit, nous divisons les informations correspondantes à l'aide du symbole « , ». Nous prenons un élément avec un index spécifique (celui où le prix du produit est stocké) à partir du tableau de chaînes résultant, le convertissons en forme numérique, et ajoutons le nombre au coût total de la commande. Écrivons une méthode qui fera tous ces calculs :
public class Main {
    public static void main(String[] args) {
        String orderInfo = "1,cucumbers,2.39;2,tomatoes,1.89;3,bacon,4.99";
        System.out.println(getTotalOrderAmount(orderInfo));
        // Output: 9.27
    }

    static double getTotalOrderAmount(String orderInfo) {
        double totalAmount = 0d;
        final String[] items = orderInfo.split(";");

        for (String item : items) {
            final String[] itemInfo = item.split(",");
            totalAmount += Double.parseDouble(itemInfo[2]);
        }

        return totalAmount;
    }
}
Essaie de voir si tu peux comprendre comment cette méthode fonctionne par toi-même. Sur la base de ces exemples, nous pouvons dire que la méthode split est utilisée lorsque nous avons des données formatées sous forme de chaîne et que nous devons en extraire des informations spécifiques.

Résumé

Nous avons examiné la méthode split de la classe String. C'est exactement ce dont tu as besoin lorsque tu dois diviser une chaîne en ses composants à l'aide d'un séparateur spécial. La méthode renvoie un tableau de chaînes (les sous-chaînes qui composent la chaîne d'origine). Elle accepte une expression régulière dont les correspondances représentent le ou les caractères de séparation. Nous avons examiné diverses subtilités de cette méthode :
  • un séparateur en début de chaîne ;
  • son homologue surchargée avec deux paramètres.
Nous avons également essayé de modéliser certaines situations de la vie réelle où nous avons utilisé la méthode split pour résoudre des problèmes hypothétiques, mais parfaitement plausibles.
Commentaires
  • Populaires
  • Nouveau
  • Anciennes
Tu dois être connecté(e) pour laisser un commentaire
Cette page ne comporte pas encore de commentaires