J’ai découvert récemment un excellent article sur le blog Java67 qui abordait une problématique que je rencontre régulièrement dans mes projets Java, particulièrement lors du traitement de fichiers CSV : comment transformer efficacement une chaîne de caractères contenant des éléments séparés par des virgules en ArrayList ? Cette question peut sembler simple au premier abord, mais elle révèle en réalité plusieurs subtilités intéressantes que tout développeur Java devrait maîtriser.
Si cette problématique vous intéresse, elle s’inscrit dans une réflexion plus large sur les structures de données Java. Vous pouvez consulter notre article ArrayList vs LinkedList en Java : Comprendre les différences fondamentales pour comprendre pourquoi le choix d’ArrayList est souvent pertinent dans un contexte comme celui-ci.
Le problème concret
Imaginez que vous disposez d’une chaîne de caractères comme « Samsung, Apple, Sony, Google, Microsoft, Amazon » et que vous souhaitiez la convertir en ArrayList contenant tous ces éléments individuellement. Java ne fournit malheureusement aucun constructeur ou méthode factory directe pour créer une ArrayList à partir d’une chaîne délimitée, mais il existe une approche élégante combinant plusieurs méthodes existantes.
La solution en trois étapes
La technique que je vais vous présenter utilise une combinaison de String.split() et Arrays.asList() pour obtenir le résultat souhaité. Le processus se décompose en trois étapes fondamentales :
Étape 1 : Division de la chaîne délimitée
La première étape consiste à utiliser la méthode split() pour diviser votre chaîne sur le délimiteur choisi (ici la virgule). Cette opération vous donnera un tableau de chaînes de caractères :
String csv = "Apple, Google, Samsung";
String[] elements = csv.split(",");
Étape 2 : Conversion du tableau en liste
Ensuite, vous pouvez passer ce tableau à la méthode Arrays.asList() pour créer une liste. Attention cependant : cette liste aura une longueur fixe et ne sera pas une véritable ArrayList modifiable :
List<String> fixedLengthList = Arrays.asList(elements);
Étape 3 : Création d’une ArrayList modifiable
La dernière étape consiste à créer une ArrayList en copiant le contenu de la liste à longueur fixe. Les collections Java fournissent un constructeur de copie qui copiera tous les éléments de la liste source vers votre nouvelle ArrayList, qui sera cette fois-ci une ArrayList standard où vous pourrez ajouter, supprimer et modifier des éléments :
ArrayList<String> listOfString = new ArrayList<String>(fixedLengthList);
Exemple complet en action
Voici comment mettre en pratique cette technique :
String csv = "Apple, Google, Samsung";
// Étape 1 : conversion de la chaîne séparée par des virgules en tableau de chaînes
String[] elements = csv.split(",");
// Étape 2 : conversion du tableau de chaînes en liste de chaînes
List<String> fixedLengthList = Arrays.asList(elements);
// Étape 3 : copie de la liste fixe vers une ArrayList
ArrayList<String> listOfString = new ArrayList<String>(fixedLengthList);
System.out.println("Liste créée depuis une chaîne séparée par des virgules : " + listOfString);
System.out.println("Taille de l'ArrayList : " + listOfString.size());
Sortie :
Liste créée depuis une chaîne séparée par des virgules : [Apple, Google, Samsung] Taille de l'ArrayList : 3
Gestion des espaces avec les expressions régulières
Un point important à retenir : la méthode String.split() accepte une expression régulière comme paramètre. Dans notre exemple basique, « , » correspond simplement à toute virgule, mais cela ne supprime pas les espaces avant ou après.
Notes : Les améliorations continues du pattern matching en Java (comme dans les récentes JEPs) montrent l’importance croissante des expressions régulières et du traitement de chaînes dans l’écosystème Java moderne.
Si votre chaîne contient des espaces indésirables comme « Apple, Google, Samsung », vous obtiendrez » Google » avec un espace de tête. Pour éviter d’avoir à utiliser trim() sur chaque élément, vous pouvez affiner votre expression régulière.
Au lieu d’utiliser simplement « , », vous pouvez utiliser « \s*,\s* ». Cette expression régulière peut paraître intimidante, mais elle est en réalité assez simple à comprendre :
\scorrespond à tout caractère d’espacement (espaces, tabulations)*signifie « zéro ou plusieurs fois »- Donc
\s*correspond à zéro ou plusieurs espaces
Comme nous devons échapper les barres obliques inverses en Java, « \s » devient « \s* ». Notre expression régulière complète « \s*,\s* » signifie : « zéro ou plusieurs espaces, puis une virgule, puis zéro ou plusieurs espaces ».
String csv = "Apple, Google, Samsung";
String[] elements = csv.split("\\s*,\\s*");
Cette approche supprimera automatiquement les espaces de tête et de queue autour des virgules, donnant un résultat plus propre.
Extension à d’autres délimiteurs
La beauté de cette approche réside dans sa flexibilité. Vous pouvez l’adapter pour n’importe quel type de délimiteur : pipe (|), deux-points (:), point-virgule (;), etc.
Voici un exemple avec un délimiteur pipe :
String csv = "Java|Ruby|Python|Perl";
// Le pipe a une signification spéciale en regex (condition OU)
// Il faut l'entourer de crochets pour l'utiliser littéralement
String[] elements = csv.split("\\s*[|]\\s*");
List<String> fixedLengthList = Arrays.asList(elements);
ArrayList<String> listOfString = new ArrayList<String>(fixedLengthList);
System.out.println("Liste créée depuis une chaîne délimitée par des pipes : " + listOfString);
Bonnes pratiques et recommandations
Dans un contexte professionnel, je recommande fortement de créer une méthode utilitaire pour encapsuler cette logique. Cela vous permettra de réutiliser le code partout où vous en avez besoin, sans avoir à recréer la logique à chaque fois :
public static ArrayList<String> stringToArrayList(String delimitedString, String delimiter) {
if (delimitedString == null || delimitedString.isEmpty()) {
return new ArrayList<>();
}
String[] elements = delimitedString.split("\\s*" + Pattern.quote(delimiter) + "\\s*");
List<String> fixedLengthList = Arrays.asList(elements);
return new ArrayList<>(fixedLengthList);
}
Si vous travaillez dans une grande organisation, il est probable qu’une bibliothèque interne contienne déjà ce type de méthodes. Pensez à vérifier avant de créer votre propre implémentation.
Notes : La manipulation fréquente de chaînes et de collections peut créer des problèmes de mémoire si elle n’est pas bien gérée, vous trouverez plus d’informations à ce sujet dans notre article Fuite Mémoire en Java : Comprendre et Maîtriser.
Points essentiels à retenir
Cette technique révèle plusieurs concepts fondamentaux du développement Java qu’il est important de maîtriser :
Premièrement, la distinction entre les différents types de listes en Java. La liste renvoyée par Arrays.asList() est une liste à longueur fixe – vous ne pouvez pas ajouter ou supprimer d’éléments. C’est pourquoi nous créons une ArrayList standard en copiant son contenu.
Deuxièmement, la puissance des expressions régulières avec String.split(). Comprendre comment utiliser correctement les regex peut considérablement améliorer la qualité de votre traitement de chaînes.
Troisièmement, l’importance de l’encapsulation. Créer une méthode utilitaire réutilisable est toujours préférable à la duplication de code.
Cette approche simple mais efficace vous permettra de gérer facilement la conversion de chaînes délimitées en ArrayList dans tous vos projets Java, en évitant les pièges courants et en produisant un code propre et maintenable.
Pour aller plus loin, cette technique de base peut être utile dans des contextes plus avancés comme le traitement de données en masse, problématique présentée dans notre article Mise à jour et suppression en masse avec JPA et Hibernate.