¿La forma más clara de delimitar por comas una lista?

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

Java 8 proporciona varias formas nuevas de hacer esto:

• La join método de String.
• A joining colector para flujos de la clase Collectors.
• El StringJoiner clase.

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(i -> i.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 utiliza flujos asume import static java.util.stream.Collectors.joining;.

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

Joiner .

Basado en la lista de Java toString implementación:

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 la última en lugar de en la primera, puede verificar la coma de salto con la misma prueba para verificar el final de la lista. Creo que este es muy elegante, pero no estoy seguro de la claridad.

Si usas el Framework Spring puedes 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)

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

Update : Como Dave Webb mencionó en los comentarios, esto puede no producir resultados correctos si los primeros elementos de la lista son cadenas vacías.

, normalmente hago 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 voy a una esta comprobación a partir de ahora 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(',')

(Copiar y pegar mi propia respuesta desde 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 buen lenguaje limpio y claro para lograr una lista separada por comas que siempre he usado. Se basa en el condicional (? operador:

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 incluyendo el declaración del array y del StringBuilder.

2nd Edit : Si está tratando con 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 debe funcionar (o estar cerca de trabajar).

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 corto, muy claro, pero da a mi sensibilidad los horrores que se arrastran. También es un poco incómodo adaptarse a diferentes delimitadores, especialmente si es una cadena (no char).

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

Inspirado en: Última iteración del 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 utility / helper que se vea así:

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 helper 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 ", " podría usar 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 otra cosa, entonces esto no va a funcionar para usted.

Me gusta esta solución:

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

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

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

Asumo que también puede hacer uso de StringBuilder.

En Python es fácil

",".únete (tu lista)

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

Cadena.Join(",", yourlistofstrings)

Lo siento, no estoy seguro acerca de Java, pero pensé que me callaría cuando me preguntaste acerca de otros idiomas. Estoy seguro de que habría algo similar en Java.

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

Así que 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]);

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

Usando esta idea: ¿El último elemento de un bucle merece un tratamiento 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 recursión 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, ','));
    }

}

En mi opinión, esto es lo más simple de leer y entender:

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

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

Dado el arreglo de [1,2,3]

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