Ich habe eine ArrayList, die ich komplett als String ausgeben möchte. Im Wesentlichen möchte ich es in der Reihenfolge ausgeben, in toStringder jedes Element durch Tabulatoren getrennt ist. Gibt es einen schnellen Weg, dies zu tun? Sie könnten es durchlaufen (oder jedes Element entfernen) und es zu einem String verketten, aber ich denke, das wird sehr langsam sein.

Grundsätzlich ist die Verwendung einer Schleife zum Iterieren über ArrayListdie einzige Option:

Verwenden Sie diesen Code NICHT. Lesen Sie weiter bis zum Ende dieser Antwort, um festzustellen, warum dies nicht wünschenswert ist und welcher Code stattdessen verwendet werden sollte:

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

Tatsächlich ist eine Zeichenfolgenverkettung in Ordnung, da der javacCompiler die Zeichenfolgenverkettung ohnehin als eine Reihe von appendOperationen für eine optimiert StringBuilder. Hier ist ein Teil der Demontage des Bytecodes aus der forSchleife aus dem obigen Programm:

   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;

Wie zu sehen ist, optimiert der Compiler diese Schleife mithilfe von a StringBuilder, sodass die Leistung kein großes Problem darstellen sollte.

(OK, auf den zweiten Blick wird das StringBuilderbei jeder Iteration der Schleife instanziiert, sodass es möglicherweise nicht der effizienteste Bytecode ist. Das Instanziieren und Verwenden eines expliziten Codes StringBuilderwürde wahrscheinlich zu einer besseren Leistung führen.)

Tatsächlich denke ich, dass jede Art von Ausgabe (sei es auf der Festplatte oder auf dem Bildschirm) mindestens eine Größenordnung langsamer ist, als sich um die Leistung von String-Verkettungen sorgen zu müssen.

Bearbeiten: Wie in den Kommentaren erwähnt, erstellt die obige Compileroptimierung tatsächlich StringBuilderbei jeder Iteration eine neue Instanz von . (Was ich zuvor bemerkt habe.)

Die am besten optimierte Technik ist die Antwort von Paul Tomblin , da nur ein einzelnes StringBuilderObjekt außerhalb der forSchleife instanziiert wird.

Umschreiben des obigen Codes auf:

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

Instanziiert nur StringBuildereinmal außerhalb der Schleife und führt nur die beiden Aufrufe der appendMethode innerhalb der Schleife durch, wie in diesem Bytecode (der die Instanziierung StringBuilderund die Schleife zeigt) belegt:

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

In der Tat sollte die Handoptimierung eine bessere Leistung erbringen, da das Innere der forSchleife kürzer ist und nicht StringBuilderbei jeder Iteration ein instanziiert werden muss.

In Java 8 oder höher:

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

Falls der listnicht vom Typ String ist, kann ein Verbindungskollektor verwendet werden:

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

Wenn Sie dies zufällig auf Android tun, gibt es dafür ein nettes Dienstprogramm namens TextUtils, das eine .join(String delimiter, Iterable)Methode hat.

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

Offensichtlich nicht viel Verwendung außerhalb von Android, aber ich dachte, ich würde es diesem Thread hinzufügen ...

Laden Sie die Apache Commons Lang herunter und verwenden Sie die Methode

 StringUtils.join(list)

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

Sie können es natürlich selbst implementieren, aber der Code ist vollständig getestet und wahrscheinlich die bestmögliche Implementierung.

Ich bin ein großer Fan der Apache Commons-Bibliothek und ich denke auch, dass sie eine großartige Ergänzung zur Java Standard Library ist.

Dies ist eine ziemlich alte Frage, aber ich denke, ich könnte genauso gut eine modernere Antwort hinzufügen - verwenden Sie die JoinerKlasse aus Guave :

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

Das Ändern der Liste in eine lesbare und aussagekräftige Zeichenfolge ist eine häufig gestellte Frage, auf die jeder stoßen kann.

Fall 1 . Wenn Sie Apaches StringUtils in Ihrem Klassenpfad haben (wie von Rogerdpack und Ravi Wallau):

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

Fall 2 . Wenn Sie nur Wege aus JDK (7) verwenden möchten:

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

Bauen Sie niemals Räder selbst, verwenden Sie keine Schleife für diese einzeilige Aufgabe.

Wenn Sie nach einem schnellen Einzeiler suchen, können Sie ab Java 5 Folgendes tun:

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

Wenn Sie nur den Inhalt ausdrucken möchten und sich weniger Gedanken über das "\ t" machen, können Sie dies einfach tun:

myList.toString()

was eine Zeichenfolge wie zurückgibt

[str1, str2, str3]

Wenn Sie ein Array (nicht ArrayList) haben, können Sie dasselbe wie folgt erreichen:

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

Durchlaufen Sie es und rufen Sie String auf. Es gibt keinen magischen Weg, und wenn ja, was würde er Ihrer Meinung nach unter der Decke tun, außer ihn zu durchlaufen? Die einzige Mikrooptimierung wäre die Verwendung von StringBuilder anstelle von String, und selbst das ist kein großer Gewinn - das Verketten von Strings wird unter dem Deckmantel zu StringBuilder, aber zumindest wenn Sie es so schreiben, können Sie sehen, was los ist.

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

In den meisten Java-Projekten steht häufig Apache-Commons-Sprache zur Verfügung. Die Methoden von StringUtils.join () sind sehr nett und bieten verschiedene Varianten, um fast alle Anforderungen zu erfüllen.

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

