将 ArrayList 转换为字符串的最佳方法

在 Java 8 或更高版本中：

String listString = String.join(", ", list);

如果 list 不是字符串类型，则可以使用连接收集器：

String listString = list.stream().map(Object::toString)
                        .collect(Collectors.joining(", "));

---

如果您碰巧在 Android 上执行此操作，则有一个很好的实用程序，称为 TextUtils，它有一个 .join(String delimiter, Iterable) 方法。

List<String> list = new ArrayList<String>();
list.add("Item 1");
list.add("Item 2");
String joined = TextUtils.join(", ", list);

显然在Android之外没有太多用处，但我想我会把它添加到这个线程中......

---

Java 8 引入了一个 String.join(separator, list) 方法；见Vitalii Federenko's answer。

在 Java 8 之前，使用循环遍历 ArrayList 是唯一的选择：

不要使用此代码，请继续阅读此答案的底部以了解为什么不希望使用它，以及应该使用哪个代码：

ArrayList<String> list = new ArrayList<String>();
list.add("one");
list.add("two");
list.add("three");

String listString = "";

for (String s : list)
{
    listString += s + "\t";
}

System.out.println(listString);

事实上，字符串连接会很好，因为 javac 编译器会将字符串连接优化为对 StringBuilder 的一系列 append 操作。以下是上述程序 for 循环中字节码反汇编的一部分：

   61:  new #13; //class java/lang/StringBuilder
   64:  dup
   65:  invokespecial   #14; //Method java/lang/StringBuilder."<init>":()V
   68:  aload_2
   69:  invokevirtual   #15; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   72:  aload   4
   74:  invokevirtual   #15; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   77:  ldc #16; //String \t
   79:  invokevirtual   #15; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   82:  invokevirtual   #17; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;

可以看出，编译器通过使用 StringBuilder 优化了该循环，因此性能应该不是一个大问题。

（好吧，乍一看，循环的每次迭代都会实例化 StringBuilder，因此它可能不是最有效的字节码。实例化和使用显式 StringBuilder 可能会产生更好的性能。）

事实上，我认为拥有任何类型的输出（无论是到磁盘还是到屏幕）都至少比担心字符串连接的性能慢一个数量级。

编辑： 正如评论中所指出的，上述编译器优化确实是在每次迭代时创建一个新的 StringBuilder 实例。 （我之前已经注意到了。）

要使用的最优化技术是 Paul Tomblin 的响应，因为它仅在 for 循环之外实例化单个 StringBuilder 对象。

将上述代码重写为：

ArrayList<String> list = new ArrayList<String>();
list.add("one");
list.add("two");
list.add("three");

StringBuilder sb = new StringBuilder();
for (String s : list)
{
    sb.append(s);
    sb.append("\t");
}

System.out.println(sb.toString());

只会在循环外实例化 StringBuilder 一次，并且只在循环内对 append 方法进行两次调用，如以下字节码所示（显示 StringBuilder 和循环的实例化）：

   // Instantiation of the StringBuilder outside loop:
   33:  new #8; //class java/lang/StringBuilder
   36:  dup
   37:  invokespecial   #9; //Method java/lang/StringBuilder."<init>":()V
   40:  astore_2

   // [snip a few lines for initializing the loop]
   // Loading the StringBuilder inside the loop, then append:
   66:  aload_2
   67:  aload   4
   69:  invokevirtual   #14; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   72:  pop
   73:  aload_2
   74:  ldc #15; //String \t
   76:  invokevirtual   #14; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   79:  pop

因此，确实手部优化的性能应该更好，因为 for 循环的内部更短，并且无需在每次迭代时实例化 StringBuilder。

---

下载 Apache Commons Lang 并使用方法

 StringUtils.join(list)

 StringUtils.join(list, ", ") // 2nd param is the separator.

当然，您可以自己实现它，但他们的代码已经过全面测试，可能是最好的实现。

我是 Apache Commons 库的忠实粉丝，我也认为它是对 Java 标准库的一个很好的补充。

---

这是一个相当古老的问题，但我想我不妨添加一个更现代的答案 - 使用 Guava 中的 Joiner 类：

String joined = Joiner.on("\t").join(list);

---

将 List 更改为可读且有意义的 String 确实是每个人都可能遇到的常见问题。

案例 1. 如果您的类路径中有 apache 的 StringUtils（来自 rogerdpack 和 Ravi Wallau）：

import org.apache.commons.lang3.StringUtils;
String str = StringUtils.join(myList);

案例 2。如果您只想使用 JDK(7) 中的方法：

import java.util.Arrays;
String str = Arrays.toString(myList.toArray()); 

