Comment convertir une chaîne séparée par des virgules en ArrayList?

Existe-t-il une méthode intégrée en Java qui nous permet de convertir une chaîne séparée par des virgules en un conteneur (par exemple un tableau, une liste ou un vecteur)? Ou dois-je écrire du code personnalisé pour cela?

String commaSeparated = "item1 , item2 , item3";
ArrayList<String> items = //method that converts above string into list??

Convertir une chaîne séparée par des virgules en liste

List<String> items = Arrays.asList(str.split("\\s*,\\s*"));

Le code ci-dessus divise la chaîne sur un délimiteur défini comme: zero or more whitespace, a literal comma, zero or more whitespacequi placera les mots dans la liste et réduira tout espace entre les mots et les virgules.

Veuillez noter que cela renvoie simplement un wrapper sur un tableau: vous NE POUVEZ PAS par exemple à .remove()partir du résultat List. Pour un réel, ArrayListvous devez continuer à utiliser new ArrayList<String>.

Arrays.asListrenvoie une taille fixe Listsoutenue par le tableau. Si vous voulez un mutable normal, java.util.ArrayListvous devez le faire:

List<String> list = new ArrayList<String>(Arrays.asList(string.split(" , ")));

Ou, en utilisant la goyave :

List<String> list = Lists.newArrayList(Splitter.on(" , ").split(string));

L'utilisation de a Splittervous donne plus de flexibilité dans la façon dont vous fractionnez la chaîne et vous permet, par exemple, d'ignorer les chaînes vides dans les résultats et de couper les résultats. Il a également un comportement moins étrange que String.splitde ne pas vous obliger à diviser par regex (ce n'est qu'une option).

Deux étapes:

1. String [] items = commaSeparated.split("\\s*,\\s*");
2. List<String> container = Arrays.asList(items);

En voici un autre pour convertir CSV en ArrayList:

String str="string,with,comma";
ArrayList aList= new ArrayList(Arrays.asList(str.split(",")));
for(int i=0;i<aList.size();i++)
{
    System.out.println(" -->"+aList.get(i));
}

Vous imprime

-> chaîne
-> avec
-> virgule

Si a Listest l'objectif final comme l'OP l'a indiqué, alors la réponse déjà acceptée est toujours la plus courte et la meilleure. Cependant, je veux fournir des alternatives utilisant Java 8 Streams , qui vous donneront plus d'avantages si elles font partie d'un pipeline pour un traitement ultérieur.

En encapsulant le résultat de la fonction .split (un tableau natif) dans un flux, puis en le convertissant en liste.

List<String> list =
  Stream.of("a,b,c".split(","))
  .collect(Collectors.toList());

S'il est important que le résultat soit stocké en tant ArrayListque selon le titre de l'OP, vous pouvez utiliser une Collectorméthode différente :

ArrayList<String> list = 
  Stream.of("a,b,c".split(","))
  .collect(Collectors.toCollection(ArrayList<String>::new));

Ou en utilisant l'API d'analyse de RegEx:

ArrayList<String> list = 
  Pattern.compile(",")
  .splitAsStream("a,b,c")
  .collect(Collectors.toCollection(ArrayList<String>::new));

Notez que vous pouvez toujours envisager de laisser la listvariable tapée comme List<String>au lieu de ArrayList<String>. L'interface générique de Listsemble toujours assez similaire à laArrayList implémentation.

En eux-mêmes, ces exemples de code ne semblent pas en ajouter beaucoup (sauf plus de frappe), mais si vous prévoyez d'en faire plus, comme cette réponse sur la conversion d'une chaîne en une liste de Longs montre , l'API de streaming est vraiment puissante en permettant pour canaliser vos opérations les unes après les autres.

Pour le bien, vous savez, l'exhaustivité.

List<String> items= Stream.of(commaSeparated.split(","))
     .map(String::trim)
     .collect(toList());

Il n'y a pas de méthode intégrée pour cela, mais vous pouvez simplement utiliser la méthode split () dans cela.

String commaSeparated = "item1 , item2 , item3";
ArrayList<String> items = 
new  ArrayList<String>(Arrays.asList(commaSeparated.split(",")));

List<String> items = Arrays.asList(commaSeparated.split(","));

Cela devrait fonctionner pour vous.

vous pouvez combiner asList et diviser

Arrays.asList(CommaSeparated.split("\\s*,\\s*"))

Ce code vous aidera,

String myStr = "item1,item2,item3";
List myList = Arrays.asList(myStr.split(","));

