Méthode Split en Java : diviser une chaîne en parties

Parlons de la méthode String split : ce qu'elle fait et pourquoi elle est nécessaire. Il est facile de deviner que cela divise la chaîne, mais comment cela fonctionne-t-il en pratique ? Examinons de plus près le fonctionnement de la méthode et discutons de certains détails non évidents, tout en découvrant combien de méthodes fractionnées il existe réellement dans la classe String . Allons-y!

Définition et signature pour Java String.split

La méthode split en Java divise une chaîne en sous-chaînes à l'aide d'un délimiteur spécifié à l'aide d'une expression régulière. Donnons la signature de la méthode et commençons notre plongée :

String[] split(String regex)

Deux choses ressortent clairement de la signature :

1. La méthode renvoie un tableau de chaînes.
2. La méthode prend une chaîne regex comme paramètre.

Examinons chaque chose séparément en fonction de la définition donnée ci-dessus.

1. La méthode renvoie un tableau de chaînes.

   La définition contient les mots suivants : « La méthode split en Java divise une chaîne en sous-chaînes. » Ces sous-chaînes sont collectées par la méthode dans un tableau et représentent sa valeur de retour.

2. La méthode prend une chaîne regex comme paramètre.

   Encore une fois, rappelez-vous la définition : « divise une chaîne en sous-chaînes à l'aide d'un délimiteur spécifié à l'aide d'une expression régulière ». Le paramètre regex accepté est un modèle d'expression régulière qui est appliqué à la chaîne source et correspond au caractère délimiteur (ou à la combinaison de caractères) dans la chaîne source.

Split en pratique

Passons maintenant aux choses sérieuses. Imaginons que nous ayons une chaîne de mots. Par exemple, comme ceci : Nous devons diviser la chaîne en mots. On voit que dans cette ligne les mots sont séparés les uns des autres par des espaces. L'espace est un candidat idéal pour le rôle de séparateur dans ce cas. Voici à quoi ressemble le code permettant de résoudre ce problème :

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

Le résultat de la méthode main sera les lignes suivantes : Examinons quelques exemples supplémentaires de la façon dont la méthode split fonctionnerait : Notez les différences entre les deux dernières lignes du tableau ci-dessus. Dans l'avant-dernière ligne, le délimiteur est une virgule, la ligne est donc divisée de telle manière que certains mots comportent des espaces de début. Dans la dernière ligne, nous avons utilisé une virgule et un espace comme délimiteur. Par conséquent, le tableau résultant ne contenait aucune ligne avec des espaces de début. Ce n’est qu’un petit détail qui démontre à quel point il est important de sélectionner soigneusement le bon séparateur.

Délimiteur principal

Il y a une autre nuance importante. Si la chaîne source commence par un délimiteur, le premier élément du tableau résultant sera la chaîne vide. Dans un exemple, cela ressemblerait à ceci : Chaîne source : "I love Java" Délimiteur : " " Tableau résultant : { "" , "I" , "love" , "Java" } Mais si la chaîne source se termine par un délimiteur et ne commence pas, le résultat sera différent : Chaîne source : "I love Java" Séparateur : " " Tableau résultant : { "I" , "love" , "Java" } Regardons dans le code les variantes de la méthode split avec un caractère séparateur à la fin et/ou au début de la chaîne source :

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

Le résultat de la méthode main ressemblera à ceci : Notez à nouveau que lorsque le premier caractère de la chaîne source est un caractère délimiteur, le tableau résultant aura la chaîne vide comme premier élément.

Un camarade surchargé

La classe String possède une autre méthode split avec cette signature :

String[] split(String regex, int limit)

Cette méthode a un paramètre limit supplémentaire : il détermine le nombre de fois que le modèle regex sera appliqué à la chaîne source. Ci-dessous les explications :

limite > 0

la limite -1 fois est appliquée . Dans ce cas, la longueur du tableau ne dépassera pas la valeur limite . Le dernier élément du tableau sera la partie de la chaîne suivant le dernier délimiteur 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));
    }
}

limite < 0

Le modèle de recherche de délimiteur est appliqué à la chaîne autant de fois que possible. La longueur du tableau résultant peut être quelconque. Exemple:

public class Main {
    public static void main(String[] args) {
        // Notice the space at the end of the line
        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, ]

        Note that the last element of the array is
        an empty string, resulting from the space
        at the end of the original string.
        */
    }

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

