Mam coś ArrayList, co chcę wyprowadzić całkowicie jako ciąg. Zasadniczo chcę wyprowadzać go w kolejności, używając toStringkażdego elementu oddzielonego tabulatorami. Czy jest jakiś szybki sposób na to? Możesz przejść przez niego (lub usunąć każdy element) i połączyć go w ciąg znaków, ale myślę, że będzie to bardzo powolne.

Zasadniczo użycie pętli do iteracji ArrayListjest jedyną opcją:

NIE używaj tego kodu, kontynuuj czytanie na dole tej odpowiedzi, aby zobaczyć, dlaczego nie jest pożądane, i który kod należy zastosować zamiast tego:

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

W rzeczywistości konkatenacja łańcuchów będzie w porządku, ponieważ javackompilator zoptymalizuje konkatenację łańcuchów jako serię appendoperacji StringBuilder. Oto część demontażu kodu bajtowego z forpętli z powyższego programu:

   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;

Jak widać, kompilator optymalizuje tę pętlę za pomocą a StringBuilder, więc wydajność nie powinna być dużym problemem.

(OK, na drugi rzut oka StringBuilderinstancja jest tworzona przy każdej iteracji pętli, więc może nie być najbardziej wydajnym kodem bajtowym. Tworzenie instancji i używanie jawnego StringBuilderprawdopodobnie poprawiłoby wydajność.)

W rzeczywistości myślę, że posiadanie jakiegokolwiek wyjścia (czy to na dysk, czy na ekran) będzie co najmniej o rząd wielkości wolniejsze niż martwienie się o wydajność konkatenacji łańcuchów.

Edycja: Jak wskazano w komentarzach, powyższa optymalizacja kompilatora rzeczywiście tworzy nowe wystąpienie StringBuilderkażdej iteracji. (Które zauważyłem wcześniej.)

Najbardziej zoptymalizowaną techniką do zastosowania będzie odpowiedź Paula Tomblina , ponieważ tworzy ona tylko pojedynczy StringBuilderobiekt poza forpętlą.

Przepisanie powyższego kodu do:

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

Utworzy tylko StringBuilderjedną instancję poza pętlą i wykona tylko dwa wywołania appendmetody wewnątrz pętli, jak pokazano w tym kodzie bajtowym (który pokazuje instancję StringBuilderi pętlę):

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

Rzeczywiście, optymalizacja ręki powinna być lepsza, ponieważ wnętrze forpętli jest krótsze i nie ma potrzeby tworzenia wystąpienia StringBuilderprzy każdej iteracji.

W Javie 8 lub nowszej:

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

W przypadku, gdy listnie jest typu String, można użyć łączącego kolektora:

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

Jeśli robisz to na Androidzie, istnieje przyjemne narzędzie do tego o nazwie TextUtils, które ma .join(String delimiter, Iterable)metodę.

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

Oczywiście niewiele poza Androidem, ale pomyślałem, że dodam go do tego wątku ...

Pobierz Apache Commons Lang i skorzystaj z metody

 StringUtils.join(list)

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

Oczywiście możesz to zaimplementować samodzielnie, ale ich kod jest w pełni przetestowany i prawdopodobnie jest to najlepsza możliwa implementacja.

Jestem wielkim fanem biblioteki Apache Commons i uważam również, że jest to świetny dodatek do biblioteki Java Standard Library.

To dość stare pytanie, ale myślę, że równie dobrze mogę dodać bardziej nowoczesną odpowiedź - skorzystaj z Joinerklasy z Guawy :

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

Zmiana listy na czytelny i znaczący ciąg znaków jest tak naprawdę częstym pytaniem, z którym każdy może się spotkać.

Przypadek 1 . Jeśli masz aplet StringUtils na swojej ścieżce klasy (jak z rogerdpack i Ravi Wallau):

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

Przypadek 2 . Jeśli chcesz korzystać tylko z JDK (7):

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

Po prostu nigdy nie buduj samodzielnie kół, nie używaj pętli do tego zadania w jednej linii.

Jeśli szukałeś szybkiego jednuliniowego oprogramowania, od wersji Java 5 możesz to zrobić:

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

Dodatkowo, jeśli Twoim celem jest jedynie wydrukowanie zawartości i nie martwisz się o „\ t”, możesz po prostu to zrobić:

myList.toString()

który zwraca ciąg podobny do

[str1, str2, str3]

Jeśli masz tablicę (nie ArrayList), możesz wykonać to samo:

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

Pętlę i wywoływanie toString. Nie ma magicznego sposobu, a jeśli tak, to co, według niego, działałoby pod przykryciem innym niż przechodzenie przez niego? Jedyną mikrooptymalizacją byłoby użycie StringBuilder zamiast String, a nawet to nie jest ogromna wygrana - łączenie łańcuchów zamienia się w StringBuilder pod przykryciem, ale przynajmniej jeśli napiszesz to w ten sposób, zobaczysz, co się dzieje.

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

