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

Question

这个问题的答案是社区的努力。 编辑现有答案以改进这篇文章。 它目前不接受新的答案或互动。

我有一个ArrayList ，我想完全输出为字符串。 本质上，我想使用由制表符分隔的每个元素的toString按顺序输出它。 有没有什么快速的方法可以做到这一点？ 您可以遍历它（或删除每个元素）并将其连接到一个字符串，但我认为这会很慢。

Answer 1

在 Java 8 或更高版本中：

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

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

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

Answer 2

如果您碰巧在 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 之外没有多少用处，但我想我会把它添加到这个线程......

Answer 3

Java 8 引入了一个String.join(separator, list)方法； 见Vitalii Federenko 的回答。

在 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 。

Answer 4

下载Apache Commons Lang并使用方法

 StringUtils.join(list)

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

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

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

Answer 5

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

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

Answer 6

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

永远不要自己构建轮子，不要使用循环来完成这项单线任务。

Answer 7

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

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

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

myList.toString()

它返回一个字符串

[str1, str2, str3]

如果您有一个数组（不是 ArrayList），那么您可以像这样完成相同的操作：

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

Answer 8

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

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

Answer 9

大多数 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

分隔符- 要使用的分隔符

返回：连接的字符串，如果迭代器输入为空，则为空

自：2.3

Answer 10

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

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

Answer 11

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

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

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

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

Answer 12

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

Answer 13

处理尾随分隔符的一种优雅方式是使用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 方法返回分隔符，除了第一次调用。 因此，我们打印没有尾随（或在这种情况下）前导分隔符的列表。

Answer 14

ArrayList类（ Java文档 ）扩展AbstractList类，它扩展AbstractCollection含有类toString()方法（ Java文档 ）。 所以你只要写

listName.toString();

Java开发人员已经找到了最有效的方法，并以一种经过很好打包和记录的方法为您提供了这种方法。 只需调用该方法即可。

Answer 15

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

只需使用StringBuilder如下：

StringBuilder sb = new StringBuilder();

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

String finalString = sb.toString();

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

Answer 16

如果您碰巧在 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()。

Answer 17

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

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

Answer 18

如果您不想要最后一个元素之后的最后一个 \\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());

Answer 19

如果您使用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 的提交者。

Answer 20

下面的代码可以帮助你，

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

Answer 21

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

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]

Answer 22

以下是否有好处：

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

Answer 23

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

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

Answer 24

要使用制表符而不是使用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");
}

Answer 25

我看到了很多依赖于额外资源的例子，但这似乎是最简单的解决方案：（这是我在我自己的项目中使用的）基本上只是从 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;
   }

Answer 26

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

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

Answer 27

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

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

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

Answer 28

这个功能怎么样：

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

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