Лучший способ связать Список Строковых объектов? [дубликат]

Используя библиотека Functional Java , импортируйте их:

import static fj.pre.Monoid.stringMonoid;
import static fj.data.List.list;
import fj.data.List;

... затем можно сделать это:

List<String> ss = list("foo", "bar", "baz");
String s = stringMonoid.join(ss, ", ");

Или, универсальный путь, если у Вас нет списка Строк:

public static <A> String showList(List<A> l, Show<A> s) {
  return stringMonoid.join(l.map(s.showS_()), ", ");
}

В зависимости от потребности в производительности и сумме элементов, которые будут добавлены, это могло бы быть хорошо решение. Если количество элементов является большим, Arraylist, перераспределение с памяти могло бы быть немного медленнее, чем StringBuilder.

Принятие это быстрее, чтобы просто переместить указатель / установило байт в NULL (или однако Java реализует StringBuilder#setLength), вместо того, чтобы проверить условие каждый раз через цикл для наблюдения, когда добавить разделитель, Вы могли использовать этот метод:

public static String Intersperse (Collection<?> collection, String delimiter)
{
    StringBuilder sb = new StringBuilder ();
    for (Object item : collection)
    {
        if (item == null) continue;
        sb.append (item).append (delimiter);
    }
    sb.setLength (sb.length () - delimiter.length ());
    return sb.toString ();
}

ArrayList наследовал toString() - метод от AbstractCollection , т.е.:

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

Здание строка самостоятельно будет намного более эффективной.

, Если Вы действительно хотите агрегировать строки заранее в своего рода Списке, необходимо предоставить собственный метод для эффективного присоединения к ним, например, как это:

static String join(Collection<?> items, String sep) {
    if(items.size() == 0)
        return "";

    String[] strings = new String[items.size()];
    int length = sep.length() * (items.size() - 1);

    int idx = 0;
    for(Object item : items) {
        String str = item.toString();
        strings[idx++] = str;
        length += str.length();
    }

    char[] chars = new char[length];
    int pos = 0;

    for(String str : strings) {
        str.getChars(0, str.length(), chars, pos);
        pos += str.length();

        if(pos < length) {
            sep.getChars(0, sep.length(), chars, pos);
            pos += sep.length();
        }
    }

    return new String(chars);
}

я так или иначе нашел, что это было более опрятным, чем использование подхода StringBuilder/StringBuffer.

я предполагаю, что это зависит, на каком подходе Вы проявили.

AbstractCollection#toString () метод просто выполняет итерации по всем элементам и добавляет их к StringBuilder. Таким образом, Ваш метод может сохранять несколько строк кода, но за счет дополнительной Обработки строк. Является ли тот компромисс хорошим, ваше дело.

Вы видели эту запись в блоге Ужаса Кодирования?

Печальная Трагедия Театра Микрооптимизации

я не Shure, "более ли это опрятно", но с производительности точки зрения это, вероятно, не будет иметь значения очень.

Используйте один из эти методы StringUtils.join в Apache палата общин Lang.

import org.apache.commons.lang3.StringUtils;

String result = StringUtils.join(list, ", ");

, Если Вам достаточно повезло использовать Java 8, затем это еще легче..., просто используют String.join

String result = String.join(", ", list);

Вариация на ответ codefin

public static String concatStringsWSep(Iterable<String> strings, String separator) {
    StringBuilder sb = new StringBuilder();
    String sep = "";
    for(String s: strings) {
        sb.append(sep).append(s);
        sep = separator;
    }
    return sb.toString();                           
}

Мне кажется, что StringBuilder будет быстр и эффективен.

каноническая форма выглядела бы примерно так:

public static String concatStrings(List<String> strings)
{
    StringBuilder sb = new StringBuilder();
    for(String s: strings)
    {
        sb.append(s);
    }
    return sb.toString();       
}

, Если это слишком упрощенно (и это, вероятно), можно использовать аналогичный подход и добавить разделитель как это:

    public static String concatStringsWSep(List<String> strings, String separator)
{
    StringBuilder sb = new StringBuilder();
    for(int i = 0; i < strings.size(); i++)
    {
        sb.append(strings.get(i));
        if(i < strings.size() - 1)
            sb.append(separator);
    }
    return sb.toString();               
}

я соглашаюсь с другими, кто ответил на этот вопрос, когда они говорят, что Вы не должны полагаться на toString () метод ArrayList Java.