Beste Möglichkeit, eine ArrayList in eine Zeichenfolge zu konvertieren

353

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.

Juan Besa
quelle
4
oder entfernen Sie jedes Element Seien Sie vorsichtig, das Entfernen von Elementen aus einer ArrayList-Liste ist ein großes NEIN-NEIN, da Ihre "Schleife" aufgrund von Verschiebungselementen quadratische Zeit benötigt (vorausgesetzt, Sie schleifen vom ersten zum letzten Element).
Dimitry K
Gleiches gilt für Sammlungen: stackoverflow.com/questions/395401/…
Ciro Santilli 法轮功 冠状 病 六四 事件 2

Antworten:

329

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.

Coobird
quelle
8
Verwenden Sie aus Leistungsgründen eine StringBuilder-Klasse, anstatt nur Zeichenfolgen anzuhängen.
Jeremy
5
Der Compiler optimiert die String-Verkettung, aber Sie erstellen jedes Mal, wenn die Schleife ausgeführt wird, ein neues StringBuilder-Objekt.
Pedro Henriques
4
-1 für die Verwendung von + =, in diesem Fall ist es ein Leistungskiller. Verwenden Sie StringBuilder immer zum wiederholten Anhängen an eine Zeichenfolge.
Starblue
10
Diese Lösung fügt am Ende der Zeichenfolge ein zusätzliches "\ t" hinzu, was häufig unerwünscht ist, insbesondere wenn Sie eine durch Kommas getrennte Liste oder ähnliches erstellen möchten. Ich denke, die anderen hier veröffentlichten Lösungen mit Apache Commons oder Guava sind überlegen.
Peter Goetz
3
Dies ist nicht die beste Antwort. Schauen Sie unten bei Vitalii nach Javaoder Geewax nachAndroid
Gibolt
895

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(", "));
Vitalii Fedorenko
quelle
144
Ich kann nicht glauben, dass es bis Java 8 gedauert hat, um dies hinzuzufügen.
Paul
45
Diese Antwort sollte mehr hochgestimmt werden! Keine Hacks, keine Bibliotheken und keine Loops.
Songo
4
Dies funktioniert nicht für das, was das OP gesagt hat. String.join nimmt als zweites Argument Iterable <? erweitert CharSequence>. Es funktioniert also, wenn Sie eine Liste <String> haben, die Sie anzeigen möchten, aber wenn Sie List <MyObject> haben, wird toString () nicht aufgerufen, wie vom OP
gewünscht
3
Warum zum Teufel ist dies nicht die erste (und akzeptierte) Antwort. Ich muss immer nach unten scrollen, bis ich weiß, dass es da ist. Elegant und prägnant
Jack
2
Benötigt Android API 26+
Arsen Sench
391

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

JJ Geewax
quelle
1
Da TextUtils.joindauert ein Object[], würde ich annehmen, dass es toString()auf jedem Token aufruft . Hat PatientDetailszu implementieren toString()? Wenn das Problem dadurch nicht gelöst wird, können Sie möglicherweise etwas mit der SeparatorKlasse anfangen.
JJ Geewax
5
org.apache.lang3.StringUtilsmacht praktisch das gleiche, so dass Ihre Antwort für mich außerhalb von Android absolut von großem Nutzen war :)
Patrick
1
Die Popularität dieser Antwort (derzeit die am höchsten
gewählte
1
Ich kann wetten, dass Sie auf diese Erde geschickt wurden, um mein Problem zu lösen :)
Kofoworola
1
Du hast mein Leben gerettet. <3
Pratik Butani
234

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.

