Meilleure façon de convertir un ArrayList en chaîne

353

J'ai un ArrayListque je veux sortir complètement sous forme de chaîne. Essentiellement, je veux le sortir dans l'ordre en utilisant le toStringde chaque élément séparé par des tabulations. Existe-t-il un moyen rapide de procéder? Vous pouvez le parcourir (ou supprimer chaque élément) et le concaténer en une chaîne, mais je pense que ce sera très lent.

Juan Besa
la source
4
ou supprimez chaque élément Soyez prudent, supprimer des éléments d'une liste ArrayList est un gros NON-NON, car votre "boucle" prendra du temps quadratique en raison du déplacement des éléments (à condition que vous boucliez du premier au dernier élément).
Dimitry K
Idem pour les collections: stackoverflow.com/questions/395401/…
Ciro Santilli 郝海东 冠状 病 六四 事件 法轮功

Réponses:

329

Fondamentalement, l'utilisation d'une boucle pour parcourir le ArrayListest la seule option:

N'UTILISEZ PAS ce code, continuez à lire au bas de cette réponse pour voir pourquoi il n'est pas souhaitable et quel code devrait être utilisé à la place:

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

En fait, une concaténation de chaînes va être très bien, car le javaccompilateur optimisera la concaténation de chaînes comme une série d' appendopérations de StringBuildertoute façon. Voici une partie du démontage du bytecode de la forboucle du programme ci-dessus:

   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;

Comme on peut le voir, le compilateur optimise cette boucle en utilisant un StringBuilder, donc les performances ne devraient pas être un gros problème.

(OK, au deuxième coup d'œil, l' StringBuilderinstanciation est effectuée à chaque itération de la boucle, donc ce n'est peut-être pas le bytecode le plus efficace. L'instanciation et l'utilisation d'un explicite StringBuilderdonneraient probablement de meilleures performances.)

En fait, je pense qu'avoir n'importe quelle sorte de sortie (que ce soit sur le disque ou sur l'écran) sera au moins un ordre de grandeur plus lent que d'avoir à se soucier des performances des concaténations de chaînes.

Edit: Comme indiqué dans les commentaires, l'optimisation du compilateur ci-dessus crée en effet une nouvelle instance de StringBuilderà chaque itération. (Ce que j'ai noté précédemment.)

La technique la plus optimisée à utiliser sera la réponse de Paul Tomblin , car elle instancie uniquement un seul StringBuilderobjet en dehors de la forboucle.

Réécriture dans le code ci-dessus pour:

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

