Comment diviser une chaîne en ArrayList en utilisant un délimiteur en Java

JavaBeginner
Pratiquer maintenant

Introduction

En programmation Java, la manipulation des chaînes de caractères et le travail avec des collections telles que ArrayList sont des compétences essentielles. Ce tutoriel vous guide à travers le processus de division d'une chaîne de caractères en un ArrayList en utilisant un délimiteur en Java. À la fin de ce lab, vous comprendrez comment décomposer des données textuelles en morceaux gérables et les stocker dans une collection flexible, ce qui vous permettra de vous attaquer à diverses tâches de traitement de données dans vos applications Java.

Comprendre les chaînes de caractères et les ArrayLists en Java

Avant de nous plonger dans la division des chaînes de caractères, comprenons les deux composants clés avec lesquels nous allons travailler dans ce lab.

Les chaînes de caractères (Strings) en Java

Une chaîne de caractères (String) en Java est une séquence de caractères. C'est l'une des classes les plus couramment utilisées en programmation Java. Les chaînes de caractères sont immuables, ce qui signifie qu'une fois créées, leurs valeurs ne peuvent pas être modifiées.

Par exemple :

String greeting = "Hello, World!";

Les ArrayLists en Java

Un ArrayList est une implémentation de tableau redimensionnable en Java. Contrairement aux tableaux réguliers qui ont une taille fixe, les ArrayLists peuvent croître ou se réduire dynamiquement. Ils font partie du Java Collections Framework et fournissent diverses méthodes pour manipuler les éléments stockés.

Pour utiliser ArrayList, nous devons l'importer depuis le package java.util :

import java.util.ArrayList;

Création d'un ArrayList :

ArrayList<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");

Maintenant, créons un nouveau fichier Java pour commencer à travailler avec ces concepts. Suivez ces étapes :

  1. Ouvrez le WebIDE dans votre environnement LabEx
  2. Naviguez vers le répertoire du projet (il devrait être ouvert par défaut)
  3. Créez un nouveau fichier nommé StringSplitDemo.java en cliquant sur l'icône "New File" dans l'éditeur
  4. Ajoutez le code de base suivant pour créer une classe Java simple :
public class StringSplitDemo {
    public static void main(String[] args) {
        // Nous ajouterons notre code ici
        System.out.println("String Split Demo");
    }
}
  1. Enregistrez le fichier en appuyant sur Ctrl+S
  2. Ouvrez le terminal dans l'IDE (s'il n'est pas déjà ouvert) et compilez le fichier Java :
javac StringSplitDemo.java
  1. Exécutez le programme :
java StringSplitDemo

Vous devriez voir la sortie :

String Split Demo

Cela confirme que votre configuration Java de base fonctionne correctement. Dans l'étape suivante, nous allons apprendre à diviser une chaîne de caractères en utilisant la méthode split().

Diviser les chaînes de caractères en utilisant la méthode split()

Java fournit une méthode intégrée appelée split() dans la classe String qui nous permet de diviser une chaîne de caractères en parties en fonction d'un délimiteur. La méthode renvoie un tableau de chaînes de caractères contenant les sous-chaînes divisées par le délimiteur.

La méthode split()

La méthode split() prend une expression régulière (regular expression) comme paramètre et renvoie un tableau de sous-chaînes :

String[] split(String regex)

Modifions notre fichier StringSplitDemo.java pour inclure du code qui divise une chaîne de caractères. Ouvrez le fichier dans l'éditeur et mettez-le à jour comme suit :

public class StringSplitDemo {
    public static void main(String[] args) {
        // Crée une chaîne de caractères avec des valeurs séparées par des virgules
        String csvData = "apple,banana,orange,grape,mango";
        System.out.println("Chaîne originale: " + csvData);

        // Divise la chaîne de caractères en utilisant la virgule comme délimiteur
        String[] fruits = csvData.split(",");

        // Affiche le tableau résultant
        System.out.println("\nAprès la division:");
        System.out.println("Nombre d'éléments: " + fruits.length);

        // Affiche chaque élément du tableau
        for (int i = 0; i < fruits.length; i++) {
            System.out.println("Élément " + i + ": " + fruits[i]);
        }
    }
}

Enregistrez le fichier et exécutez le programme :

javac StringSplitDemo.java
java StringSplitDemo

Vous devriez voir une sortie similaire à :

Chaîne originale: apple,banana,orange,grape,mango

Après la division:
Nombre d'éléments: 5
Élément 0: apple
Élément 1: banana
Élément 2: orange
Élément 3: grape
Élément 4: mango

Ceci démontre comment la méthode split() divise la chaîne de caractères originale à chaque virgule et place chaque sous-chaîne dans un tableau. Le tableau fruits contient maintenant cinq éléments, chacun représentant un nom de fruit de notre chaîne de caractères originale séparée par des virgules.

Dans l'étape suivante, nous allons convertir ce tableau en un ArrayList pour plus de flexibilité dans la manipulation des données.

