在Java中用逗号分隔列表最清晰的方法是什么？
我知道几种方法，但我想知道最好的方法是什么（“最佳”意味着最清晰和/或最短，而不是最有效。
我有一个列表，我想循环它，打印每个值。我想在每个项目之间打印一个逗号，但不是在最后一个项目之后（也不是在第一个项目之前）。
List --> Item ( , Item ) *
List --> ( Item , ) * Item
样品溶液1：
boolean isFirst = true;
for (Item i : list) {
if (isFirst) {
System.out.print(i); // no comma
isFirst = false;
} else {
System.out.print(", "+i); // comma
}
}
示例解决方案2 - 创建子列表：
if (list.size()>0) {
System.out.print(list.get(0)); // no comma
List theRest = list.subList(1, list.size());
for (Item i : theRest) {
System.out.print(", "+i); // comma
}
}
样品溶液3：
Iterator<Item> i = list.iterator();
if (i.hasNext()) {
System.out.print(i.next());
while (i.hasNext())
System.out.print(", "+i.next());
}
这些特别对待第一项;一个人可以专门对待最后一个。
顺便说一句，这里是如何在Java 1.6中实现List toString（它继承自AbstractCollection）：
public String toString() {
Iterator<E> i = iterator();
if (! i.hasNext())
return "[]";
StringBuilder sb = new StringBuilder();
sb.append('[');
for (;;) {
E e = i.next();
sb.append(e == this ? "(this Collection)" : e);
if (! i.hasNext())
return sb.append(']').toString();
sb.append(", ");
}
}
它会提前退出循环以避免在最后一项之后使用逗号。顺便说一句：这是我第一次回忆起“（此收藏品）”;这是激发它的代码：
List l = new LinkedList();
l.add(l);
System.out.println(l);
我欢迎任何解决方案，即使他们使用意外的库（regexp？）;还有Java以外的语言解决方案（例如我认为Python / Ruby有一个散布功能 - 如何实现？）。
澄清：通过库，我的意思是标准的Java库。对于其他图书馆，我认为它们与其他语言一样，并且有兴趣知道它们是如何实现的。
EDIT工具包提到了一个类似的问题：Last iteration of enhanced for loop in java
另一个：Does the last element in a loop deserve a separate treatment?
使用StringJoiner类：
StringJoiner joiner = new StringJoiner(",");
for (Item item : list) {
joiner.add(item.toString());
}
return joiner.toString();
使用Stream和Collectors：
return list.stream().
map(Object::toString).
collect(Collectors.joining(",")).toString();
另见#285523
String delim = "";
for (Item i : list) {
sb.append(delim).append(i);
delim = ",";
}
foreach循环的一个选项是：
StringBuilder sb = new StringBuilder();
for(String s:list){
if (sb.length()>0) sb.append(",");
sb.append(s);
}
StringBuffer result = new StringBuffer();
for(Iterator it=list.iterator; it.hasNext(); ) {
if (result.length()>0)
result.append(", ");
result.append(it.next());
}
更新：正如Dave Webb在评论中提到的，如果列表中的第一项是空字符串，则可能无法产生正确的结果。
我经常这样做：
StringBuffer sb = new StringBuffer();
Iterator it = myList.iterator();
if (it.hasNext()) { sb.append(it.next().toString()); }
while (it.hasNext()) { sb.append(",").append(it.next().toString()); }
虽然我认为我将从现在开始按照Java实现进行检查;）
如果您可以使用Groovy（在JVM上运行）：
def list = ['a', 'b', 'c', 'd']
println list.join(',')
（从here复制我自己答案的粘贴。）这里描述的许多解决方案都有点过头了，恕我直言，尤其是依赖外部库的那些。有一个很好的干净，清晰的习惯用法来实现我一直使用的逗号分隔列表。它依赖于条件（？）运算符：
编辑：原始解决方案正确，但根据评论非最佳。第二次尝试：
int[] array = {1, 2, 3};
StringBuilder builder = new StringBuilder();
for (int i = 0 ; i < array.length; i++)
builder.append(i == 0 ? "" : ",").append(array[i]);
你可以在4行代码中找到，包括数组的声明和StringBuilder。
第2编辑：如果您正在处理迭代器：
List<Integer> list = Arrays.asList(1, 2, 3);
StringBuilder builder = new StringBuilder();
for (Iterator it = list.iterator(); it.hasNext();)
builder.append(it.next()).append(it.hasNext() ? "," : "");
我通常使用类似于版本3的东西。它适用于c / c ++ / bash / ...：P
我没有编译它...但应该工作（或接近工作）。
public static <T> String toString(final List<T> list,
final String delim)
{
final StringBuilder builder;
builder = new StringBuilder();
for(final T item : list)
{
builder.append(item);
builder.append(delim);
}
// kill the last delim
builder.setLength(builder.length() - delim.length());
return (builder.toString());
}
这是非常短暂的，非常清楚，但是让我的敏感性成为匍匐的恐怖。适应不同的分隔符也有点尴尬，特别是如果是String（不是char）。
for (Item i : list)
sb.append(',').append(i);
if (sb.charAt(0)==',') sb.deleteCharAt(0);
StringBuffer sb = new StringBuffer();
for (int i = 0; i < myList.size(); i++)
{
if (i > 0)
{
sb.append(", ");
}
sb.append(myList.get(i));
}
我有点喜欢这种方法，我前段时间在博客上找到了这种方法。不幸的是我不记得博客的名称/网址。
您可以创建一个如下所示的实用程序/帮助程序类：
private class Delimiter
{
private final String delimiter;
private boolean first = true;
public Delimiter(String delimiter)
{
this.delimiter = delimiter;
}
@Override
public String toString()
{
if (first) {
first = false;
return "";
}
return delimiter;
}
}
使用辅助类很简单，如下所示：
StringBuilder sb = new StringBuilder();
Delimiter delimiter = new Delimiter(", ");
for (String item : list) {
sb.append(delimiter);
sb.append(item);
}
org.apache.commons.lang3.StringUtils.join(list,",");
因为您的分隔符是“，”，您可以使用以下任何一种：
public class StringDelim {
public static void removeBrackets(String string) {
System.out.println(string.substring(1, string.length() - 1));
}
public static void main(String... args) {
// Array.toString() example
String [] arr = {"Hi" , "My", "name", "is", "br3nt"};
String string = Arrays.toString(arr);
removeBrackets(string);
// List#toString() example
List<String> list = new ArrayList<String>();
list.add("Hi");
list.add("My");
list.add("name");
list.add("is");
list.add("br3nt");
string = list.toString();
removeBrackets(string);
// Map#values().toString() example
Map<String, String> map = new LinkedHashMap<String, String>();
map.put("1", "Hi");
map.put("2", "My");
map.put("3", "name");
map.put("4", "is");
map.put("5", "br3nt");
System.out.println(map.values().toString());
removeBrackets(string);
// Enum#toString() example
EnumSet<Days> set = EnumSet.allOf(Days.class);
string = set.toString();
removeBrackets(string);
}
public enum Days {
MON("Monday"),
TUE("Tuesday"),
WED("Wednesday"),
THU("Thursday"),
FRI("Friday"),
SAT("Saturday"),
SUN("Sunday");
private final String day;
Days(String day) {this.day = day;}
public String toString() {return this.day;}
}
}
如果您的分隔符是其他任何分隔符，那么这对您不起作用。
我喜欢这个解决方案：
String delim = " - ", string = "";
for (String item : myCollection)
string += delim + item;
string = string.substring(delim.length());
我假设它也可以使用StringBuilder。
在Python中它很容易
“，”。加入（你的名单）
在C＃中，String类上有一个静态方法
String.Join（“，”，yourlistofstrings）
对不起，不确定Java，但是当你问起其他语言时我觉得我已经知道了。我确信在Java中会有类似的东西。
您还可以无条件地添加分隔符字符串，并在循环之后删除末尾的额外分隔符。然后在开头的“if list is empty然后返回此字符串”将允许您在结尾处避免检查（因为您无法从空列表中删除字符）
所以问题确实是：
“考虑到循环和if，你认为将这些结合起来最清楚的方式是什么？”
public static String join (List<String> list, String separator) {
String listToString = "";
if (list == null || list.isEmpty()) {
return listToString;
}
for (String element : list) {
listToString += element + separator;
}
listToString = listToString.substring(0, separator.length());
return listToString;
}
if (array.length>0) // edited in response Joachim's comment
sb.append(array[i]);
for (int i=1; i<array.length; i++)
sb.append(",").append(array[i]);
基于Clearest way to comma-delimit a list (Java)?
使用这个想法：Does the last element in a loop deserve a separate treatment?
public String toString(List<Item> items)
{
StringBuilder sb = new StringBuilder("[");
for (Item item : items)
{
sb.append(item).append(", ");
}
if (sb.length() >= 2)
{
//looks cleaner in C# sb.Length -= 2;
sb.setLength(sb.length() - 2);
}
sb.append("]");
return sb.toString();
}
到目前为止，没有一个答案使用递归...
public class Main {
public static String toString(List<String> list, char d) {
int n = list.size();
if(n==0) return "";
return n > 1 ? Main.toString(list.subList(0, n - 1), d) + d
+ list.get(n - 1) : list.get(0);
}
public static void main(String[] args) {
List<String> list = Arrays.asList(new String[]{"1","2","3"});
System.out.println(Main.toString(list, ','));
}
}
在我看来，这是最简单的阅读和理解：
StringBuilder sb = new StringBuilder();
for(String string : strings) {
sb.append(string).append(',');
}
sb.setLength(sb.length() - 1);
String result = sb.toString();
private String betweenComma(ArrayList<String> strings) {
String united = "";
for (String string : strings) {
united = united + "," + string;
}
return united.replaceFirst(",", "");
}
Java 8提供了几种新方法：
join上的String方法。joining级的流的Collectors收集器。StringJoiner类。例：
// Util method for strings and other char sequences
List<String> strs = Arrays.asList("1", "2", "3");
String listStr1 = String.join(",", strs);
// For any type using streams and collectors
List<Object> objs = Arrays.asList(1, 2, 3);
String listStr2 = objs.stream()
.map(Object::toString)
.collect(joining(",", "[", "]"));
// Using the new StringJoiner class
StringJoiner joiner = new StringJoiner(", ", "[", "]");
joiner.setEmptyValue("<empty>");
for (Integer i : objs) {
joiner.add(i.toString());
}
String listStr3 = joiner.toString();
使用流的方法假设import static java.util.stream.Collectors.joining;。
String join(List<Object> collection, String delimiter){
StringBuilder stringBuilder = new StringBuilder();
int size = collection.size();
for (Object value : collection) {
size --;
if(size > 0){
stringBuilder.append(value).append(delimiter);
}
}
return stringBuilder.toString();
}
鉴于[1,2,3]的数组
join(myArray, ",") // 1,2,3
Joiner.on(",").join(myList)
如果您使用Spring Framework，则可以使用StringUtils执行此操作：
public static String arrayToDelimitedString(Object[] arr)
public static String arrayToDelimitedString(Object[] arr, String delim)
public static String collectionToCommaDelimitedString(Collection coll)
public static String collectionToCommaDelimitedString(Collection coll, String delim)
基于Java的List toString实现：
Iterator i = list.iterator();
for (;;) {
sb.append(i.next());
if (! i.hasNext()) break;
ab.append(", ");
}
它使用这样的语法：
List --> (Item , )* Item
通过基于last而不是first-based，它可以检查具有相同测试的skip-逗号以检查列表的结尾。我觉得这个非常优雅，但我不确定清晰度。
String delimiter = ",";
StringBuilder sb = new StringBuilder();
for (Item i : list) {
sb.append(delimiter).append(i);
}
sb.toString().replaceFirst(delimiter, "");
使用Java 8可以实现这一目标：
List<String> list = Arrays.asList(array);
String joinedString = String.join(",", list);
for(int i=0, length=list.size(); i<length; i++)
result+=(i==0?"":", ") + list.get(i);