Jak przekonwertować ciąg rozdzielany przecinkami na ArrayList?

Czy jest jakaś wbudowana metoda w Javie, która pozwala nam konwertować ciąg znaków rozdzielany przecinkami na jakiś kontener (np. Tablicę, listę lub wektor)? Czy też muszę do tego napisać niestandardowy kod?

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

Konwertuj łańcuch rozdzielony przecinkami na listę

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

Powyższy kod dzieli ciąg na separator zdefiniowany jako:, zero or more whitespace, a literal comma, zero or more whitespacektóry umieści słowa na liście i zwinie wszelkie spacje między słowami a przecinkami.

Pamiętaj, że to zwraca po prostu opakowanie w tablicy: NIE MOŻESZ na przykład .remove()wynikać z wynikowego List. W rzeczywistości ArrayListmusisz dalej korzystać new ArrayList<String>.

Arrays.asListzwraca stały rozmiar Listwspierany przez tablicę. Jeśli chcesz normalnego mutable java.util.ArrayList, musisz to zrobić:

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

Lub za pomocą Guava :

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

Użycie a Splitterdaje większą elastyczność w dzieleniu łańcucha i daje możliwość, na przykład, pomijania pustych łańcuchów w wynikach i przycinania wyników. Ma również mniej dziwne zachowanie niż String.splitnie wymaga dzielenia przez regex (to tylko jedna opcja).

Dwa kroki:

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

Oto kolejny sposób konwersji CSV na 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));
}

Drukuje cię

-> ciąg
-> z
-> przecinek

Jeśli a Listjest celem końcowym, jak stwierdził PO, to już zaakceptowana odpowiedź jest wciąż najkrótsza i najlepsza. Chciałbym jednak przedstawić alternatywne rozwiązania wykorzystujące strumienie Java 8 , które przyniosą więcej korzyści, jeśli będą częścią potoku do dalszego przetwarzania.

Zawijając wynik funkcji .split (macierz macierzysta) do strumienia, a następnie konwertując na listę.

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

Jeśli ważne jest, aby wynik był zapisany jak ArrayListw tytule z PO, możesz użyć innej Collectormetody:

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

Lub używając interfejsu analizującego RegEx:

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

Zauważ, że nadal możesz rozważyć pozostawienie listzmiennej wpisanej jako List<String>zamiast ArrayList<String>. Ogólny interfejs dla Listnadal wygląda dość podobnie do ArrayListimplementacji.

Same przykłady w kodzie nie wydają się dużo dodawać (oprócz więcej pisania), ale jeśli planujesz zrobić więcej, na przykład ta odpowiedź na temat konwersji ciągu znaków na listę długich , interfejs API przesyłania strumieniowego jest naprawdę potężny, ponieważ umożliwia aby potokować swoje operacje jedna po drugiej.

Ze względu na kompletność.

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

Nie ma do tego wbudowanej metody, ale możesz po prostu użyć w tym celu metody split ().

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

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

To powinno ci pomóc.

możesz łączyć asList i split

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

Ten kod pomoże,

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

Możesz użyć Guava, aby podzielić ciąg i przekonwertować go na ArrayList. Działa to również z pustym ciągiem i zwraca pustą listę.

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

wyprowadza następujące:

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

Przykład użycia Collections.

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

Istnieje wiele sposobów rozwiązania tego problemu za pomocą strumieni w Javie 8, ale IMO następujące linijki są proste:

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

Możesz najpierw podzielić je za pomocą String.split(","), a następnie przekonwertować zwrócony ciąg arrayna za ArrayListpomocąArrays.asList(array)

W groovy możesz użyć metody tokenize (token znakowy):

list = str.tokenize(',')

Ten sam wynik można osiągnąć za pomocą klasy Splitter.

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

(napisane w kotlin)

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

// enter code here

Zwykle używam wstępnie skompilowanego wzorca dla listy. Jest to również nieco bardziej uniwersalne, ponieważ może uwzględniać nawiasy następujące po wyrażeniach 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();

W Kotlin, jeśli twoja lista ciągów w ten sposób i możesz użyć do konwersji ciągu na ArrayList, użyj tego wiersza kodu

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

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

Możesz to zrobić w następujący sposób.

To usuwa białe spacje i dzieli je przecinkami, dzięki czemu nie musisz się martwić o białe spacje.

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

String -> Konwersja kolekcji : (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()));

Kolekcja -> Konwersja ciągu [] :

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

Konwersja String -> String [] :

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

I Kolekcja -> Kolekcja :

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

konwertuj Collection na ciąg znaków jako przecinek oddzielony w Javie 8

Obiekt listOfString zawiera elementy [„A”, „B”, „C”, „D”]

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

Dane wyjściowe to: - „A”, „B”, „C”, „D”

I przekonwertuj tablicę ciągów na listę w Javie 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(",");