Vous pouvez utiliser Guava pour diviser la chaîne et la convertir en ArrayList. Cela fonctionne également avec une chaîne vide et renvoie une liste vide.

import com.google.common.base.Splitter;
import com.google.common.collect.Lists;

String commaSeparated = "item1 , item2 , item3";

// Split string into list, trimming each item and removing empty items
ArrayList<String> list = Lists.newArrayList(Splitter.on(',').trimResults().omitEmptyStrings().splitToList(commaSeparated));
System.out.println(list);

list.add("another item");
System.out.println(list);

génère les éléments suivants:

[item1, item2, item3]
[item1, item2, item3, another item]

Un exemple utilisant Collections.

import java.util.Collections;
 ...
String commaSeparated = "item1 , item2 , item3";
ArrayList<String> items = new ArrayList<>();
Collections.addAll(items, commaSeparated.split("\\s*,\\s*"));
 ...

Il existe de nombreuses façons de résoudre ce problème en utilisant des flux dans Java 8, mais les lignes suivantes de l'OMI sont simples:

String  commaSeparated = "item1 , item2 , item3";
List<String> result1 = Arrays.stream(commaSeparated.split(" , "))
                                             .collect(Collectors.toList());
List<String> result2 = Stream.of(commaSeparated.split(" , "))
                                             .collect(Collectors.toList());

Vous pouvez tout d' abord les séparer à l' aide String.split(","), puis convertir la chaîne de retour arrayà une ArrayListaide deArrays.asList(array)

Dans groovy, vous pouvez utiliser la méthode tokenize (Character Token):

list = str.tokenize(',')

Même résultat que vous pouvez obtenir en utilisant la classe Splitter.

var list = Splitter.on(",").splitToList(YourStringVariable)

(écrit en kotlin)

List commaseperated = new ArrayList();
String mylist = "item1 , item2 , item3";
mylist = Arrays.asList(myStr.trim().split(" , "));

// enter code here

J'utilise généralement un modèle précompilé pour la liste. Et cela est également légèrement plus universel car il peut considérer les crochets qui suivent certaines des expressions listToString.

private static final Pattern listAsString = Pattern.compile("^\\[?([^\\[\\]]*)\\]?$");

private List<String> getList(String value) {
  Matcher matcher = listAsString.matcher((String) value);
  if (matcher.matches()) {
    String[] split = matcher.group(matcher.groupCount()).split("\\s*,\\s*");
    return new ArrayList<>(Arrays.asList(split));
  }
  return Collections.emptyList();

Dans Kotlin, si votre liste de chaînes comme celle-ci et que vous pouvez utiliser pour convertir une chaîne en ArrayList, utilisez cette ligne de code

var str= "item1, item2, item3, item4"
var itemsList = str.split(", ")

List<String> items = Arrays.asList(s.split("[,\\s]+"));

Vous pouvez le faire comme suit.

Cela supprime les espaces blancs et les divise par des virgules où vous n'avez pas à vous soucier des espaces blancs.

    String myString= "A, B, C, D";

    //Remove whitespace and split by comma 
    List<String> finalString= Arrays.asList(myString.split("\\s*,\\s*"));

    System.out.println(finalString);

Chaîne -> Conversion de collection : (Chaîne -> Chaîne [] -> Collection)

//         java version 8

String str = "aa,bb,cc,dd,aa,ss,bb,ee,aa,zz,dd,ff,hh";

//          Collection,
//          Set , List,
//      HashSet , ArrayList ...
// (____________________________)
// ||                          ||
// \/                          \/
Collection<String> col = new HashSet<>(Stream.of(str.split(",")).collect(Collectors.toList()));

Collection -> Conversion chaîne [] :

String[] se = col.toArray(new String[col.size()]);

Chaîne -> Conversion chaîne [] :

String[] strArr = str.split(",");

Et Collection -> Collection :

List<String> list = new LinkedList<>(col);

convertir la collection en chaîne comme une virgule séparée dans Java 8

L'objet listOfString contient les éléments ["A", "B", "C", "D"]

listOfString.stream().map(ele->"'"+ele+"'").collect(Collectors.joining(","))

La sortie est: - 'A', 'B', 'C', 'D'

Et convertir un tableau de chaînes en liste dans Java 8

    String string[] ={"A","B","C","D"};
    List<String> listOfString = Stream.of(string).collect(Collectors.toList());

ArrayList<HashMap<String, String>> mListmain = new ArrayList<HashMap<String, String>>(); 
String marray[]= mListmain.split(",");