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

Arrays.asList renvoie un List de taille fixe soutenu par le tableau. Si vous voulez un java.util.ArrayList mutable normal, vous devez faire ceci:

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

Ou, en utilisant Goyave :

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

L'utilisation d'un Splitter vous donne plus de flexibilité dans la façon dont vous divisez la chaîne et vous donne la possibilité, par exemple, de sauter des chaînes vides dans les résultats et de couper les résultats. Il a également un comportement moins étrange que String.split et ne vous oblige pas à diviser par regex (c'est juste une option).

Deux étapes:

1. String [] items = commaSeparated.split(",");
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

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

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

Si un List est le but final comme l'a indiqué le PO, alors la réponse déjà acceptée est toujours la plus courte et la meilleure. Cependant, je veux vous fournir des alternatives en utilisant Java 8 Streams , ce qui vous donnera plus d'avantages s'il fait partie d'un pipeline pour un traitement ultérieur.

En enveloppant le résultat de la .divisez la fonction (un tableau natif) en un flux, puis convertissez - la en une 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 que ArrayList selon le titre de L'OP, vous pouvez utiliser une méthode Collector différente:

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

Ou en utilisant L'api D'analyse 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 variable list tapée List<String> au lieu de ArrayList<String>. L'interface générique de List semble encore assez similaire à l'implémentation ArrayList.

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

Par souci d'exhaustivité.

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

Cela devrait fonctionner pour vous.

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

Vous pouvez combiner asList et split

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

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*"));
 ...

Ce code ci-dessous peut vous aider,

List myList = new ArrayList();
String myStr = "item1 , item2 , item3";
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);

Produit ce qui suit:

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

, Vous pouvez d'abord les séparer à l'aide de String.split(","), puis convertir la Chaîne renvoyée array pour un ArrayList utiliser Arrays.asList(array)

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

list = str.tokenize(',')

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

// enter code here

J'utilise habituellement un motif précompilé pour la liste. Et c'est aussi un peu plus universel car il peut considérer les parenthèses 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();

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

Il y a plusieurs façons de résoudre cela en utilisant des flux dans Java 8 mais IMO les liners suivants 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 le faire comme suit.

Cela supprime les espaces blancs et divisé par une virgule où vous n'avez pas besoin de 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);

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

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

(écrit en kotlin)

String -> Collection conversion: (String -> String[] -> 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 - > Chaîne [] conversion:

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

Chaîne - > Chaîne [] conversion:

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 des éléments ["A","B","C" ,"D"]-

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

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

Et convertir le tableau de Chaînes en liste en 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(",");