N'instanciera qu'une seule StringBuilderfois à l'extérieur de la boucle, et ne fera que les deux appels à la appendméthode à l'intérieur de la boucle, comme en témoigne ce bytecode (qui montre l'instanciation de StringBuilderet la boucle):

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

Ainsi, l'optimisation de la main devrait en effet être plus performante, car l'intérieur de la forboucle est plus court et il n'est pas nécessaire d'instancier un StringBuilderà chaque itération.

coobird
la source
8
Envisagez d'utiliser une classe StringBuilder au lieu de simplement ajouter des chaînes, pour des raisons de performances.
Jeremy
5
Le compilateur optimisera la concaténation de chaînes mais vous créerez un nouvel objet StringBuilder à chaque exécution de la boucle.
Pedro Henriques
4
-1 pour l'utilisation de + =, dans ce cas, c'est un tueur de performance. Utilisez toujours StringBuilder pour l'ajout répété à une chaîne.
starblue
10
Cette solution ajoute un "\ t" supplémentaire à la fin de la chaîne, ce qui est souvent indésirable, en particulier lorsque vous souhaitez créer une liste séparée par des virgules ou similaire. Je pense que les autres solutions publiées ici, utilisant Apache Commons ou Guava, sont supérieures.
Peter Goetz
3
Ce n'est pas la meilleure réponse. Regardez ci-dessous Vitalii pour Javaou Geewax pourAndroid
Gibolt
896

Dans Java 8 ou version ultérieure:

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

Dans le cas où le listn'est pas de type String, un collecteur de jointure peut être utilisé:

String listString = list.stream().map(Object::toString)
                        .collect(Collectors.joining(", "));
Vitalii Fedorenko
la source
144
Je ne peux pas croire qu'il ait fallu attendre Java 8 pour ajouter cela.
Paul
45
Cette réponse devrait être davantage votée! Pas de hacks, pas de bibliothèques et pas de boucles.
Songo
4
cela ne fonctionne pas pour ce que le PO a dit. String.join prend comme deuxième argument Iterable <? étend CharSequence>. Cela fonctionne donc si vous avez une List <String> que vous souhaitez afficher, mais si vous avez List <MyObject>, il n'appellera pas toString () comme souhaité par l'OP
Hilikus
3
Pourquoi diable ce n'est pas la première (et acceptée) réponse .. Je dois toujours faire défiler jusqu'à ce que je sache qu'elle est là .. élégante et concise
Jack
2
Nécessite Android API 26+
Arsen Sench
391

S'il vous arrive de le faire sur Android, il existe un bel utilitaire pour cela appelé TextUtils qui a une .join(String delimiter, Iterable)méthode.

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

Évidemment, pas beaucoup d'utilisation en dehors d'Android, mais je pensais l'ajouter à ce fil ...

JJ Geewax
la source
1
Puisque TextUtils.joinprend un Object[], je suppose qu'il fait appel toString()à chaque jeton. Met en PatientDetailsœuvre toString()? Si cela ne résout pas le problème, vous pourriez être coincé à faire quelque chose avec la Separatorclasse.
JJ Geewax
5
org.apache.lang3.StringUtilsfait pratiquement la même chose, donc votre réponse m'a été d'une grande utilité en dehors d'Android :)
Patrick
1
La popularité de cette réponse (actuellement la plus votée) montre que de nombreuses questions java proviennent du développement Android
Amr H. Abd Elmajeed
1
Je peux parier que vous avez été envoyé sur cette Terre pour résoudre mon problème :)
kofoworola
1
Tu m'as sauvé la vie. <3
Pratik Butani
234

Téléchargez le langage Apache Commons et utilisez la méthode

 StringUtils.join(list)

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

Vous pouvez l'implémenter par vous-même, bien sûr, mais leur code est entièrement testé et est probablement la meilleure implémentation possible.

Je suis un grand fan de la bibliothèque Apache Commons et je pense aussi que c'est un excellent ajout à la bibliothèque standard Java.

Ravi Wallau
la source
63
Malheureusement, les habitants de SO préfèrent réinventer la roue.
skaffman
33
Également dans Apache Commons Lang. L'utilisation ressemblerait àStringUtils.join(list.toArray(),"\t")
Muhd
33
Cette roue particulière ne vaut guère une dépendance supplémentaire.
Seva Alekseyev
25
@SevaAlekseyev Je pense que c'est discutable. Si vous ajoutez cette dépendance tout de suite, vous utiliserez ses classes beaucoup plus souvent qu'autrement. Au lieu d'utiliser "if string! = Null && string.trim ()! =" ", Vous utiliserez StringUtils.isNotEmpty ... Vous utiliserez ObjectUtils.equals () afin de ne pas avoir à rechercher de null partout. Mais si vous attendez la seule dépendance qui justifie l'utilisation de ces bibliothèques, vous ne les utiliserez peut-être jamais réellement
Ravi Wallau
6
C'est aussi bien qu'il n'ajoutera pas d'onglet supplémentaire à la fin!
keuleJ
139

C'est une question assez ancienne, mais je pense que je pourrais aussi bien ajouter une réponse plus moderne - utilisez la Joinerclasse de Guava :

String joined = Joiner.on("\t").join(list);
Jon Skeet
la source
2
Ceci est ma solution préférée. : -> +1 pour la goyave.
csgeek
Ctrl + F'd pour Guava également. Merci!
Priidu Neemre
List <String> list = new ArrayList <String> (); list.add ("Bonjour"); list.add ("Hai"); list.add ("Salut"); System.out.println (list.toString (). Substring (1, list.toString (). Length () - 1) .replaceAll (",", "\ t"));
Lova Chittumuri
86

