Самый ясный способ запятых-разделять список?

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

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

• The join метод on String.
• A joining коллектор для потоков от Collectors класса.
• The 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(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();

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

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

Столяр.

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

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

он использует грамматику, как это:

List --> (Item , )* Item

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

Если вы используете 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)

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

есть довольно способ добиться этого с помощью 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);

один из вариантов для цикла 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(',')

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

Edit: оригинальное решение правильное, но не оптимальное по комментариям. Попытка во второй раз:

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

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

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

StringBuffer sb = new StringBuffer();

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

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

мне несколько нравится этот подход, который я нашел в блоге некоторое время назад. К сожалению, я не помню имя/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 тоже.

в Python его легко

",".join (yourlist )

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

строку.Join (",", yourlistofstrings)

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

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

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

"учитывая петлю и если, что вы думаете, это самый ясный способ иметь их вместе?"

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

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

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

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

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

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

}

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

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

метод

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