Eu tenho um ArrayListque eu quero produzir completamente como uma String. Essencialmente, quero exibi-lo em ordem, usando o toStringde cada elemento separado por tabulações. Existe alguma maneira rápida de fazer isso? Você pode fazer um loop através dele (ou remover cada elemento) e concatená-lo em uma String, mas acho que isso será muito lento.

Basicamente, o uso de um loop para iterar sobre a ArrayListé a única opção:

NÃO use esse código, continue lendo na parte inferior desta resposta para ver por que não é desejável e qual código deve ser usado:

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

De fato, uma concatenação de strings será ótima, pois o javaccompilador otimizará a concatenação de strings como uma série de appendoperações StringBuilder. Aqui está uma parte da desmontagem do bytecode do forloop do programa acima:

   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;

Como pode ser visto, o compilador otimiza esse loop usando a StringBuilder, portanto, o desempenho não deve ser uma grande preocupação.

(OK, à segunda vista, ele StringBuilderestá sendo instanciado em cada iteração do loop, portanto, pode não ser o bytecode mais eficiente. Instanciar e usar um explícito StringBuilderprovavelmente produziriam melhor desempenho.)

Na verdade, acho que ter qualquer tipo de saída (seja em disco ou na tela) será pelo menos uma ordem de magnitude mais lenta do que ter que se preocupar com o desempenho de concatenações de strings.

Edit: Como apontado nos comentários, a otimização do compilador acima está de fato criando uma nova instância StringBuilderem cada iteração. (O que observei anteriormente.)

A técnica mais otimizada a ser usada será a resposta de Paul Tomblin , pois apenas instancia um único StringBuilderobjeto fora do forloop.

Reescrevendo o código acima para:

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

Instanciará apenas StringBuilderuma vez fora do loop e fará apenas as duas chamadas para o appendmétodo dentro do loop, conforme evidenciado neste bytecode (que mostra a instanciação StringBuildere o loop):

   // 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

Portanto, a otimização manual deve ter um desempenho melhor, pois o interior do forloop é mais curto e não é necessário instanciar um StringBuilderem cada iteração.

No Java 8 ou posterior:

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

Caso listnão seja do tipo String, um coletor de junção pode ser usado:

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

Se você estiver fazendo isso no Android, existe um bom utilitário para isso chamado TextUtils, que possui um .join(String delimiter, Iterable)método.

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

Obviamente, não uso muito fora do Android, mas achei que eu o adicionaria a este tópico ...

Faça o download do Apache Commons Lang e use o método

 StringUtils.join(list)

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

Você pode implementá-lo sozinho, é claro, mas o código deles é totalmente testado e provavelmente é a melhor implementação possível.

Sou um grande fã da biblioteca Apache Commons e também acho que é um ótimo complemento para a Java Standard Library.

Essa é uma pergunta bastante antiga, mas acho que devo adicionar uma resposta mais moderna - use a Joinerclasse do Guava :

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

Mudar a lista para uma string legível e significativa é realmente uma pergunta comum que todos podem encontrar.

Caso 1 . Se você tiver o StringUtils do apache no caminho da sua classe (como no rogerdpack e Ravi Wallau):

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

Caso 2 . Se você deseja usar apenas maneiras do JDK (7):

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

Apenas nunca construa rodas sozinho, não use loop para esta tarefa de uma linha.

Se você estava procurando uma linha única rápida, a partir do Java 5, você pode fazer isso:

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

Além disso, se seu objetivo é apenas imprimir o conteúdo e estiver menos preocupado com o "\ t", você pode simplesmente fazer o seguinte:

myList.toString()

que retorna uma string como

[str1, str2, str3]

Se você tiver um Array (não ArrayList), poderá fazer o mesmo assim:

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

Faça um loop e chame toString. Não existe uma maneira mágica, e se houvesse, o que você acha que estaria fazendo debaixo das cobertas, a não ser percorrê-la? A única micro-otimização seria usar o StringBuilder em vez do String, e mesmo isso não é uma grande vitória - concatenar seqüências se transforma em StringBuilder sob as cobertas, mas pelo menos se você escrever dessa maneira, poderá ver o que está acontecendo.

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

A maioria dos projetos Java geralmente tem o apache-commons lang disponível. O método StringUtils.join () é muito bom e possui vários sabores para atender quase todas as necessidades.

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