Ravi Wallau
quelle
63
Leider ziehen es die Bewohner von SO vor, das Rad neu zu erfinden.
Skaffman
33
Auch in Apache Commons Lang. Die Verwendung würde aussehen wieStringUtils.join(list.toArray(),"\t")
Muhd
33
Dieses spezielle Rad ist kaum eine zusätzliche Abhängigkeit wert.
Seva Alekseyev
25
@SevaAlekseyev Ich denke, das ist umstritten. Wenn Sie diese Abhängigkeit sofort hinzufügen, werden Sie ihre Klassen viel häufiger verwenden als nicht. Anstatt "if string! = Null && string.trim ()! =" "Zu verwenden, verwenden Sie StringUtils.isNotEmpty ... Sie verwenden ObjectUtils.equals (), damit Sie nicht überall nach null suchen müssen Wenn Sie auf die eine Abhängigkeit warten, die die Verwendung dieser Bibliotheken rechtfertigt, werden Sie sie möglicherweise nie tatsächlich verwenden.
Ravi Wallau
6
Es ist auch schön, dass am Ende kein zusätzlicher Tab hinzugefügt wird!
KeuleJ
139

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);
Jon Skeet
quelle
2
Dies ist meine Lieblingslösung. : -> +1 für Guave.
Csgeek
Strg + F auch für Guave. Vielen Dank!
Priidu Neemre
List <String> list = new ArrayList <String> (); list.add ("Hallo"); list.add ("Hai"); list.add ("Hi"); System.out.println (list.toString (). Teilstring (1, list.toString (). Length () - 1) .replaceAll (",", "\ t"));
Lova Chittumuri
86

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.

Sheng.W
quelle
1
Ich habe Ihre Case 2-Lösung nicht bemerkt, bevor ich meine eigene veröffentlicht habe. Ihre ist eigentlich viel besser und spart den zusätzlichen Schritt. Ich würde es definitiv über einige der Antworten empfehlen, die zusätzliche Tools erfordern.
Elliander
5
Arrays.toString(myList.toArray())- die einfachste und einfachste Lösung
Ondrej Bozek
Ich denke, dies sollte als die beste und effizienteste Lösung angesehen werden
Morey
Arrays.toString(list.toArray())ist leicht zu schreiben, aber sehr ineffizient.
Matthieu
60

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")
Ken Shih
quelle
3
Ich denke, das ist tatsächlich effizienter als die oben beschriebenen Methoden. So eine Schande, dass es unten gezeigt wird. Es mag nicht elegant sein, aber ich bin fest davon überzeugt, dass Ihre Lösung O (n) ausführt, während die anderen theoretisch in O (n ^ 2) ausgeführt werden (da Java-Strings unveränderlich sind, erstellen Sie bei jeder Zusammenführung im Grunde genommen einen neuen String, und dieser wird schlimmer als der resultierende
Zeichenfolge
Wenn Ihr Text sehr groß ist, verbrauchen Sie am Ende die Ressourcen Ihres Computers.
user3790827
Diese Methode ist 7-8 mal langsamer als die Verwendung von StringBuilder.
Zoka
@ user3790827 Sie betrachten eine sehr oberflächliche Ebene. Wenn ich Ihnen sage, dass Sie nach einer Person in mHaushalten in nStädten in xBundesstaaten suchen sollen , würden Sie sagen, dass es O(mnx)oder ist O(n^3), aber ich kann es umformulieren, um zu sagen: "Suchen Sie nach dieser Person in diesem Land", und Sie würden es mir sofort sagen O(n). Darüber hinaus gibt es bei allen Algorithmen im Allgemeinen O(n)keine Schleife innerhalb einer Schleife.
Jai
39

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();
Paul Tomblin
quelle
Vielen Dank! das ist, was ich am Ende mache :)
Juan Besa
4
Für große Arrays ist dies definitiv keine Mikrooptimierung. Die automatische Konvertierung zur Verwendung von StringBuilder erfolgt separat für jede Zeichenfolgenverkettung, was im Fall einer Schleife nicht hilfreich ist. Es ist in Ordnung, wenn Sie eine große Anzahl von Elementen in einem Ausdruck verketten.
Starblue
1
Die explizite Verwendung des StringBuilder ist eine große Sache, wenn Sie beispielsweise 50.000 Zeichenfolgen verketten, die ~ 1 MB Ergebniszeichenfolge ergeben - dies kann eine Differenz von 1 Minute gegenüber der Ausführungszeit von 1 s sein.
Herr Napik
36

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