limite 0

Comme pour la limite < 0, le modèle de délimiteur est appliqué à la chaîne autant de fois que possible. Le tableau résultant peut être de n’importe quelle longueur. Si les derniers éléments sont égaux à la chaîne vide, ils seront ignorés dans le tableau final. Exemple:

public class Main {
    public static void main(String[] args) {
        // Notice the space at the end of the line
        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 regardons l'implémentation de la méthode split avec un argument, nous voyons que cette méthode appelle son frère surchargé avec un deuxième argument de zéro :

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

Divers exemples

Dans la pratique du travail, il arrive parfois que nous ayons une ligne rédigée selon certaines règles. Cette ligne peut « entrer » dans notre programme de n’importe où :

• à partir d'un service tiers ;
• d'une requête à notre serveur ;
• à partir du fichier de configuration ;
• etc.

Habituellement, dans une telle situation, le programmeur connaît les « règles du jeu ». Disons que le programmeur sait qu'il dispose d'informations sur l'utilisateur, qui sont stockées selon ce modèle : Par exemple, prenons des valeurs spécifiques : Et maintenant, le programmeur est confronté à la tâche : écrire une méthode qui envoie un e-mail à l'utilisateur. A sa disposition se trouvent des informations sur l'utilisateur, enregistrées dans le format ci-dessus. Eh bien, la sous-tâche que nous continuerons à analyser est d'isoler l'adresse e-mail des informations générales sur l'utilisateur. Ceci est un exemple où la méthode split peut être utile. Après tout, si nous regardons le modèle, nous comprenons que pour extraire l'adresse e-mail de l'utilisateur de toutes les informations, il suffit de diviser la ligne en utilisant la méthode split . Ensuite, l'adresse e-mail figurera dans le dernier élément du tableau résultant. Donnons un exemple d'une telle méthode, qui prend une chaîne contenant des informations sur l'utilisateur et renvoie l'e-mail de l'utilisateur. Pour simplifier, supposons que cette chaîne correspond toujours au format dont nous avons besoin :

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]
    }
}

Notez le séparateur : "\\|" . Puisque dans les expressions régulières « | » - il s'agit d'un caractère spécial auquel est liée une certaine logique ; pour l'utiliser comme un caractère normal (celui que l'on veut retrouver dans la chaîne source), il faut échapper à ce caractère à l'aide de deux barres obliques inverses. Regardons un autre exemple. Disons que nous avons des informations sur une commande, qui sont écrites approximativement dans ce format : Ou prenons des valeurs spécifiques : Nous sommes confrontés à la tâche de calculer le coût total de la commande. Ici, nous devrons utiliser la méthode split plusieurs fois. La première étape consiste à diviser la chaîne via le symbole « ; » en ses composants. Ensuite, dans chacune de ces parties, nous aurons des informations sur un produit individuel, que nous pourrons traiter à l'avenir. Et puis, au sein de chaque produit, nous séparerons les informations à l'aide du symbole "," et prendrons du tableau résultant un élément avec un certain index (dans lequel le prix est stocké), le convertirons sous une forme numérique et compilerons le coût final. de la commande. Écrivons une méthode qui calculera tout cela :

public class Main {
    public static void main(String[] args) {
        String orderInfo = "1, cucumbers, 20.05; 2, tomatoes, 123.45; 3, hares, 0.50";
        System.out.println(getTotalOrderAmount(orderInfo));
        // Output: 144.0
    }

    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;
    }
}

Essayez de comprendre par vous-même comment fonctionne cette méthode. Sur la base de ces exemples, nous pouvons dire que la méthode split est utilisée lorsque nous disposons d'informations sous forme de chaîne, à partir desquelles nous devons extraire des informations plus spécifiques.

Résultats

Nous avons examiné la méthode split de la classe String . Il est nécessaire de diviser une chaîne en ses composants à l’aide d’un délimiteur spécial. La méthode renvoie un tableau de chaînes (les composants d'une chaîne). Accepte une expression régulière qui recherche le(s) caractère(s) délimiteur(s). Nous avons examiné les différentes subtilités de cette méthode :

• caractère délimiteur principal ;
• frère surchargé avec deux arguments.

Nous avons également essayé de simuler certaines situations de la « vie réelle » dans lesquelles nous avons utilisé la méthode du fractionnement pour résoudre des problèmes certes fictifs, mais tout à fait réalistes.