Convertir une chaîne de caractères divisée en un ArrayList

Maintenant que nous avons divisé notre chaîne de caractères en un tableau, convertissons-la en un ArrayList. Les ArrayLists offrent plus de flexibilité que les tableaux, y compris le redimensionnement dynamique et des méthodes pratiques pour ajouter, supprimer et manipuler des éléments.

Convertir un tableau en ArrayList

Il existe plusieurs façons de convertir un tableau en un ArrayList en Java :

  1. En utilisant Arrays.asList() et le constructeur ArrayList
  2. En utilisant une boucle pour ajouter chaque élément individuellement
  3. En utilisant l'API Java 8 Stream

Mettons à jour notre fichier StringSplitDemo.java pour inclure la conversion en ArrayList. Nous devrons importer les classes nécessaires du package java.util :

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class StringSplitDemo {
    public static void main(String[] args) {
        // Crée une chaîne de caractères avec des valeurs séparées par des virgules
        String csvData = "apple,banana,orange,grape,mango";
        System.out.println("Chaîne originale: " + csvData);

        // Divise la chaîne de caractères en utilisant la virgule comme délimiteur
        String[] fruits = csvData.split(",");

        // Affiche le tableau résultant
        System.out.println("\nAprès la division en tableau:");
        System.out.println("Nombre d'éléments: " + fruits.length);

        // Affiche chaque élément du tableau
        for (int i = 0; i < fruits.length; i++) {
            System.out.println("Élément du tableau " + i + ": " + fruits[i]);
        }

        // Méthode 1: Convertir en ArrayList en utilisant Arrays.asList() et le constructeur ArrayList
        ArrayList<String> fruitList1 = new ArrayList<>(Arrays.asList(fruits));

        // Méthode 2: Convertir en ArrayList en utilisant une boucle
        ArrayList<String> fruitList2 = new ArrayList<>();
        for (String fruit : fruits) {
            fruitList2.add(fruit);
        }

        // Affiche l'ArrayList créé en utilisant la Méthode 1
        System.out.println("\nAprès la conversion en ArrayList (Méthode 1):");
        System.out.println("Nombre d'éléments: " + fruitList1.size());

        for (int i = 0; i < fruitList1.size(); i++) {
            System.out.println("Élément de l'ArrayList " + i + ": " + fruitList1.get(i));
        }

        // Démontre l'ajout d'un nouvel élément à l'ArrayList
        fruitList1.add("pineapple");
        System.out.println("\nAprès avoir ajouté un nouvel élément à l'ArrayList:");
        System.out.println("Nombre d'éléments: " + fruitList1.size());
        System.out.println("Nouvel élément: " + fruitList1.get(fruitList1.size() - 1));
    }
}

Enregistrez le fichier et exécutez le programme :

javac StringSplitDemo.java
java StringSplitDemo

Vous devriez voir une sortie similaire à :

Chaîne originale: apple,banana,orange,grape,mango

Après la division en tableau:
Nombre d'éléments: 5
Élément du tableau 0: apple
Élément du tableau 1: banana
Élément du tableau 2: orange
Élément du tableau 3: grape
Élément du tableau 4: mango

Après la conversion en ArrayList (Méthode 1):
Nombre d'éléments: 5
Élément de l'ArrayList 0: apple
Élément de l'ArrayList 1: banana
Élément de l'ArrayList 2: orange
Élément de l'ArrayList 3: grape
Élément de l'ArrayList 4: mango

Après avoir ajouté un nouvel élément à l'ArrayList:
Nombre d'éléments: 6
Nouvel élément: pineapple

Cet exemple démontre comment convertir un tableau de chaînes de caractères en un ArrayList et met en évidence l'un des avantages de l'utilisation d'un ArrayList : la possibilité d'ajouter facilement de nouveaux éléments à la collection.