Brian
quelle
2
Dies ist sehr schön, da die join(...)Methode Varianten sowohl für Arrays als auch für Sammlungen enthält.
Wikingersteve
Ich musste Sammlungen von Zeichenfolgen mit selten aufgefüllten Elementen und Zufallszahlen erstellen. Am Ende brauchte ich einen String, kein Array, kein Array zum String. Dies ist mein Code: Collections.shuffle (L); StringBuilder sb = new StringBuilder (); L. für jeden (e -> sb.append (e)); return sb.toString ();
Dobrivoje
14

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");
Khader MA
quelle
13

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.

akuhn
quelle
8

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"));
amra
quelle
2
Dies ist vielleicht nur eine Codezeile, aber für mich sieht das nicht einfach aus. Für mich ist es einfacher, die Liste zu durchlaufen und ihre Elemente in den String zu analysieren.
Bartzilla
1
Dies war auch mein erster Eindruck. Aber nachdem ich mich daran gewöhnt habe, finde ich es großartig. Zum Beispiel können Sie Operationen wie hinzufügen filter. Am Ende fällt es mir viel leichter, den Code zu lesen.
Amra
3
In Java 8: String.join ("\ t", Array)
Tomasz
Der letzte Kommentar funktioniert nur, wenn der Inhalt ebenfalls ein ist String. Wenn es eine Liste von Integers ist, haben Sie ein Problem
LeO
Alle 3 erfordern API Level 24 auf Android.
Asad35Waheed
6

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.

Mike C.
quelle
5

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.

Javad Sadeqzadeh
quelle
1
Die Verwendung reduceist für die Verkettung von Zeichenfolgen äußerst ineffizient. Sie sollten dies auf die Java 8-Methode tun, return StreamSupport.stream(list).map(Object::toString).collect(joining("\n"))die intern verwendet wird StringJoiner. Es gibt keinen Grund, warum Sie dies nicht auch mit Streamsupport tun könnten .
Stefan Zobel
Eine andere Sache ist, dass Ihr Code schrecklich (aufgrund der Optional#get) fehlschlagen würde, wenn er eine leere Liste übergeben wird.
Stefan Zobel
@StefanZobel Vielen Dank, dass Sie auf die Effizienz- und Randfallprobleme hingewiesen haben. Code geändert.
Javad Sadeqzadeh
3

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

quelle
3

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
Srinivasan.S
quelle
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]

Mohan Narayanaswamy
quelle
1
Ich denke, dies ist der beste Weg, wenn "am besten" Code-Lesbarkeit bedeutet. Ich habe mir den Code nicht angesehen, aber er ist wahrscheinlich genauso effizient wie die StringBuilder-Methode (sie verwendet wahrscheinlich einen StringBuilder unter der Haube), obwohl er in der Ausgabe nicht so anpassbar ist.
Mike Miller
3

Wäre folgendes gut:

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

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.

Craig P. Motlin
quelle
3
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(", ");

fmsf
quelle
3

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

String srt= list.toString().replaceAll("\\[|\\]|,","");
Pratyush Pranjal
quelle
2
1) Es gibt keinen Grund mehr, solchen Code zu verwenden (seit 4 Jahren!). 2) Diese Antwort fügt den Fragen und Antworten nichts hinzu.
Radiodef
5 Sterne in einer Zeile. Vielen Dank.
Atef Farouk
Das funktioniert perfekt. Verwenden Sie für durch Kommas getrennte Zeichenfolgen: String srt = list.toString (). ReplaceAll ("\ [| \]", "");
Asad35Waheed
2

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

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;
   }
Elliander
quelle
0

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.

Alex VI
quelle
0

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

System.out.println(yourArrayList.toString().replaceAll("\\[|\\]|[,][ ]","\t"));
Vikrant Goel
quelle
-1

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

Android-Entwickler
quelle