Tengo un ArrayListque quiero generar completamente como una cadena. Esencialmente quiero generarlo en orden usando el toStringde cada elemento separado por pestañas. ¿Hay alguna forma rápida de hacer esto? Puede recorrerlo (o eliminar cada elemento) y concatenarlo en una Cadena, pero creo que esto será muy lento.

Básicamente, usar un bucle para iterar sobre ArrayListes la única opción:

NO use este código, continúe leyendo hasta el final de esta respuesta para ver por qué no es deseable y qué código debe usarse en su lugar:

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 hecho, una concatenación de cadenas estará bien, ya que el javaccompilador optimizará la concatenación de cadenas como una serie de appendoperaciones de StringBuildertodos modos. Aquí hay una parte del desmontaje del bytecode del forbucle del programa anterior:

   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 se puede ver, el compilador optimiza ese ciclo mediante el uso de a StringBuilder, por lo que el rendimiento no debería ser una gran preocupación.

(OK, en una segunda mirada, StringBuilderse está instanciando el en cada iteración del bucle, por lo que puede que no sea el código de bytes más eficiente. La creación de instancias y el uso de un explícito StringBuilderprobablemente produciría un mejor rendimiento).

De hecho, creo que tener cualquier tipo de salida (ya sea en el disco o en la pantalla) será al menos un orden de magnitud más lento que tener que preocuparse por el rendimiento de las concatenaciones de cadenas.

Editar: Como se señaló en los comentarios, la optimización del compilador anterior está creando una nueva instancia de StringBuildercada iteración. (Lo cual he notado anteriormente).

La técnica más optimizada para usar será la respuesta de Paul Tomblin , ya que solo crea una instancia de un StringBuilderobjeto fuera del forbucle.

Reescribiendo el código anterior 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());

Solo creará StringBuilderuna instancia fuera del bucle y solo realizará las dos llamadas al appendmétodo dentro del bucle, como se evidencia en este código de bytes (que muestra la instanciación StringBuildery el bucle):

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

Entonces, de hecho, la optimización de la mano debería tener un mejor rendimiento, ya que el interior del forbucle es más corto y no hay necesidad de crear una instancia StringBuilderen cada iteración.

En Java 8 o posterior:

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

En caso de listque no sea de tipo String, se puede usar un recopilador de unión:

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

Si está haciendo esto en Android, hay una buena utilidad para esto llamada TextUtils que tiene un .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 no uso mucho fuera de Android, pero pensé que lo agregaría a este hilo ...

Descargue Apache Commons Lang y use el método

 StringUtils.join(list)

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

Puede implementarlo usted mismo, por supuesto, pero su código está completamente probado y es probablemente la mejor implementación posible.

Soy un gran admirador de la biblioteca Apache Commons y también creo que es una gran adición a la Biblioteca estándar de Java.

Esta es una pregunta bastante antigua, pero creo que también podría agregar una respuesta más moderna: use la Joinerclase de Guava :

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

Cambiar la Lista a una Cadena legible y significativa es realmente una pregunta común que todos pueden encontrar.

Caso 1 . Si tiene StringUtils de apache en su ruta de clase (como de rogerdpack y Ravi Wallau):

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

Caso 2 . Si solo desea utilizar formas de JDK (7):

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

Simplemente nunca construya ruedas usted mismo, no use el bucle para esta tarea de una línea.

Si estaba buscando una línea rápida, a partir de Java 5 puede hacer esto:

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

Además, si su propósito es imprimir el contenido y está menos preocupado por el "\ t", simplemente puede hacer esto:

myList.toString()

que devuelve una cadena como

[str1, str2, str3]

Si tiene una matriz (no ArrayList), puede lograr lo mismo de esta manera:

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

Recorrerlo y llamar a String. No hay una forma mágica, y si la hubiera, ¿qué crees que estaría haciendo bajo las sábanas además de recorrerla? Casi la única microoptimización sería usar StringBuilder en lugar de String, e incluso eso no es una gran victoria: la concatenación de cadenas se convierte en StringBuilder debajo de las cubiertas, pero al menos si lo escribe de esa manera, puede ver lo que está sucediendo.

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

La mayoría de los proyectos Java a menudo tienen apache-commons lang disponibles. Los métodos StringUtils.join () son muy agradables y tienen varios sabores para satisfacer casi todas las necesidades.

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:

colección : la colección de valores para unir, puede ser nula

separador - el carácter separador a usar

Devuelve : la cadena unida, nula si la entrada de iterador es nula

Desde: 2.3

Android tiene una clase TextUtil que puede usar http://developer.android.com/reference/android/text/TextUtils.html

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

Para este caso de uso simple, simplemente puede unir las cadenas con una coma. Si usa Java 8:

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

de lo contrario, commons-lang tiene un método join ():

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

Una forma elegante de lidiar con los caracteres de separación final es usar Class Separator

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

El método toString de Class Separator devuelve el separador, a excepción de la primera llamada. Por lo tanto, imprimimos la lista sin separadores iniciales (o en este caso) finales.

En Java 8 es simple. Vea el ejemplo para la lista de enteros:

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

O versión multilínea (que es más fácil de leer):

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

Actualización: una versión más corta

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

Es un O(n)algoritmo de cualquier manera (a menos que haya hecho alguna solución de subprocesos múltiples en la que separó la lista en varias sublistas, pero no creo que sea lo que está pidiendo).

Simplemente use un StringBuildercomo a continuación:

StringBuilder sb = new StringBuilder();

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

String finalString = sb.toString();

El StringBuilderva a ser mucho más rápido que la concatenación de cadenas, ya que no se volverá a instancias de un Stringobjeto en cada una concatenación.

En caso de que esté en Android y aún no esté usando Jack (por ejemplo, porque todavía no tiene soporte para Instant Run), y si desea tener más control sobre el formato de la cadena resultante (por ejemplo, le gustaría usar el carácter de nueva línea como el divisor de elementos), y al usar / querer usar la biblioteca StreamSupport (para usar secuencias en Java 7 o versiones anteriores del compilador), podría usar algo como esto (pongo este método en mi clase ListUtils):

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

Y, por supuesto, asegúrese de implementar toString () en la clase de objetos de su lista.

Si no desea el último \ t después del último elemento, debe usar el índice para verificar, pero recuerde que esto solo "funciona" (es decir, es O (n)) cuando las listas implementan 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());

El siguiente código puede ayudarlo,

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

Salida:

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

Puede que no sea la mejor manera, sino la manera elegante.

Arrays.deepToString (Arrays.asList ("Prueba", "Prueba2")

import java.util.Arrays;

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

Salida

[Prueba, Prueba2]

¿Sería bueno lo siguiente?

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

Si está usando Eclipse Collections , puede usar el 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"));

Si puede convertir su ArrayLista FastList, puede deshacerse del adaptador.

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

Nota: Soy un committer para Eclipse Collections.

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

Pasa a la new StringJoinersecuencia de caracteres que desea utilizar como separador. Si quieres hacer un CSV:new StringJoiner(", ");

En una línea: de [12,0,1,78,12] a 12 0 1 78 12

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

Para separar usando pestañas en lugar de usar println puedes 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");
}

Veo algunos ejemplos que dependen de recursos adicionales, pero parece que esta sería la solución más simple: (que es lo que usé en mi propio proyecto) que básicamente se está convirtiendo de una ArrayList a una Array y luego a una 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 es una conversación bastante antigua por ahora y los comunes de Apache ahora están utilizando un StringBuilder internamente: http://commons.apache.org/lang/api/src-html/org/apache/commons/lang/StringUtils.html#line. 3045

Como sabemos, esto mejorará el rendimiento, pero si el rendimiento es crítico, entonces el método utilizado podría ser algo ineficiente. Mientras que la interfaz es flexible y permitirá un comportamiento consistente en diferentes tipos de Colección, es algo ineficiente para las Listas, que es el tipo de Colección en la pregunta original.

Baso esto en que estamos incurriendo en una sobrecarga que evitaríamos simplemente iterando a través de los elementos en un bucle for tradicional. En cambio, hay algunas cosas adicionales que suceden detrás de escena para verificar modificaciones concurrentes, llamadas a métodos, etc. Por otro lado, el bucle for mejorado dará como resultado la misma sobrecarga ya que el iterador se usa en el objeto Iterable (la Lista).

Puedes usar un Regex para esto. Esto es tan conciso como se pone

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

¿Qué tal esta función:

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 cualquier tipo de colección ...