У мене є ArrayListте, що я хочу вивести повністю як рядка. По суті, я хочу вивести його для того, щоб використовувати toStringкожен елемент, розділений вкладками. Чи є швидкий спосіб зробити це? Ви можете провести цикл (або вилучити кожен елемент) і об'єднати його в String, але я думаю, це буде дуже повільно.

В основному, використання циклу для повторення над ArrayListєдиним варіантом:

НЕ використовуйте цей код, продовжуйте читати донизу цю відповідь, щоб побачити, чому це не бажано, і який код слід використовувати замість цього:

ArrayList<String> list = new ArrayList<String>();
list.add("one");
list.add("two");
list.add("three");

String listString = "";

for (String s : list)
{
    listString += s + "\t";
}

System.out.println(listString);

Насправді, конкатенація рядків буде просто чудовою, оскільки javacкомпілятор оптимізує конкатенацію рядків як серію appendоперацій у StringBuilderбудь-якому разі. Ось частина розбирання байт-коду з forциклу з вищевказаної програми:

   61:  new #13; //class java/lang/StringBuilder
   64:  dup
   65:  invokespecial   #14; //Method java/lang/StringBuilder."<init>":()V
   68:  aload_2
   69:  invokevirtual   #15; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   72:  aload   4
   74:  invokevirtual   #15; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   77:  ldc #16; //String \t
   79:  invokevirtual   #15; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   82:  invokevirtual   #17; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;

Як видно, компілятор оптимізує цю петлю за допомогою a StringBuilder, тому продуктивність не повинна викликати особливих проблем.

(Гаразд, з другого погляду, StringBuilderінстанціюється при кожній ітерації циклу, тому це може бути не найефективнішим байт-кодом. Моментальне використання та використання явного StringBuilder, можливо, дасть кращі показники.)

Насправді, я думаю, що мати будь-який вихід (будь то на диск чи на екран) буде щонайменше на порядок повільніше, ніж турбуватися про продуктивність струнних конкатенацій.

Редагування: Як зазначено в коментарях, вищеописана оптимізація компілятора справді створює новий примірник для StringBuilderкожної ітерації. (Що я вже відзначав раніше.)

Найбільш оптимізованою технікою для використання буде відповідь Пола Томбліна , оскільки вона створює лише один StringBuilderоб'єкт поза forциклом.

Переписання вищевказаного коду на:

ArrayList<String> list = new ArrayList<String>();
list.add("one");
list.add("two");
list.add("three");

StringBuilder sb = new StringBuilder();
for (String s : list)
{
    sb.append(s);
    sb.append("\t");
}

System.out.println(sb.toString());

Буде інстанціювати лише StringBuilderодин раз зовні цикл, і лише зробить два виклики appendметоду всередині циклу, про що свідчить цей байт-код (який показує інстанціювання StringBuilderі цикл):

   // Instantiation of the StringBuilder outside loop:
   33:  new #8; //class java/lang/StringBuilder
   36:  dup
   37:  invokespecial   #9; //Method java/lang/StringBuilder."<init>":()V
   40:  astore_2

   // [snip a few lines for initializing the loop]
   // Loading the StringBuilder inside the loop, then append:
   66:  aload_2
   67:  aload   4
   69:  invokevirtual   #14; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   72:  pop
   73:  aload_2
   74:  ldc #15; //String \t
   76:  invokevirtual   #14; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
   79:  pop

Таким чином, оптимізація руки повинна бути ефективнішою, оскільки внутрішня forпетля коротшає, і немає необхідності вводити копії StringBuilderна кожну ітерацію.

У Java 8 чи новіших версіях:

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

Якщо listString не типу, може бути використаний приєднувальний колектор:

String listString = list.stream().map(Object::toString)
                        .collect(Collectors.joining(", "));

Якщо вам трапляється робити це на Android, є приємна утиліта для цього під назвою TextUtils, яка має .join(String delimiter, Iterable)метод.

List<String> list = new ArrayList<String>();
list.add("Item 1");
list.add("Item 2");
String joined = TextUtils.join(", ", list);

Очевидно, що поза межами Android багато не використовується, але я подумав, що я додам його до цієї теми ...

Завантажте Apache Commons Lang і використовуйте метод

 StringUtils.join(list)

 StringUtils.join(list, ", ") // 2nd param is the separator.

Ви можете реалізувати його самостійно, звичайно, але їх код повністю перевірений і, мабуть, найкраща можлива реалізація.

Я великий фанат бібліотеки Apache Commons, і я також вважаю, що це чудове доповнення до стандартної бібліотеки Java.

Це досить старе питання, але я думаю, що я можу також додати більш сучасну відповідь - використовуйте Joinerклас від Guava :

String joined = Joiner.on("\t").join(list);

Зміна списку на читабельну та змістовну рядок - це справді поширене питання, з яким може зіткнутися кожен.

Випадок 1 . Якщо у вашому класі є шлях StringUtils apache (як від rogerdpack та Ravi Wallau):

import org.apache.commons.lang3.StringUtils;
String str = StringUtils.join(myList);

