Najlepszy sposób na konwersję ArrayList na ciąg znaków

W Javie 8 lub nowszej:

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

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

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

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

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

Oczywiście nie ma większego zastosowania poza Androidem, ale pomyślałem, że dodam go do tego wątku...

Pobierz Jakarta Commons Lang i użyj metody

 StringUtils.join(list)

Można oczywiście zaimplementować go samodzielnie, ale ich kod jest w pełni przetestowany i jest prawdopodobnie najlepszą możliwą implementacją.

Jestem wielkim fanem Jakarta Commons library i uważam, że jest to świetny dodatek do standardowej biblioteki Javy.

To dość stare pytanie, ale pomyślałem, że równie dobrze mogę dodać bardziej nowoczesną odpowiedź-użyj Joiner klasa z :

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

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

Przypadek 1 . Jeśli masz Stringutile apache ' a w swojej ścieżce klasowej (od rogerdpack i Ravi Wallau):

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

Przypadek 2 . Jeśli chcesz używać tylko sposobów z JDK (7):

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

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

Jeśli szukałeś szybkiego jednowiersza, od Javy 5 możesz to zrobić:

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

Dodatkowo, jeśli twoim celem jest tylko wydrukowanie treści i mniej martwisz się o "\ t", możesz po prostu to zrobić:

myList.toString()

Który zwraca łańcuch jak

[str1, str2, str3]

Jeśli masz tablicę (nie ArrayList), możesz wykonać to samo w następujący sposób:

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

Przeprowadź pętlę i wywołaj toString. Nie ma magicznego sposobu, A gdyby tak było, to jak myślisz, co robiłoby pod kołdrą, poza zapętleniem? O jedyną mikro-optymalizacją byłoby użycie Stringbuildera zamiast String, a nawet to nie jest wielka wygrana-konkatenacja ciągów zamienia się w StringBuilder pod okładkami, ale przynajmniej jeśli piszesz to w ten sposób, możesz zobaczyć, 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 często posiada Apache-commons lang. StringUtils.metoda join () jest bardzo przyjemna i ma kilka smaków, aby zaspokoić 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:

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

Separator - znak separatora do użycia

Returns: połączony Łańcuch, null if null iterator input

Od: 2.3

Android ma klasę TextUtil, której możesz użyć http://developer.android.com/reference/android/text/TextUtils.html

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

Eleganckim sposobem radzenia sobie z końcowymi znakami separacyjnymi jest użycie separatora klasy

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 separater, z wyjątkiem dla pierwszego wywołania. W ten sposób drukujemy listę bez końcowych (lub w tym przypadku) wiodących separatorów.

W tym prostym przypadku można po prostu połączyć ciągi znaków przecinkiem. Jeśli używasz Javy 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");

To algorytm O(n) tak czy inaczej (chyba, że zrobiłeś jakieś wielowątkowe rozwiązanie, w którym podzieliłeś listę na wiele podlist, ale nie sądzę, że o to prosisz).

Wystarczy użyć StringBuilder Jak poniżej:

StringBuilder sb = new StringBuilder();

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

String finalString = sb.toString();

StringBuilder będzie o wiele szybsza niż konkatenacja ciągu znaków, ponieważ nie będziesz ponownie tworzyć instancji String obiektu przy każdej konkatenacji.

ArrayList class (Java Docs ) extends AbstractList class, która rozszerza AbstractCollection class, która zawiera metodętoString() (Java Docs ). Więc po prostu napisz

listName.toString();

Programiści Javy już wymyślili najbardziej efektywny sposób i dali ci to w ładnie zapakowanej i udokumentowanej metodzie. Po prostu zadzwoń do tej metody.

W przypadku, gdy zdarzy ci się, że jesteś na Androidzie i nie używasz jeszcze Jack (np. ponieważ wciąż brakuje wsparcia dla Instant Run), i jeśli chcesz mieć większą kontrolę nad formatowaniem wynikowego ciągu znaków (np. chcesz użyć znaku nowej linii jako dzielnika elementów), a zdarzyło ci się użyć / want to use biblioteki StreamSupport (do korzystania ze strumieni w Java 7 lub wcześniejszych wersjach kompilatora), możesz użyć czegoś takiego (umieściłem tę metodę w mojej liście Klasa): {]}

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.

Może nie jest to najlepszy sposób, ale elegancki sposób.

Tablice.deepToString (Węg.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()));
        }
    }

Wyjście

[Test, Test2]

Jeśli używasz kolekcji Eclipse , możesz użyć metody 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"));

Jeśli możesz przekonwertować ArrayList na FastList, możesz pozbyć się adaptera.

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

Uwaga: jestem committerem Dla Kolekcji Eclipse.

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

PRZEKAZUJESZ do new StringJoiner sekwencję znaków, którą chcesz użyć jako separatora. Jeśli chcesz zrobić plik CSV: new StringJoiner(", ");

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

Wyjście:

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

W Javie 8 to proste. Zobacz przykład dla 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 (prostsza do odczytania):

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

Czy to byłoby dobre:

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

Jeśli nie chcesz ostatniego \t po ostatnim elemencie, musisz użyć indeksu, aby sprawdzić, ale pamiętaj, że to tylko "działa" (tzn. jest O (n)), gdy lists implementuje 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());

Do oddzielania za pomocą tabulatorów 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ę sporo przykładów, które zależą od dodatkowych zasobów, ale wydaje się, że byłoby to najprostsze rozwiązanie: (czego użyłem w moim własnym projekcie), który jest w zasadzie tylko konwersją z ArrayList do tablicy, a następnie do listy.

    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 i Apache commons używa teraz wewnętrznie Stringbuildera: http://commons.apache.org/lang/api/src-html/org/apache/commons/lang/StringUtils.html#line.3045

To, jak wiemy, poprawi wydajność, ale jeśli wydajność jest krytyczna, zastosowana metoda może być nieco nieefektywna. Podczas gdy interfejs jest elastyczny i pozwoli na spójne zachowanie w różnych typach kolekcji, jest on nieco nieefektywny w przypadku list, jaki jest rodzaj zbioru w pytaniu pierwotnym.

Bazuję na tym, że ponosimy pewne koszty, których unikniemy, po prostu iterując przez elementy w tradycyjnej pętli for. Zamiast tego za kulisami dzieje się kilka dodatkowych rzeczy, które sprawdzają współbieżne modyfikacje, wywołania metod itp. Z drugiej strony pętla enhanced for spowoduje ten sam narzut, ponieważ iterator jest używany na obiekcie Iterable (lista).

Możesz użyć do tego wyrażenia regularnego. To jest tak zwięzłe, jak się wydaje

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

A może ta funkcja:

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 typu kolekcji...

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

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