Większość projektów Java ma często dostępny język apache-commons. Metody StringUtils.join () są bardzo ładne i mają kilka smaków, które zaspokoją prawie każdą potrzebę.

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

Parametry:

kolekcja - zbiór wartości do połączenia, może być zerowy

separator - znak separatora do użycia

Zwroty : połączony ciąg, null, jeśli iterator jest pusty

Od: 2.3

Android ma klasę TextUtil, z której można korzystać http://developer.android.com/reference/android/text/TextUtils.html

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

W tym prostym przypadku użycia możesz po prostu połączyć ciągi przecinkiem. Jeśli używasz Java 8:

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

w przeciwnym razie commons-lang ma metodę join ():

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

Eleganckim sposobem radzenia sobie z końcowymi znakami separacji jest użycie separatora klas

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

Metoda toString klasy Separator zwraca separator, z wyjątkiem pierwszego wywołania. Dlatego drukujemy listę bez końcowych (lub w tym przypadku) wiodących separatorów.

W Javie 8 jest to proste. Zobacz przykład listy liczb całkowitych:

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

Lub wersja wielowierszowa (łatwiejsza do odczytania):

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

Aktualizacja - krótsza wersja

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

To jest O(n) algorytm w obu kierunkach (chyba że wykonałeś jakieś wielowątkowe rozwiązanie, w którym podzieliłeś listę na wiele list podrzędnych, ale nie sądzę, że o to prosisz).

Po prostu użyj StringBuilderponiższego:

StringBuilder sb = new StringBuilder();

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

String finalString = sb.toString();

StringBuilderBędzie dużo szybciej niż ciąg konkatenacji, ponieważ nie będzie ponowne utworzenie wystąpienia Stringobiektu na każdej konkatenacji.

Jeśli zdarzyło Ci się być na Androidzie i jeszcze nie używasz Jacka (np. Ponieważ wciąż brakuje wsparcia dla Instant Run) i jeśli chcesz mieć większą kontrolę nad formatowaniem wynikowego łańcucha (np. Chciałbyś użyć znaku nowej linii jako dzielnik elementów) i zdarzyło się użyć / chcesz użyć biblioteki StreamSupport (do korzystania ze strumieni w Javie 7 lub wcześniejszych wersjach kompilatora), możesz użyć czegoś takiego (umieściłem tę metodę w mojej klasie ListUtils):

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

I oczywiście upewnij się, że zaimplementowałeś toString () w klasie obiektów listy.

Jeśli nie chcesz ostatniego \ t po ostatnim elemencie, musisz użyć indeksu do sprawdzenia, ale pamiętaj, że to „działa” (tj. O (n)), gdy listy implementują 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());

Poniższy kod może ci pomóc,

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

Wynik:

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

Może nie być najlepszy, ale elegancki sposób.

Arrays.deepToString (Arrays.asList („Test”, „Test2”)

import java.util.Arrays;

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

Wynik

[Test, Test2]

Czy byłoby coś dobrego:

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

Jeśli korzystasz z kolekcji Eclipse , możesz użyć tej makeString()metody.

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

Jeśli możesz przekonwertować swój ArrayListna FastList, możesz pozbyć się adaptera.

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

Uwaga: jestem osobą odpowiedzialną za kolekcje Eclipse.

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

Przechodzisz do new StringJoinersekwencji char, której chcesz użyć jako separatora. Jeśli chcesz zrobić plik CSV:new StringJoiner(", ");

W jednej linii: od [12,0,1,78,12] do 12 0 1 78 12

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

Do oddzielania za pomocą zakładek zamiast println możesz użyć 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");
}

Widzę kilka przykładów, które zależą od dodatkowych zasobów, ale wydaje się, że byłoby to najprostsze rozwiązanie: (tego właśnie użyłem w swoim własnym projekcie), który w zasadzie jest po prostu konwertowany z ArrayList na Array, a następnie na Listę .

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

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

To już dość stara rozmowa, a wspólne apache używają teraz StringBuilder wewnętrznie: http://commons.apache.org/lang/api/src-html/org/apache/commons/lang/StringUtils.html#line. 3045

Jak wiemy, poprawi to wydajność, ale jeśli wydajność ma kluczowe znaczenie, zastosowana metoda może być nieco nieefektywna. Chociaż interfejs jest elastyczny i pozwoli na spójne zachowanie różnych typów kolekcji, jest on nieco nieefektywny w przypadku list, co jest rodzajem kolekcji w pierwotnym pytaniu.

Opieram to na tym, że ponosimy pewne koszty ogólne, których unikalibyśmy, po prostu iterując elementy w tradycyjnej pętli for. Zamiast tego za kulisami dzieją się pewne dodatkowe rzeczy, które sprawdzają, czy są równoległe modyfikacje, wywołania metod itp. Ulepszona pętla for spowoduje z drugiej strony ten sam narzut, ponieważ iterator jest używany na obiekcie Iterable (List).

Możesz do tego użyć Regex. To jest tak zwięzłe, jak to możliwe

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

A co z tą funkcją:

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

działa dla każdego rodzaju kolekcji ...