¿Cuál es la forma más clara de delimitar por comas una lista en Java?

Conozco varias formas de hacerlo, pero me pregunto cuál es la mejor (donde "mejor" significa más clara y / o más corta, no la más eficiente.

Tengo una lista y quiero recorrerla, imprimiendo cada valor. Quiero imprimir una coma entre cada elemento, pero no después del último (ni antes del primero).

List --> Item ( , Item ) *
List --> ( Item , ) * Item

Solución de muestra 1:

boolean isFirst = true;
for (Item i : list) {
  if (isFirst) {
    System.out.print(i);        // no comma
    isFirst = false;
  } else {
    System.out.print(", "+i);   // comma
  }
}

Solución de muestra 2: cree una sublista:

if (list.size()>0) {
  System.out.print(list.get(0));   // no comma
  List theRest = list.subList(1, list.size());
  for (Item i : theRest) {
    System.out.print(", "+i);   // comma
  }
}

Solución de muestra 3:

  Iterator<Item> i = list.iterator();
  if (i.hasNext()) {
    System.out.print(i.next());
    while (i.hasNext())
      System.out.print(", "+i.next());
  }

Estos tratan el primer artículo de manera especial; en su lugar, se podría tratar al último de manera especial.

Por cierto, así es como List toString se implementa (se hereda de AbstractCollection), en Java 1.6:

public String toString() {
    Iterator<E> i = iterator();
    if (! i.hasNext())
        return "[]";

    StringBuilder sb = new StringBuilder();
    sb.append('[');
    for (;;) {
        E e = i.next();
        sb.append(e == this ? "(this Collection)" : e);
        if (! i.hasNext())
            return sb.append(']').toString();
        sb.append(", ");
    }
}

Sale del bucle antes de tiempo para evitar la coma después del último elemento. Por cierto: esta es la primera vez que recuerdo haber visto "(esta colección)"; aquí hay un código para provocarlo:

List l = new LinkedList();
l.add(l);
System.out.println(l);

Doy la bienvenida a cualquier solución, incluso si usan bibliotecas inesperadas (¿regexp?); y también soluciones en idiomas distintos de Java (por ejemplo Creo Python / Ruby tiene un intersperse función - ¿Cómo se que ? implementada).

Aclaración : por bibliotecas, me refiero a las bibliotecas estándar de Java. Para otras bibliotecas, las considero con otros lenguajes y me interesa saber cómo se implementan.

El kit de herramientas EDIT mencionó una pregunta similar: última iteración del bucle for mejorado en java

Y otro: ¿El último elemento de un bucle merece un tratamiento aparte?

Java 8 y posterior

Usando StringJoinerclase:

StringJoiner joiner = new StringJoiner(",");
for (Item item : list) {
    joiner.add(item.toString());
}
return joiner.toString();

Usando Stream, y Collectors:

return list.stream().
       map(Object::toString).
       collect(Collectors.joining(",")).toString();

Java 7 y versiones anteriores

Véase también # 285523

String delim = "";
for (Item i : list) {
    sb.append(delim).append(i);
    delim = ",";
}

org.apache.commons.lang3.StringUtils.join(list,",");

Java 8 proporciona varias formas nuevas de hacer esto:

• El joinmétodo de String.
• Un joiningrecopilador de transmisiones de la Collectorsclase.
• La StringJoinerclase.

Ejemplo:

// Util method for strings and other char sequences
List<String> strs = Arrays.asList("1", "2", "3");
String listStr1 = String.join(",", strs);

// For any type using streams and collectors
List<Object> objs = Arrays.asList(1, 2, 3);
String listStr2 = objs.stream()
    .map(Object::toString)
    .collect(joining(",", "[", "]"));

// Using the new StringJoiner class
StringJoiner joiner = new StringJoiner(", ", "[", "]");
joiner.setEmptyValue("<empty>");
for (Integer i : objs) {
  joiner.add(i.toString());
}
String listStr3 = joiner.toString();

El enfoque que usa corrientes asume import static java.util.stream.Collectors.joining;.

Joiner.on(",").join(myList)

Carpintero .

Si usa Spring Framework, puede hacerlo con StringUtils :

public static String arrayToDelimitedString(Object[] arr)
public static String arrayToDelimitedString(Object[] arr, String delim)
public static String collectionToCommaDelimitedString(Collection coll)
public static String collectionToCommaDelimitedString(Collection coll, String delim)

Basado en la implementación List toString de Java:

Iterator i = list.iterator();
for (;;) {
  sb.append(i.next());
  if (! i.hasNext()) break;
  ab.append(", ");
}

Utiliza una gramática como esta:

List --> (Item , )* Item

Al estar basado en el último en lugar de en el primero, puede buscar la coma con la misma prueba para verificar el final de la lista. Creo que este es muy elegante, pero no estoy seguro de la claridad.

String delimiter = ",";
StringBuilder sb = new StringBuilder();
for (Item i : list) {
    sb.append(delimiter).append(i);
}
sb.toString().replaceFirst(delimiter, "");

Hay una manera bonita de lograr esto usando Java 8:

List<String> list = Arrays.asList(array);
String joinedString = String.join(",", list);

for(int i=0, length=list.size(); i<length; i++)
  result+=(i==0?"":", ") + list.get(i);

Una opción para el bucle foreach es:

StringBuilder sb = new StringBuilder();
for(String s:list){
  if (sb.length()>0) sb.append(",");
  sb.append(s);
}

StringBuffer result = new StringBuffer();
for(Iterator it=list.iterator; it.hasNext(); ) {
  if (result.length()>0)
    result.append(", ");
  result.append(it.next());
}

Actualización : como mencionó Dave Webb en los comentarios, es posible que esto no produzca resultados correctos si los primeros elementos de la lista son cadenas vacías.

Yo suelo hacer esto:

StringBuffer sb = new StringBuffer();
Iterator it = myList.iterator();
if (it.hasNext()) { sb.append(it.next().toString()); }
while (it.hasNext()) { sb.append(",").append(it.next().toString()); }

Aunque creo que haré esta verificación de ahora en adelante según la implementación de Java;)