Changer la liste en une chaîne lisible et significative est vraiment une question courante que chacun peut rencontrer.

Cas 1 . Si vous avez StringUtils d'Apache dans votre chemin de classe (comme de rogerdpack et Ravi Wallau):

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

Cas 2 . Si vous ne souhaitez utiliser que les moyens de JDK (7):

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

Ne construisez jamais de roues vous-même, n'utilisez pas de boucle pour cette tâche en ligne.

Sheng.W
la source
1
Je n'ai pas remarqué votre solution Case 2 avant de poster la mienne. Le vôtre est en fait beaucoup mieux et enregistre l'étape supplémentaire. Je le recommanderais certainement par-dessus certaines des réponses qui semblent nécessiter des outils supplémentaires.
Elliander
5
Arrays.toString(myList.toArray())- la solution la plus simple et la plus simple
Ondrej Bozek
Je pense que cela devrait être considéré comme la solution la meilleure et la plus efficace
Morey
Arrays.toString(list.toArray())est facile à écrire, mais très inefficace.
Matthieu
60

Si vous cherchiez un one-liner rapide, à partir de Java 5 vous pouvez le faire:

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

De plus, si votre but est simplement d'imprimer le contenu et que vous vous souciez moins du "\ t", vous pouvez simplement faire ceci:

myList.toString()

qui renvoie une chaîne comme

[str1, str2, str3]

Si vous avez un tableau (pas ArrayList), vous pouvez accomplir la même chose comme ceci:

 Arrays.toString(myList).replaceAll("\\[|\\]", "").replaceAll(", ","\t")
Ken Shih
la source
3
Je pense que c'est en fait plus efficace que les méthodes affichées ci-dessus. Quelle honte que ça se voit en bas. Ce n'est peut-être pas élégant, mais je crois fermement que votre solution exécute O (n) tandis que les autres s'exécutent théoriquement en O (n ^ 2) (puisque les chaînes Java sont immuables, vous créez essentiellement une nouvelle chaîne à chaque fusion, et cela devient pire lorsque la la chaîne résultante devient plus grande)
user3790827
Si votre texte est très volumineux, vous finissez par manger les ressources de votre ordinateur.
user3790827
Cette méthode est 7 à 8 fois plus lente que l'utilisation de StringBuilder.
Zoka
@ user3790827 Vous regardez à un niveau très superficiel. Si je vous dis de rechercher une personne dans les mménages des nvilles des xÉtats, vous diriez que c'est O(mnx)ou O(n^3), mais je peux la reformuler pour dire "recherchez cette personne dans ce pays", et vous me diriez immédiatement O(n). En plus de cela, tous les algorithmes ici sont généralement O(n), il n'y a pas de boucle dans une boucle.
Jai
39

Parcourez-le et appelez toString. Il n'y a pas de moyen magique, et s'il y en avait, que pensez-vous qu'il ferait sous les couvertures à part le boucler? La seule micro-optimisation serait d'utiliser StringBuilder au lieu de String, et même ce n'est pas une énorme victoire - concaténer des chaînes se transforme en StringBuilder sous les couvertures, mais au moins si vous l'écrivez de cette façon, vous pouvez voir ce qui se passe.

StringBuilder out = new StringBuilder();
for (Object o : list)
{
  out.append(o.toString());
  out.append("\t");
}
return out.toString();
Paul Tomblin
la source
Merci! c'est ce que je finis par faire :)
Juan Besa
4
Pour les grands tableaux, ce n'est certainement pas une micro-optimisation. La conversion automatique pour utiliser StringBuilder se fait séparément pour chaque concaténation de chaînes, ce qui n'aide pas dans le cas d'une boucle. C'est OK si vous concaténez un grand nombre d'éléments dans une expression.
starblue
1
L'utilisation explicite de StringBuilder est un gros problème si vous concaténons disons 50 000 chaînes faisant ~ 1 Mo de chaîne de résultat - cela peut être une différence de 1 min par rapport au temps d'exécution de 1 s.
M. Napik
36

La plupart des projets Java ont souvent une langue apache-commons disponible. Les méthodes StringUtils.join () sont très agréables et ont plusieurs saveurs pour répondre à presque tous les besoins.

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