Випадок 2 . Якщо ви хочете використовувати лише способи з JDK (7):

import java.util.Arrays;
String str = Arrays.toString(myList.toArray()); 

Просто ніколи не будуйте колеса самостійно, не використовуйте петлю для цього однорядкового завдання.

Якщо ви шукали швидкий однолінійний апарат, то для Java 5 ви можете зробити це:

myList.toString().replaceAll("\\[|\\]", "").replaceAll(", ","\t")

Крім того, якщо ваша мета - просто роздрукувати вміст і вас менше не хвилює питання "\ t", ви можете просто зробити це:

myList.toString()

яка повертає рядок типу

[str1, str2, str3]

Якщо у вас є масив (не ArrayList), ви можете виконати таке ж:

 Arrays.toString(myList).replaceAll("\\[|\\]", "").replaceAll(", ","\t")

Проведіть через нього і зателефонуйте доString. Немає чарівного способу, і якби вони були, як ви думаєте, що це робило б під прикриттями, крім того, щоб прошивати його? Єдиною мікрооптимізацією було б використання StringBuilder замість String, і навіть це не величезна виграш - об'єднувальні рядки перетворюються на StringBuilder під обкладинками, але принаймні, якщо ви пишете це так, ви можете побачити, що відбувається.

StringBuilder out = new StringBuilder();
for (Object o : list)
{
  out.append(o.toString());
  out.append("\t");
}
return out.toString();

У більшості Java-проектів часто доступний апарат apache-commons. Методи StringUtils.join () дуже приємні та мають кілька смаків, щоб задовольнити майже кожну потребу.

public static java.lang.String join(java.util.Collection collection,
                                    char separator)


public static String join(Iterator iterator, String separator) {
    // handle null, zero and one elements before building a buffer 
    Object first = iterator.next();
    if (!iterator.hasNext()) {
        return ObjectUtils.toString(first);
    }
    // two or more elements 
    StringBuffer buf = 
        new StringBuffer(256); // Java default is 16, probably too small 
    if (first != null) {
        buf.append(first);
    }
    while (iterator.hasNext()) {
        if (separator != null) {
            buf.append(separator);
        }
        Object obj = iterator.next();
        if (obj != null) {
            buf.append(obj);
        }
    }
    return buf.toString();
}

Параметри:

collection - Колекція значень для об'єднання разом може бути недійсною

separator - символ роздільника, який потрібно використовувати

Повертає : об'єднаний рядок, null якщо введений null ітератор

З моменту: 2.3

Android має клас TextUtil, яким ви можете користуватися http://developer.android.com/reference/android/text/TextUtils.html

String implode = TextUtils.join("\t", list);

У цьому простому випадку ви можете просто з'єднати рядки з комою. Якщо ви використовуєте Java 8:

String csv = String.join("\t", yourArray);

в іншому випадку commons-lang має метод join ():

String csv = org.apache.commons.lang3.StringUtils.join(yourArray, "\t");

Елегантний спосіб розібратися із символами розділення - це використання класового роздільника

StringBuilder buf = new StringBuilder();
Separator sep = new Separator("\t");
for (String each: list) buf.append(sep).append(each);
String s = buf.toString();

Метод ToString Class Separator повертає роздільник, за винятком першого дзвінка. Таким чином, ми друкуємо список, не затримуючи провідні роздільники (або в цьому випадку).

У Java 8 це просто. Див. Приклад для списку цілих чисел:

String result = Arrays.asList(1,2,3).stream().map(Object::toString).reduce((t, u) -> t + "\t" + u).orElse("");

Або багаторядкова версія (яку простіше читати):

String result = Arrays.asList(1,2,3).stream()
    .map(Object::toString)
    .reduce((t, u) -> t + "\t" + u)
    .orElse("");

Оновлення - скорочена версія

String result = Arrays.asList(1,2,3).stream()
                .map(Object::toString)
                .collect(Collectors.joining("\t"));

Це O(n)алгоритм в будь-якому випадку (якщо ви не зробили якесь багатопотокове рішення, де ви розбили список на декілька підсписок, але я не думаю, що саме цього ви просите).

Просто використовуйте StringBuilderнаведене нижче:

StringBuilder sb = new StringBuilder();

for (Object obj : list) {
  sb.append(obj.toString());
  sb.append("\t");
}

String finalString = sb.toString();

Це StringBuilderбуде набагато швидше, ніж конкатенація рядків, тому що ви не будете повторно інстанціювати Stringоб'єкт на кожному конкатенації.

У випадку, якщо ви перебуваєте на Android і ще не використовуєте Джека (наприклад, тому, що йому все ще не вистачає підтримки для миттєвого запуску), і якщо ви хочете більше контролювати форматування отриманого рядка (наприклад, ви хочете використовувати символ нового рядка як дільник елементів), і, трапляється, використовувати / хочу використовувати бібліотеку StreamSupport (для використання потоків на Java 7 або більш ранніх версіях компілятора), ви могли б використовувати щось подібне (я помістив цей метод у свій клас ListUtils):