永远不要自己造轮子，不要使用循环来完成这一单行任务。

---

如果您正在寻找一种快速的单线，从 Java 5 开始，您可以这样做：

myList.toString().replaceAll("\\[|\\]", "").replaceAll(", ","\t")

此外，如果您的目的只是打印内容并且不太关心“\t”，您可以简单地执行以下操作：

myList.toString()

它返回一个字符串，如

[str1，str2，str3]

如果你有一个数组（不是 ArrayList），那么你可以像这样完成同样的事情：

 Arrays.toString(myList).replaceAll("\\[|\\]", "").replaceAll(", ","\t")

---

循环遍历它并调用 toString。没有什么神奇的方法，如果有的话，你认为除了循环遍历它之外，它会在幕后做什么？唯一的微优化是使用 StringBuilder 而不是 String，即使这也不是一个巨大的胜利 - 连接字符串在幕后变成了 StringBuilder，但至少如果你这样写，你可以看到发生了什么。

StringBuilder out = new StringBuilder();
for (Object o : list)
{
  out.append(o.toString());
  out.append("\t");
}
return out.toString();

---

大多数 Java 项目通常都有可用的 apache-commons lang。 StringUtils.join() 方法非常好，并且有多种风格可以满足几乎所有需求。

public static java.lang.String join(java.util.Collection collection,
                                    char separator)


public static String join(Iterator iterator, String separator) {
    // handle null, zero and one elements before building a buffer 
    Object first = iterator.next();
    if (!iterator.hasNext()) {
        return ObjectUtils.toString(first);
    }
    // two or more elements 
    StringBuffer buf = 
        new StringBuffer(256); // Java default is 16, probably too small 
    if (first != null) {
        buf.append(first);
    }
    while (iterator.hasNext()) {
        if (separator != null) {
            buf.append(separator);
        }
        Object obj = iterator.next();
        if (obj != null) {
            buf.append(obj);
        }
    }
    return buf.toString();
}

参数：collection - 要连接在一起的值的集合，可以是 null separator - 要使用的分隔符返回：连接的字符串，如果为 null 则为 null

---

Android 有一个 TextUtil 类，您可以使用 http://developer.android.com/reference/android/text/TextUtils.html

String implode = TextUtils.join("\t", list);

---

对于这个简单的用例，您可以简单地用逗号连接字符串。如果您使用 Java 8：

String csv = String.join("\t", yourArray);

否则 commons-lang 有一个 join() 方法：

String csv = org.apache.commons.lang3.StringUtils.join(yourArray, "\t");

---

在 Java 8 中，这很简单。有关整数列表，请参见示例：

String result = Arrays.asList(1,2,3).stream().map(Object::toString).reduce((t, u) -> t + "\t" + u).orElse("");

或多行版本（更易于阅读）：

String result = Arrays.asList(1,2,3).stream()
    .map(Object::toString)
    .reduce((t, u) -> t + "\t" + u)
    .orElse("");

更新 - 更短的版本

String result = Arrays.asList(1,2,3).stream()
                .map(Object::toString)
                .collect(Collectors.joining("\t"));

---

处理尾随分隔符的一种优雅方法是使用 Class Separator

StringBuilder buf = new StringBuilder();
Separator sep = new Separator("\t");
for (String each: list) buf.append(sep).append(each);
String s = buf.toString();

Class Separator 的 toString 方法返回分隔符，但第一次调用除外。因此，我们打印没有尾随（或在这种情况下）前导分隔符的列表。

---

无论哪种方式，它都是一个 O(n) 算法（除非您做了一些多线程解决方案，将列表分成多个子列表，但我认为这不是您所要求的）。

只需使用 StringBuilder，如下所示：

StringBuilder sb = new StringBuilder();

for (Object obj : list) {
  sb.append(obj.toString());
  sb.append("\t");
}

String finalString = sb.toString();

StringBuilder 将比字符串连接快得多，因为您不会在每个连接上重新实例化 String 对象。

---

如果您碰巧在 Android 上并且您还没有使用 Jack（例如，因为它仍然缺乏对 Instant Run 的支持），并且如果您想要更多地控制结果字符串的格式（例如，您想使用换行符作为元素的分隔符），并且碰巧使用/想要使用 StreamSupport 库（用于在 Java 7 或更早版本的编译器上使用流），你可以使用这样的东西（我把这个方法放在我的 ListUtils 类中）：

public static <T> String asString(List<T> list) {
    return StreamSupport.stream(list)
            .map(Object::toString)
            .collect(Collectors.joining("\n"));
}

当然，请确保在列表对象的类上实现 toString()。