Paramètres:

collection - la collection de valeurs à réunir, peut être nulle

separator - le caractère séparateur à utiliser

Renvoie : la chaîne jointe, nulle si entrée d'itérateur nulle

Depuis: 2.3

Brian
la source
2
C'est très bien car la join(...)méthode a des variantes pour les tableaux et les collections.
vikingsteve
J'avais besoin de créer des collections de chaînes avec des éléments rarement remplis, avec des nombres aléatoires. À la fin, j'avais besoin d'une chaîne, pas d'un tableau, pas d'un tableau à chaîne. Voici mon code: Collections.shuffle (L); StringBuilder sb = new StringBuilder (); L.forEach (e -> sb.append (e)); return sb.toString ();
dobrivoje
14

Pour ce cas d'utilisation simple, vous pouvez simplement joindre les chaînes avec une virgule. Si vous utilisez Java 8:

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

sinon commons-lang a une méthode join ():

String csv = org.apache.commons.lang3.StringUtils.join(yourArray, "\t");
Khader MA
la source
13

Une manière élégante de gérer les caractères de séparation de fin consiste à utiliser le séparateur de classes

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

La méthode toString de Class Separator renvoie le séparateur, sauf pour le premier appel. Ainsi, nous imprimons la liste sans traîner (ou dans ce cas) les séparateurs principaux.

akuhn
la source
8

En Java 8, c'est simple. Voir l'exemple pour la liste des entiers:

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

Ou version multiligne (qui est plus simple à lire):

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

Mise à jour - une version plus courte

String result = Arrays.asList(1,2,3).stream()
                .map(Object::toString)
                .collect(Collectors.joining("\t"));
amra
la source
2
Ce n'est peut-être qu'une ligne de code, mais pour moi, cela ne semble pas simple. Pour moi, parcourir la liste et analyser ses éléments dans la chaîne est plus simple que cela.
Bartzilla
1
C'était aussi ma première impression. Mais après m'y être habitué, je le trouve génial. Par exemple, vous pouvez ajouter des opérations comme filter. Au final, il m'est beaucoup plus facile de lire le code.
amra
3
Dans Java 8: String.join ("\ t", array)
Tomasz
Le dernier commentaire ne fonctionne que si le contenu est Stringégalement. Si c'est une liste de Integers, vous avez un problème
LeO
Tous les 3 nécessitent un niveau d'API 24 sur Android.
Asad35Waheed
6

C'est un O(n)algorithme de toute façon (sauf si vous avez fait une solution multi-thread où vous avez divisé la liste en plusieurs sous-listes, mais je ne pense pas que c'est ce que vous demandez).

Utilisez simplement un StringBuildercomme ci-dessous:

StringBuilder sb = new StringBuilder();

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

String finalString = sb.toString();

Le StringBuildersera beaucoup plus rapide que la concaténation de chaînes car vous ne réinstancierez pas un Stringobjet à chaque concaténation.

Mike C.
la source
5

Dans le cas où vous vous trouvez sur Android et que vous n'utilisez pas encore Jack (par exemple, car il manque toujours de support pour Instant Run), et si vous voulez plus de contrôle sur le formatage de la chaîne résultante (par exemple, vous souhaitez utiliser le caractère de nouvelle ligne comme le diviseur d'éléments), et d'utiliser / vouloir utiliser la bibliothèque StreamSupport (pour utiliser des flux sur Java 7 ou des versions antérieures du compilateur), vous pouvez utiliser quelque chose comme ça (je mets cette méthode dans ma classe ListUtils):

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

Et bien sûr, assurez-vous d'implémenter toString () sur la classe des objets de votre liste.

