Каков самый простой способ разделить список через запятую в Java?

Я знаю несколько способов сделать это, но мне интересно, какой из них лучший (где «лучший» означает самый ясный и / или самый короткий, а не самый эффективный.

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

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

Пример раствора 1:

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

Пример решения 2 - создать подсписок:

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

Пример раствора 3:

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

Они специально относятся к первому элементу; вместо этого можно было относиться к последнему специально.

Кстати, вот как List toString это реализовано (унаследовано от AbstractCollection) в 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(", ");
    }
}

Он выходит из цикла раньше, чтобы не ставить запятую после последнего элемента. Кстати: это первый раз, когда я вспоминаю, что видел "(этот сборник)"; вот код, чтобы спровоцировать это:

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

Я приветствую любое решение, даже если оно использует неожиданные библиотеки (regexp?); а также решения на языках, отличных от Java (например, я думаю, что в Python / Ruby есть функция перемежения - как это реализовано?).

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

В наборе инструментов EDIT упоминался аналогичный вопрос: последняя итерация расширенного цикла for в java

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

Java 8 и новее

Использование StringJoinerкласса:

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

Использование Stream, и Collectors:

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

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

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

• В joinСпособ по 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

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

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(',')

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

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

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.

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.

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

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 было бы что-то подобное.

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

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

«Как вы думаете, с учетом цикла и« если »их можно соединить вместе?»

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

}

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