Parameter:

Sammlung - Die Sammlung von Werten, die zusammengefügt werden sollen, kann null sein

Trennzeichen - das zu verwendende Trennzeichen

Rückgabe : Der verknüpfte String, null, wenn null Iteratoreingabe

Seit: 2.3

Android verfügt über eine TextUtil-Klasse, die Sie unter http://developer.android.com/reference/android/text/TextUtils.html verwenden können

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

Für diesen einfachen Anwendungsfall können Sie die Zeichenfolgen einfach mit Komma verbinden. Wenn Sie Java 8 verwenden:

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

Andernfalls hat commons-lang eine join () -Methode:

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

Eine elegante Möglichkeit, mit nachgestellten Trennzeichen umzugehen, ist die Verwendung des Klassentrennzeichens

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

Die toString-Methode von Class Separator gibt das Separator mit Ausnahme des ersten Aufrufs zurück. Daher drucken wir die Liste ohne nachfolgende (oder in diesem Fall) führende Trennzeichen.

In Java 8 ist es einfach. Siehe Beispiel für eine Liste von Ganzzahlen:

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

Oder eine mehrzeilige Version (die einfacher zu lesen ist):

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

Update - eine kürzere Version

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

Es ist so oder so ein O(n)Algorithmus (es sei denn, Sie haben eine Multithread-Lösung durchgeführt, bei der Sie die Liste in mehrere Unterlisten aufgeteilt haben, aber ich denke nicht, dass Sie danach fragen).

Verwenden Sie einfach ein StringBuilderwie folgt:

StringBuilder sb = new StringBuilder();

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

String finalString = sb.toString();

Das StringBuilderwird viel schneller als String - Verkettung, weil Sie nicht wieder Instanziieren ein sein StringObjekt auf jeder Verkettung.

Für den Fall, dass Sie gerade auf Android sind und Jack noch nicht verwenden (z. B. weil Instant Run noch nicht unterstützt wird) und wenn Sie mehr Kontrolle über die Formatierung der resultierenden Zeichenfolge wünschen (z. B. möchten Sie das Zeilenumbruchzeichen als verwenden der Teiler der Elemente) und zufällig die StreamSupport-Bibliothek verwenden / verwenden möchten (für die Verwendung von Streams unter Java 7 oder früheren Versionen des Compilers), könnten Sie Folgendes verwenden (ich habe diese Methode in meine ListUtils-Klasse eingefügt):

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

Stellen Sie natürlich sicher, dass Sie toString () in der Klasse Ihrer Listenobjekte implementieren.

Wenn Sie das letzte \ t nach dem letzten Element nicht möchten, müssen Sie den Index verwenden, um dies zu überprüfen. Beachten Sie jedoch, dass dies nur "funktioniert" (dh O (n)), wenn Listen den RandomAccess implementieren.

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

Der folgende Code kann Ihnen helfen,

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

Ausgabe:

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

Vielleicht nicht der beste, aber elegante Weg.

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

Ausgabe

[Test, Test2]

Wäre folgendes gut:

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

Wenn Sie Eclipse-Sammlungen verwenden , können Sie die makeString()Methode verwenden.

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

Wenn Sie Ihre ArrayListin a konvertieren können FastList, können Sie den Adapter entfernen.

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

Hinweis: Ich bin ein Committer für Eclipse-Sammlungen.

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

Sie übergeben die new StringJoinerZeichenfolge, die Sie als Trennzeichen verwenden möchten. Wenn Sie eine CSV erstellen möchten:new StringJoiner(", ");

In einer Zeile: Von [12,0,1,78,12] bis 12 0 1 78 12

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

Zum Trennen mithilfe von Registerkarten anstelle von println können Sie print verwenden

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

Ich sehe einige Beispiele, die von zusätzlichen Ressourcen abhängen, aber es scheint, dass dies die einfachste Lösung wäre: (was ich in meinem eigenen Projekt verwendet habe), die im Grunde nur von einer ArrayList in ein Array und dann in eine Liste konvertiert .

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

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

Dies ist mittlerweile eine ziemlich alte Konversation, und Apache Commons verwenden jetzt intern einen StringBuilder: http://commons.apache.org/lang/api/src-html/org/apache/commons/lang/StringUtils.html#line. 3045

Dies wird bekanntlich die Leistung verbessern. Wenn die Leistung jedoch kritisch ist, ist die verwendete Methode möglicherweise etwas ineffizient. Während die Benutzeroberfläche flexibel ist und ein konsistentes Verhalten über verschiedene Sammlungstypen hinweg ermöglicht, ist sie für Listen, die der Sammlungstyp in der ursprünglichen Frage ist, etwas ineffizient.

Ich begründe dies damit, dass wir einen gewissen Overhead verursachen, den wir vermeiden würden, indem wir einfach die Elemente in einer traditionellen for-Schleife durchlaufen. Stattdessen passieren hinter den Kulissen einige zusätzliche Dinge, die auf gleichzeitige Änderungen, Methodenaufrufe usw. prüfen. Die erweiterte for-Schleife führt andererseits zu demselben Overhead, da der Iterator für das Iterable-Objekt (die Liste) verwendet wird.

Sie können hierfür einen Regex verwenden. Dies ist so kurz wie es nur geht

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

Wie wäre es mit dieser Funktion:

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

es funktioniert für jede Art von Sammlung ...