Parâmetros:

coleção - a coleção de valores para unir pode ser nula

separator - o caractere separador a ser usado

Retorna : a entrada de String unida, nula se nula do iterador

Desde: 2.3

O Android tem uma classe TextUtil que você pode usar http://developer.android.com/reference/android/text/TextUtils.html

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

Para este caso de uso simples, você pode simplesmente juntar as cadeias com vírgula. Se você usa o Java 8:

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

caso contrário, commons-lang possui um método join ():

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

Uma maneira elegante de lidar com caracteres de separação à direita é usar o Class Separator

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

O método toString do Class Separator retorna o separador, exceto a primeira chamada. Assim, imprimimos a lista sem arrastar (ou, neste caso) separadores à esquerda.

No Java 8 é simples. Veja o exemplo da lista de números inteiros:

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

Ou versão multilinha (que é mais simples de ler):

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

Atualização - uma versão mais curta

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

É um O(n)algoritmo de qualquer maneira (a menos que você tenha criado uma solução multithread em que você dividiu a lista em várias sublistas, mas acho que não é isso que você está pedindo).

Basta usar um StringBuildercomo abaixo:

StringBuilder sb = new StringBuilder();

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

String finalString = sb.toString();

o StringBuilder será muito mais rápido que concatenação porque você não será re-instanciar um Stringobjeto em cada concatenação.

Caso você esteja no Android e ainda não esteja usando o Jack (por exemplo, porque ainda falta suporte para a Execução Instantânea) e se desejar ter mais controle sobre a formatação da sequência resultante (por exemplo, gostaria de usar o caractere de nova linha como o divisor de elementos) e por acaso usar / desejar usar a biblioteca StreamSupport (para usar fluxos no Java 7 ou versões anteriores do compilador), você poderia usar algo assim (eu coloquei esse método na minha classe ListUtils):

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

E, é claro, certifique-se de implementar toString () na classe dos objetos da lista.

Se você não quiser o último \ t após o último elemento, precisará usar o índice para verificar, mas lembre-se de que isso apenas "funciona" (ou seja, é O (n)) quando a lista implementa o RandomAccess.

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

O código abaixo pode ajudá-lo,

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

Resultado:

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

Pode não ser o melhor caminho, mas o caminho elegante.

Arrays.deepToString (Arrays.asList ("Teste", "Teste2")

import java.util.Arrays;

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

Resultado

[Teste, Teste2]

Seria bom o seguinte:

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

Se você estiver usando o Eclipse Collections , poderá usar o makeString()método

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

Se você pode converter seu ArrayListem um FastList, pode se livrar do adaptador.

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

Nota: Sou um colaborador das Coleções Eclipse.

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

Você passa para a new StringJoinersequência char que você deseja que seja usada como separador. Se você deseja fazer um CSV:new StringJoiner(", ");

Em uma linha: de [12,0,1,78,12] a 12 0 1 78 12

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

Para separar usando guias em vez de usar println, você pode usar 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");
}

Eu vejo alguns exemplos que dependem de recursos adicionais, mas parece que essa seria a solução mais simples: (que é o que eu usei no meu próprio projeto), que basicamente é apenas a conversão de um ArrayList para um Array e depois para uma Lista .

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

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

Esta é uma conversa bastante antiga e os apache commons agora estão usando um StringBuilder internamente: http://commons.apache.org/lang/api/src-html/org/apache/commons/lang/StringUtils.html#line. 3045

Isso, como sabemos, melhora o desempenho, mas se o desempenho é crítico, o método usado pode ser um pouco ineficiente. Embora a interface seja flexível e permita um comportamento consistente entre os diferentes tipos de coleções, é um pouco ineficiente para Listas, que é o tipo de coleção na pergunta original.

Baseamo isso no fato de estarmos incorrendo em alguma sobrecarga que evitaríamos simplesmente iterando os elementos em um loop for tradicional. Em vez disso, há algumas coisas adicionais acontecendo nos bastidores, verificando modificações simultâneas, chamadas de método etc. O loop for aprimorado, por outro lado, resultará na mesma sobrecarga, pois o iterador é usado no objeto Iterável (a Lista).

Você pode usar um Regex para isso. Isso é tão conciso quanto possível

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

Que tal esta função:

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

funciona para qualquer tipo de coleção ...