Javad Sadeqzadeh
la source
1
L'utilisation reduceest extrêmement inefficace pour la concaténation de chaînes. Vous devez le faire de la manière Java 8 return StreamSupport.stream(list).map(Object::toString).collect(joining("\n"))qui utilise en interne StringJoiner. Il n'y a aucune raison que vous ne puissiez pas faire cela avec streamsupport également.
Stefan Zobel
Une autre chose est que votre code échouerait horriblement (à cause de Optional#get) s'il obtient une liste vide.
Stefan Zobel
@StefanZobel Merci d'avoir signalé les problèmes d'efficacité et de cas marginaux. Modification du code.
Javad Sadeqzadeh
3

Si vous ne voulez pas le dernier \ t après le dernier élément, vous devez utiliser l'index pour vérifier, mais n'oubliez pas que cela ne "fonctionne" (c'est-à-dire O (n)) que lorsque listes implémente 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());

la source
3

Le code ci-dessous peut vous aider,

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

Production:

Step-1 : [1, 2, 3]
Step-2 : 1, 2, 3
Srinivasan.S
la source
3

Peut-être pas la meilleure façon, mais élégante.

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

Production

[Test, Test2]

Mohan Narayanaswamy
la source
1
Je pense que c'est la meilleure façon si «meilleur» signifie la lisibilité du code. Je n'ai pas regardé le code, mais il est probablement aussi efficace que la méthode StringBuilder (il utilise probablement un StringBuilder sous le capot), mais pas aussi personnalisable dans la sortie.
Mike Miller
3

Est-ce que ce qui suit serait bon:

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

Si vous utilisez des collections Eclipse , vous pouvez utiliser la makeString()méthode.

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

Si vous pouvez convertir votre ArrayListen un FastList, vous pouvez vous débarrasser de l'adaptateur.

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

Remarque: je suis un committer pour les collections Eclipse.

Craig P. Motlin
la source
3
List<String> stringList = getMyListOfStrings();
StringJoiner sj = new StringJoiner(" ");
stringList.stream().forEach(e -> sj.add(e));
String spaceSeparated = sj.toString()

Vous passez à la new StringJoinerséquence de caractères que vous souhaitez utiliser comme séparateur. Si vous voulez faire un CSV:new StringJoiner(", ");

fmsf
la source
3

En une ligne: de [12,0,1,78,12] à 12 0 1 78 12

String srt= list.toString().replaceAll("\\[|\\]|,","");
Pratyush Pranjal
la source
2
1) Il n'y a plus de raison d'utiliser du code comme celui-ci (il y a 4 ans!). 2) Cette réponse n'ajoute rien au Q&R.
Radiodef
5 étoiles sur une seule ligne. Merci beaucoup.
Atef Farouk
Cela fonctionne parfaitement. Pour une chaîne séparée par des virgules, utilisez: String srt = list.toString (). ReplaceAll ("\ [| \]", "");
Asad35Waheed
2

Pour séparer en utilisant des onglets au lieu d'utiliser println, vous pouvez utiliser 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");
}
côtelettes
la source
1

Je vois pas mal d'exemples qui dépendent de ressources supplémentaires, mais il semble que ce serait la solution la plus simple: (qui est ce que j'ai utilisé dans mon propre projet) qui consiste simplement à convertir une ArrayList en une Array puis en une List .

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

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

Il s'agit maintenant d'une conversation assez ancienne et apache commons utilise désormais un StringBuilder en interne: http://commons.apache.org/lang/api/src-html/org/apache/commons/lang/StringUtils.html#line. 3045

Comme nous le savons, cela améliorera les performances, mais si les performances sont critiques, la méthode utilisée pourrait être quelque peu inefficace. Alors que l'interface est flexible et permettra un comportement cohérent entre les différents types de collections, elle est quelque peu inefficace pour les listes, qui est le type de collection dans la question d'origine.

Je base cela en ce que nous encourons des frais généraux que nous éviterions en parcourant simplement les éléments dans une boucle for traditionnelle. Au lieu de cela, il y a des choses supplémentaires qui se produisent en arrière-plan pour vérifier les modifications simultanées, les appels de méthode, etc. La boucle for améliorée entraînera en revanche la même surcharge puisque l'itérateur est utilisé sur l'objet Iterable (la liste).

Alex VI
la source
0

Vous pouvez utiliser un Regex pour cela. C'est aussi concis que possible

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

Que diriez-vous de cette fonction:

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

ça marche pour tout type de collection ...

développeur android
la source