Si puede usar Groovy (que se ejecuta en la JVM):

def list = ['a', 'b', 'c', 'd']
println list.join(',')

(Copie y pegue mi propia respuesta de aquí ). Muchas de las soluciones descritas aquí son un poco exageradas, en mi humilde opinión, especialmente aquellas que dependen de bibliotecas externas. Hay un lenguaje agradable, limpio y claro para lograr una lista separada por comas que siempre he usado. Se basa en el operador condicional (?):

Editar : Solución original correcta, pero no óptima según los comentarios. Intentando una segunda vez:

int[] array = {1, 2, 3};
StringBuilder builder = new StringBuilder();
for (int i = 0 ;  i < array.length; i++)
       builder.append(i == 0 ? "" : ",").append(array[i]);

Ahí lo tienes, en 4 líneas de código, incluida la declaración de la matriz y el StringBuilder.

2da edición : si se trata de un iterador:

    List<Integer> list = Arrays.asList(1, 2, 3);
    StringBuilder builder = new StringBuilder();
    for (Iterator it = list.iterator(); it.hasNext();)
        builder.append(it.next()).append(it.hasNext() ? "," : "");

Normalmente uso algo similar a la versión 3. Funciona bien c / c ++ / bash / ...: P

No lo compilé ... pero debería funcionar (o estar cerca de funcionar).

public static <T> String toString(final List<T> list, 
                                  final String delim)
{
    final StringBuilder builder;

    builder = new StringBuilder();

    for(final T item : list)
    {
        builder.append(item);
        builder.append(delim);
    }

    // kill the last delim
    builder.setLength(builder.length() - delim.length());

    return (builder.toString());
}

Esto es muy breve, muy claro, pero le da a mi sensibilidad los horrores que se arrastran. También es un poco incómodo adaptarse a diferentes delimitadores, especialmente si un String (no char).

for (Item i : list)
  sb.append(',').append(i);
if (sb.charAt(0)==',') sb.deleteCharAt(0);

Inspirado por: última iteración de bucle for mejorado en java

StringBuffer sb = new StringBuffer();

for (int i = 0; i < myList.size(); i++)
{ 
    if (i > 0) 
    {
        sb.append(", ");
    }

    sb.append(myList.get(i)); 
}

Me gusta un poco este enfoque, que encontré en un blog hace algún tiempo. Desafortunadamente, no recuerdo el nombre / URL del blog.

Puede crear una clase de utilidad / ayuda con este aspecto:

private class Delimiter
{
    private final String delimiter;
    private boolean first = true;

    public Delimiter(String delimiter)
    {
        this.delimiter = delimiter;
    }

    @Override
    public String toString()
    {
        if (first) {
            first = false;
            return "";
        }

        return delimiter;
    }
}

Usar la clase auxiliar es tan simple como esto:

StringBuilder sb = new StringBuilder();
Delimiter delimiter = new Delimiter(", ");

for (String item : list) {
    sb.append(delimiter);
    sb.append(item);
}

Debido a que su delimitador es "," puede utilizar cualquiera de los siguientes:

public class StringDelim {

    public static void removeBrackets(String string) {
        System.out.println(string.substring(1, string.length() - 1));
    }

    public static void main(String... args) {
        // Array.toString() example
        String [] arr = {"Hi" , "My", "name", "is", "br3nt"};
        String string = Arrays.toString(arr);
        removeBrackets(string);

        // List#toString() example
        List<String> list = new ArrayList<String>();
        list.add("Hi");
        list.add("My");
        list.add("name");
        list.add("is");
        list.add("br3nt");
        string = list.toString();
        removeBrackets(string);

        // Map#values().toString() example
        Map<String, String> map = new LinkedHashMap<String, String>();
        map.put("1", "Hi");
        map.put("2", "My");
        map.put("3", "name");
        map.put("4", "is");
        map.put("5", "br3nt");
        System.out.println(map.values().toString());
        removeBrackets(string);

        // Enum#toString() example
        EnumSet<Days> set = EnumSet.allOf(Days.class);
        string = set.toString();
        removeBrackets(string);
    }

    public enum Days {
        MON("Monday"),
        TUE("Tuesday"),
        WED("Wednesday"),
        THU("Thursday"),
        FRI("Friday"),
        SAT("Saturday"),
        SUN("Sunday");

        private final String day;

        Days(String day) {this.day = day;}
        public String toString() {return this.day;}
    }
}

Si su delimitador es CUALQUIER COSA más, entonces esto no funcionará para usted.

Me gusta esta solucion:

String delim = " - ", string = "";

for (String item : myCollection)
    string += delim + item;

string = string.substring(delim.length());

Supongo que también puede hacer uso de StringBuilder.

En mi opinión, este es el más simple de leer y comprender:

StringBuilder sb = new StringBuilder();
for(String string : strings) {
    sb.append(string).append(',');
}
sb.setLength(sb.length() - 1);
String result = sb.toString();

En Python es fácil

",". únete (tu lista)

En C # hay un método estático en la clase String

String.Join (",", su lista de cadenas)

Lo siento, no estoy seguro acerca de Java, pero pensé en hablar mientras preguntaba por otros idiomas. Estoy seguro de que habría algo similar en Java.

También puede agregar incondicionalmente la cadena delimitador y, después del bucle, eliminar el delimitador adicional al final. Luego, un "si la lista está vacía, devuelva esta cadena" al principio le permitirá evitar la marca al final (ya que no puede eliminar caracteres de una lista vacía)

Entonces la pregunta realmente es:

"Dado un bucle y un si, ¿cuál crees que es la forma más clara de tenerlos juntos?"

public static String join (List<String> list, String separator) {
  String listToString = "";

  if (list == null || list.isEmpty()) {
   return listToString;
  }

  for (String element : list) {
   listToString += element + separator;
  }

  listToString = listToString.substring(0, separator.length());

  return listToString;
}

if (array.length>0)          // edited in response Joachim's comment
  sb.append(array[i]);
for (int i=1; i<array.length; i++)
  sb.append(",").append(array[i]);

Residencia en forma más clara de delimitar una lista por comas (Java)?

Usando esta idea: ¿El último elemento de un bucle merece un tratamiento por separado?

public String toString(List<Item> items)
{
    StringBuilder sb = new StringBuilder("[");

    for (Item item : items)
    {
        sb.append(item).append(", ");
    }

    if (sb.length() >= 2)
    {
        //looks cleaner in C# sb.Length -= 2;
        sb.setLength(sb.length() - 2);
    }

    sb.append("]");

    return sb.toString();
}

Ninguna de las respuestas usa recursividad hasta ahora ...

public class Main {

    public static String toString(List<String> list, char d) {
        int n = list.size();
        if(n==0) return "";
        return n > 1 ? Main.toString(list.subList(0, n - 1), d) + d
                  + list.get(n - 1) : list.get(0);
    }

    public static void main(String[] args) {
        List<String> list = Arrays.asList(new String[]{"1","2","3"});
        System.out.println(Main.toString(list, ','));
    }

}

private String betweenComma(ArrayList<String> strings) {
    String united = "";
    for (String string : strings) {
        united = united + "," + string;
    }
    return united.replaceFirst(",", "");
}

Método

String join(List<Object> collection, String delimiter){
    StringBuilder stringBuilder = new StringBuilder();
    int size = collection.size();
    for (Object value : collection) {
        size --;
        if(size > 0){
            stringBuilder.append(value).append(delimiter);
        }
    }

    return stringBuilder.toString();
}

Uso

Dada la matriz de [1,2,3]

join(myArray, ",") // 1,2,3