Java 8 и новее

Использование класса StringJoiner и _ 2 _ метод:

StringJoiner joiner = new StringJoiner(",");
list.forEach(item -> joiner.add(item.toString());
return joiner.toString();

Используя Stream и _ 5_:

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

Java 7 и более ранние версии

См. Также # 285523.

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

В Java 8 есть несколько новых способов сделать это:

• _ 1_ на String.
• joining сборщик потоков из класса Collectors.
• Класс StringJoiner.

Пример:

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

Подход с использованием потоков предполагает import static java.util.stream.Collectors.joining;.

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

Столяр.

Если вы используете Spring Framework, вы можете сделать это с помощью 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)

На основе реализации Java List toString:

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

Он использует такую ​​грамматику:

List --> (Item , )* Item

Будучи основанным на последнем, а не на первом, он может проверять пропущенную запятую с помощью того же теста, чтобы проверить наличие конца списка. Я думаю, что это очень элегантно, но я не уверен в ясности.

Есть отличный способ добиться этого с помощью Java 8:

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

Один из вариантов цикла foreach:

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

Обновление: как Дэйв Уэбб упомянул в комментариях, это может не дать правильных результатов, если первые элементы в списке являются пустыми строками.

Я обычно так делаю:

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

Хотя я думаю, что с этого момента я буду проходить эту проверку в соответствии с реализацией Java;)

Если вы можете использовать Groovy (который работает на JVM):

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

(Скопируйте и вставьте мой собственный ответ здесь. Многие из описанных здесь решений немного переборщили, ИМХО, особенно те, которые полагаются на внешние библиотеки. Есть хорошая чистая, ясная идиома для создания списка, разделенного запятыми, который я всегда использовал. Он полагается на условный оператор (?):

Изменить: исходное решение правильное, но не оптимальное согласно комментариям. Пробуем второй раз:

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

Вот и все, 4 строчки кода, включая объявление массива и StringBuilder.

2-е изменение: если вы имеете дело с итератором:

    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() ? "," : "");

Я обычно использую что-то похожее на версию 3. Работает хорошо c / c ++ / bash / ...: P

Я не компилировал его ... но должен работать (или быть близок к работе).

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

Это очень коротко, очень ясно, но придает моей чувствительности ползучий ужас. Также немного неудобно адаптироваться к различным разделителям, особенно если это String (не char).

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

На основе: Последняя итерация расширенного цикла for в java

Мне немного нравится этот подход, который я нашел некоторое время назад в блоге. К сожалению, я не помню имя / URL блога.

Вы можете создать служебный / вспомогательный класс, который будет выглядеть так:

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

Использовать вспомогательный класс просто:

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

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

Поскольку вашим разделителем является "," вы можете использовать любое из следующего:

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

Если ваш разделитель НИЧЕГО другого, то это не сработает для вас.

Мне нравится это решение:

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

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

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

Я предполагаю, что он также может использовать StringBuilder.

На мой взгляд, это проще всего прочитать и понять:

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

В Python это просто

",". присоединиться (ваш список)

В C # есть статический метод класса String

String.Join (",", ваш список строк)

Извините, не уверен насчет Java, но подумал, что отвечу, когда вы спросите о других языках. Я уверен, что в Java было бы что-то подобное.

Вы также можете безоговорочно добавить строку разделителя, а после цикла удалить лишний разделитель в конце. Тогда "если список пуст, то вернуть эту строку" в начале позволит вам избежать проверки в конце (так как вы не можете удалить символы из пустого списка)

Итак, действительно вопрос:

«Как вы думаете, какой способ собрать их вместе, имея петлю и if, является наиболее ясным?»

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

На основе Самый простой способ разделить список запятыми (Java )?

Используя эту идею: Последний элемент в петля заслуживает отдельного рассмотрения?

Ни один из ответов пока не использует рекурсию ...

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, ','));
    }

}

Метод

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

использование

Учитывая массив [1,2,3]

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