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

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

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

Java 8引入了一个字符串。Join(分隔符，列表)方法;请看维塔利·费连科的回答。

在Java 8之前，使用循环遍历数组列表是唯一的选择:

不要使用这个代码，继续阅读这个答案的底部，看看为什么它是不可取的，以及应该使用哪些代码:

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上的一系列附加操作。下面是上面程序中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。

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

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

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

下面的代码可以帮助你，

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