Notez les différences entre les tableaux et les ArrayLists :

  • Les tableaux ont une taille fixe, tandis que les ArrayLists peuvent croître dynamiquement
  • Les ArrayLists fournissent des méthodes comme add(), remove() et get() pour manipuler les éléments
  • Les ArrayLists ne peuvent stocker que des objets, pas des types primitifs (bien que Java gère automatiquement la conversion en utilisant l'autoboxing)

Dans l'étape suivante, nous allons explorer différents délimiteurs pour diviser les chaînes de caractères.

Travailler avec différents délimiteurs

Dans les étapes précédentes, nous avons utilisé une virgule comme délimiteur pour diviser la chaîne de caractères. Cependant, la méthode split() accepte n'importe quelle expression régulière (regular expression) comme délimiteur, ce qui nous permet de diviser les chaînes de caractères en fonction de divers motifs.

Créons un nouveau fichier Java pour expérimenter avec différents délimiteurs. Créez un fichier nommé DelimiterDemo.java avec le contenu suivant :

import java.util.ArrayList;
import java.util.Arrays;

public class DelimiterDemo {
    public static void main(String[] args) {
        // 1. Division par un seul caractère
        String commaString = "red,green,blue,yellow";
        ArrayList<String> colors = new ArrayList<>(Arrays.asList(commaString.split(",")));

        System.out.println("1. Division par une virgule:");
        for (String color : colors) {
            System.out.println("  " + color);
        }

        // 2. Division par un espace
        String spaceString = "Java Python C++ JavaScript Ruby";
        ArrayList<String> languages = new ArrayList<>(Arrays.asList(spaceString.split(" ")));

        System.out.println("\n2. Division par un espace:");
        for (String language : languages) {
            System.out.println("  " + language);
        }

        // 3. Division par plusieurs caractères
        String pipeColonString = "name|John:age|30:city|New York";
        ArrayList<String> personData = new ArrayList<>(Arrays.asList(pipeColonString.split("[|:]")));

        System.out.println("\n3. Division par plusieurs caractères (| ou :):");
        for (String data : personData) {
            System.out.println("  " + data);
        }

        // 4. Division par des chiffres
        String digitsString = "apple123banana456cherry";
        ArrayList<String> fruits = new ArrayList<>(Arrays.asList(digitsString.split("\\d+")));

        System.out.println("\n4. Division par des chiffres:");
        for (String fruit : fruits) {
            System.out.println("  " + fruit);
        }

        // 5. Limiter le nombre de divisions
        String limitString = "one-two-three-four-five";
        ArrayList<String> limitedParts = new ArrayList<>(Arrays.asList(limitString.split("-", 3)));

        System.out.println("\n5. Limiter le nombre de divisions (limit=3):");
        for (String part : limitedParts) {
            System.out.println("  " + part);
        }
    }
}

Enregistrez le fichier et exécutez le programme :

javac DelimiterDemo.java
java DelimiterDemo

Vous devriez voir une sortie similaire à :

1. Division par une virgule:
  red
  green
  blue
  yellow

2. Division par un espace:
  Java
  Python
  C++
  JavaScript
  Ruby

3. Division par plusieurs caractères (| ou :):
  name
  John
  age
  30
  city
  New York

4. Division par des chiffres:
  apple
  banana
  cherry

5. Limiter le nombre de divisions (limit=3):
  one
  two
  three-four-five

Comprendre les différents types de délimiteurs

  1. Délimiteur à caractère unique : La forme la plus simple, comme les virgules ou les espaces.

    string.split(",")
  2. Délimiteurs de classe de caractères : Diviser par n'importe quel caractère d'un ensemble.

    string.split("[|:]")  // Diviser par '|' ou ':'
  3. Délimiteurs d'expression régulière : Pour des motifs plus complexes.

    string.split("\\d+")  // Diviser par un ou plusieurs chiffres
  4. Limiter les divisions : Le deuxième paramètre limite le nombre de divisions.

    string.split("-", 3)  // Max 3 parties (2 divisions)

Caractères spéciaux dans les expressions régulières

Lorsque vous utilisez des expressions régulières comme délimiteurs, certains caractères ont des significations spéciales et doivent être échappés avec une barre oblique inversée (\). Puisque la barre oblique inversée elle-même doit être échappée dans les chaînes de caractères Java, vous vous retrouvez avec des doubles barres obliques inversées (\\).

Quelques caractères spéciaux courants :

  • \d - Correspond à n'importe quel chiffre (en Java, écrivez comme \\d)
  • \s - Correspond à n'importe quel caractère d'espacement (en Java, écrivez comme \\s)
  • . - Correspond à n'importe quel caractère (en Java, écrivez comme \\.)
  • +, *, ? - Quantificateurs (en Java, écrivez comme \\+, \\*, \\?)

Ces exemples démontrent la polyvalence de la méthode split() pour gérer divers formats de chaînes de caractères et les exigences de vos applications Java.

Résumé

Dans ce laboratoire, vous avez appris à diviser des chaînes de caractères en ArrayLists en utilisant des délimiteurs en Java. Vous avez acquis une expérience pratique avec :

  • La compréhension et l'utilisation des chaînes de caractères (Strings) et des ArrayLists en Java
  • L'utilisation de la méthode split() pour diviser les chaînes de caractères en fonction des délimiteurs
  • La conversion de tableaux de chaînes de caractères en ArrayLists pour une manipulation des données plus flexible
  • L'utilisation de différents types de délimiteurs, y compris les caractères uniques, les classes de caractères et les expressions régulières (regular expressions)
  • Le contrôle du processus de division avec les paramètres de limite

Ces compétences de manipulation de chaînes de caractères sont fondamentales en programmation Java et vous aideront dans divers scénarios, notamment l'analyse des données provenant de fichiers, le traitement des entrées utilisateur et l'utilisation de formats de texte structurés comme CSV ou JSON.

En combinant la puissance des expressions régulières avec les collections Java comme ArrayList, vous pouvez traiter et transformer efficacement les données de chaînes de caractères pour répondre aux exigences de vos applications.