---

在一行中：从 [12,0,1,78,12] 到 12 0 1 78 12

String srt= list.toString().replaceAll("\\[|\\]|,","");

---

如果您不想在最后一个元素之后出现最后一个 \t，则必须使用索引来检查，但请记住，这仅在列表实现 RandomAccess 时“有效”（即 O(n)）。

List<String> list = new ArrayList<String>();
list.add("one");
list.add("two");
list.add("three");

StringBuilder sb = new StringBuilder(list.size() * apprAvg); // every apprAvg > 1 is better than none
for (int i = 0; i < list.size(); i++) {
    sb.append(list.get(i));
    if (i < list.size() - 1) {
        sb.append("\t");
    }
}
System.out.println(sb.toString());

---

下面的代码可以帮助你，

List list = new ArrayList();
list.add("1");
list.add("2");
list.add("3");
String str = list.toString();
System.out.println("Step-1 : " + str);
str = str.replaceAll("[\\[\\]]", "");
System.out.println("Step-2 : " + str);

输出：

Step-1 : [1, 2, 3]
Step-2 : 1, 2, 3

---

可能不是最好的方式，但优雅的方式。

Arrays.deepToString(Arrays.asList("Test", "Test2")

import java.util.Arrays;

    public class Test {
        public static void main(String[] args) {
            System.out.println(Arrays.deepToString(Arrays.asList("Test", "Test2").toArray()));
        }
    }

输出

[测试，测试2]

---

以下内容会有什么好处：

List<String> streamValues = new ArrayList<>();
Arrays.deepToString(streamValues.toArray()));   

---

如果您使用 Eclipse Collections，则可以使用 makeString() 方法。

ArrayList<String> list = new ArrayList<String>();
list.add("one");
list.add("two");
list.add("three");

Assert.assertEquals(
    "one\ttwo\tthree",
    ArrayListAdapter.adapt(list).makeString("\t"));

如果您可以将 ArrayList 转换为 FastList，则可以摆脱适配器。

Assert.assertEquals(
    "one\ttwo\tthree",
    FastList.newListWith("one", "two", "three").makeString("\t"));

注意：我是 Eclipse Collections 的提交者。

---

List<String> stringList = getMyListOfStrings();
StringJoiner sj = new StringJoiner(" ");
stringList.stream().forEach(e -> sj.add(e));
String spaceSeparated = sj.toString()

您将要用作分隔符的字符序列传递给 new StringJoiner。如果您想做 CSV：new StringJoiner(", ");

---

要使用制表符而不是使用 println 进行分隔，您可以使用 print

ArrayList<String> mylist = new ArrayList<String>();

mylist.add("C Programming");
mylist.add("Java");
mylist.add("C++");
mylist.add("Perl");
mylist.add("Python");

for (String each : mylist)
{       
    System.out.print(each);
    System.out.print("\t");
}

---

我看到了很多依赖于额外资源的示例，但这似乎是最简单的解决方案：（这是我在自己的项目中使用的）基本上只是从 ArrayList 转换为 Array 然后再转换为 List .

    List<Account> accounts = new ArrayList<>();

   public String accountList() 
   {
      Account[] listingArray = accounts.toArray(new Account[accounts.size()]);
      String listingString = Arrays.toString(listingArray);
      return listingString;
   }

---

到目前为止，这是一个相当古老的对话，apache commons 现在在内部使用 StringBuilder：http://commons.apache.org/lang/api/src-html/org/apache/commons/lang/StringUtils.html#line.3045

正如我们所知，这将提高性能，但如果性能很关键，那么使用的方法可能效率低下。虽然接口很灵活，并且允许跨不同集合类型的一致行为，但对于列表来说效率有点低，这是原始问题中的集合类型。

我之所以这样做是因为我们会产生一些开销，我们可以通过简单地遍历传统 for 循环中的元素来避免这些开销。相反，在检查并发修改、方法调用等的幕后会发生一些额外的事情。另一方面，增强的 for 循环将导致相同的开销，因为迭代器用于 Iterable 对象（列表）。

---

您可以为此使用正则表达式。这是最简洁的

System.out.println(yourArrayList.toString().replaceAll("\\[|\\]|[,][ ]","\t"));

---

这个功能怎么样：

public static String toString(final Collection<?> collection) {
    final StringBuilder sb = new StringBuilder("{");
    boolean isFirst = true;
    for (final Object object : collection) {
        if (!isFirst)
            sb.append(',');
        else
            isFirst = false;
        sb.append(object);
    }
    sb.append('}');
    return sb.toString();
}

它适用于任何类型的收藏...

---