Java 如何将逗号分隔的字符串转换为列表？

Java中是否有任何内置方法允许我们将逗号分隔的字符串转换为某种容器（例如数组、列表或向量）？或者我需要为此编写自定义代码吗

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

String commaSeparated=“item1、item2、item3”；
List items=//将上述字符串转换为List的方法？？

两个步骤：

String[]items=commaSeparated.split（\\s*，\\s*）

List container=Arrays.asList（items）

---

您可以将asList和split组合在一起

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

---

将逗号分隔的字符串转换为列表

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

List items=Arrays.asList（str.split（“\\s*，\\s*”）；

上面的代码将分隔符上的字符串拆分为：

零个或多个空格、文字逗号、零个或多个空格

，这将把单词放入列表中，并折叠单词和逗号之间的任何空格

---

---

请注意，这只返回数组上的一个包装器：您不能例如

.remove（）

从结果的

列表

。对于实际的

ArrayList

您必须进一步使用

new ArrayList

您可以首先使用

String.split（“，”

）拆分它们，然后使用

Arrays.asList（array）
List items=Arrays.asList（commasepared.split（“，”）将返回的字符串
array
转换为
ArrayList；

这应该适合您。
数组。asList
返回数组支持的固定大小的
列表。如果您想要一个普通的可变
java.util.ArrayList
，您需要执行以下操作：

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

List List=newarraylist（Arrays.asList（string.split（“，”））；

或者，使用：

List List=Lists.newArrayList（Splitter.on（“，”）.split（string））；

使用
拆分器
可以更灵活地拆分字符串，并可以在结果中跳过空字符串和修剪结果。它的奇怪行为也比String.split要少，而且不需要按正则表达式进行拆分（这只是一个选项）。
没有内置的方法，但您可以在这里简单地使用split（）方法

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

String commaSeparated=“item1、item2、item3”；
ArrayList项=
新的ArrayList（Arrays.asList（commaSeparated.split（“，”））；
在groovy中，可以使用标记化（字符标记）方法：

使用
集合的示例

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

import java.util.Collections；
...
字符串commaSeparated=“item1、item2、item3”；
ArrayList items=新建ArrayList（）；
Collections.addAll（项目，逗号分隔.split（“\\s*，\\s*”）；
...
下面是另一个将CSV转换为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));
}

String str=“字符串，带逗号”；
ArrayList aList=新的ArrayList（Arrays.asList（str.split（“，”））；
对于（int i=0；istring

-->与

-->逗号

这个代码会有帮助

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

如果一个
列表
是OP所述的最终目标，那么已经接受的答案仍然是最短和最好的。但是，我想提供使用的替代方案，如果它是进一步处理的管道的一部分，这将给您带来更多好处

通过将.split函数（本机数组）的结果包装到流中，然后转换为列表

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

或者使用正则表达式解析api：

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

ArrayList列表=
Pattern.compile（“，”）
.分流（“a、b、c”）
.collect（收集器.toCollection（ArrayList:：new））；

注意，您仍然可以考虑“<代码>列表> <代码>变量> <代码>列表>代码>而不是<代码> ARRAYLIST/COD>。
就其本身而言，这些代码示例似乎并没有增加多少内容（除了更多的键入），但如果您打算做更多的事情，比如示例，流式API通过允许一个接一个地管道化您的操作而真正强大
你知道，为了完整性的缘故。
ArrayList mListmain=new ArrayList（）；
ArrayList<HashMap<String, String>> mListmain = new ArrayList<HashMap<String, String>>(); 
String marray[]= mListmain.split(",");

字符串marray[]=mListmain.split（“，”）；
String->Collection转换：（String->String[]->Collection）

字符串->字符串[]转换：

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

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

和收藏->收藏：

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

List List=新链接列表（col）；
< />代码> 我通常使用列表的预编译模式，而且这是稍微更通用的，因为它可以考虑遵循ListToScript表达式的括号。

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

private static final Pattern listastring=Pattern.compile（“^\\[？（[^\\[\\]*）\\]？$”；
私有列表getList（字符串值）{
Matcher Matcher=listAsString.Matcher（（字符串）值）；
if（matcher.matches（））{
字符串[]split=matcher.group（matcher.groupCount（））.split（\\s*，\\s*）；
返回新的ArrayList（Arrays.asList（split））；
}
返回集合。emptyList（）；
将集合转换为字符串，在Java 8中以逗号分隔

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

listOfString对象包含[“A”、“B”、“C”、“D”]元素-

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

输出为：-
“A”，“B”，“C”，“D”

并在Java 8中将字符串数组转换为列表

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

String[]={“A”、“B”、“C”、“D”}；
List listOfString=Stream.of（string.collect（Collectors.toList（））；
List items=Arrays.asList（s.split（“[，\\s]+”）；
列表项=流（commaSeparated.split（“，”））
.map（字符串：：trim）
.collect（toList（））；
您可以使用Guava拆分字符串，并将其转换为ArrayList。这也适用于空字符串，并返回空列表

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

在Java8中使用streams有很多方法可以解决这个问题，但在我看来，下面的一行代码是直截了当的：

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

String commaSeparated=“item1、item2、item3”；
List result1=Arrays.stream（逗号分隔的.split（“，”））
收集
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();

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

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

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

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

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

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

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

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

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

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

StringUtils.isBlank(commaSeparatedEmailList) ?
            Collections.emptyList() :
            Stream.of(StringUtils.split(commaSeparatedEmailList, ','))
                    .map(String::trim)
                    .filter(StringUtils::isNotBlank)
                    .collect(Collectors.toList());