public static <T> String asString(List<T> list) {
    return StreamSupport.stream(list)
            .map(Object::toString)
            .collect(Collectors.joining("\n"));
}

І звичайно, переконайтеся, що застосувати toString () у класі об'єктів списку.

Якщо ви не хочете останнього \ t після останнього елемента, вам потрібно використовувати індекс, щоб перевірити, але пам’ятайте, що це "працює" (тобто є O (n)), коли списки реалізують RandomAccess.

List<String> list = new ArrayList<String>();
list.add("one");
list.add("two");
list.add("three");

StringBuilder sb = new StringBuilder(list.size() * apprAvg); // every apprAvg > 1 is better than none
for (int i = 0; i < list.size(); i++) {
    sb.append(list.get(i));
    if (i < list.size() - 1) {
        sb.append("\t");
    }
}
System.out.println(sb.toString());

Наведений нижче код може допомогти вам,

List list = new ArrayList();
list.add("1");
list.add("2");
list.add("3");
String str = list.toString();
System.out.println("Step-1 : " + str);
str = str.replaceAll("[\\[\\]]", "");
System.out.println("Step-2 : " + str);

Вихід:

Step-1 : [1, 2, 3]
Step-2 : 1, 2, 3

Можливо, це не найкращий, але елегантний спосіб.

Arrays.deepToString (Arrays.asList ("Тест", "Test2")

import java.util.Arrays;

    public class Test {
        public static void main(String[] args) {
            System.out.println(Arrays.deepToString(Arrays.asList("Test", "Test2").toArray()));
        }
    }

Вихідні дані

[Тест, Тест2]

Буде таке корисне:

List<String> streamValues = new ArrayList<>();
Arrays.deepToString(streamValues.toArray()));   

Якщо ви використовуєте Eclipse Collection , ви можете скористатися makeString()методом.

ArrayList<String> list = new ArrayList<String>();
list.add("one");
list.add("two");
list.add("three");

Assert.assertEquals(
    "one\ttwo\tthree",
    ArrayListAdapter.adapt(list).makeString("\t"));

Якщо ви можете конвертувати ваш ArrayListфайл у FastList, ви можете позбутися адаптера.

Assert.assertEquals(
    "one\ttwo\tthree",
    FastList.newListWith("one", "two", "three").makeString("\t"));

Примітка. Я є членом колекції Eclipse.

List<String> stringList = getMyListOfStrings();
StringJoiner sj = new StringJoiner(" ");
stringList.stream().forEach(e -> sj.add(e));
String spaceSeparated = sj.toString()

Ви переходите до new StringJoinerпослідовності char, яку ви хочете використовувати як роздільник. Якщо ви хочете зробити CSV:new StringJoiner(", ");

В одному рядку: Від [12,0,1,78,12] до 12 0 1 78 12

String srt= list.toString().replaceAll("\\[|\\]|,","");

Для розділення за допомогою вкладок замість println можна використовувати print

ArrayList<String> mylist = new ArrayList<String>();

mylist.add("C Programming");
mylist.add("Java");
mylist.add("C++");
mylist.add("Perl");
mylist.add("Python");

for (String each : mylist)
{       
    System.out.print(each);
    System.out.print("\t");
}

Я бачу досить багато прикладів, які залежать від додаткових ресурсів, але здається, що це було б найпростішим рішенням: (саме це я використовував у своєму власному проекті), який в основному просто перетворюється з ArrayList в масив, а потім у список .

    List<Account> accounts = new ArrayList<>();

   public String accountList() 
   {
      Account[] listingArray = accounts.toArray(new Account[accounts.size()]);
      String listingString = Arrays.toString(listingArray);
      return listingString;
   }

Це вже досить давня розмова і апаш-комуни зараз використовують StringBuilder внутрішньо: http://commons.apache.org/lang/api/src-html/org/apache/commons/lang/StringUtils.html#line. 3045

Це, як ми знаємо, підвищить ефективність роботи, але якщо продуктивність є критичною, то використаний метод може бути дещо неефективним. Тоді як інтерфейс є гнучким і дозволить послідовно проводити поведінку для різних типів колекції, для списків це дещо неефективно, що є типом колекції в оригінальному питанні.

Я базую це на тому, що ми несемо певні накладні витрати, яких уникнемо, просто перебравшись у елементи, традиційні для циклу. Натомість є деякі додаткові речі, що відбуваються за лаштунками, перевіряючи паралельні модифікації, виклики методів тощо. З іншого боку, посилений цикл призведе до того ж накладних витрат, оскільки ітератор використовується в об'єкті Iterable (Список).

Для цього можна використовувати Regex. Це настільки стисло, як це виходить

System.out.println(yourArrayList.toString().replaceAll("\\[|\\]|[,][ ]","\t"));

Як щодо цієї функції:

public static String toString(final Collection<?> collection) {
    final StringBuilder sb = new StringBuilder("{");
    boolean isFirst = true;
    for (final Object object : collection) {
        if (!isFirst)
            sb.append(',');
        else
            isFirst = false;
        sb.append(object);
    }
    sb.append('}');
    return sb.toString();
}

він працює для будь-якого типу колекції ...