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.

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.

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

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

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.

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

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.

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

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

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

Android a une classe TextUtil que vous pouvez utiliser http://developer.android.com/reference/android/text/TextUtils.html

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

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

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.

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

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.

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.

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

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

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]

Est-ce que ce qui suit serait bon:

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

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.

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

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

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

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

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

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

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

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

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