Le meilleur moyen de convertir une liste de tableaux à une chaîne

Fondamentalement, à l'aide d'une boucle pour parcourir les ArrayList est la seule option:

N'utilisez PAS ce code, continuer la lecture vers le bas de cette réponse de voir pourquoi il n'est pas souhaitable, et dont le code doit ê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îne est va être très bien, comme le javac compilateur d'optimiser la concaténation de chaîne comme une série de append opérations sur un StringBuilder de toute façon. Voici une partie du démontage du bytecode de la for boucle à partir 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 en boucle à l'aide d'un StringBuilder, de sorte que les performances ne devraient pas être une grande préoccupation.

(OK, sur le deuxième coup d'œil, le StringBuilder est instancié à chaque itération de la boucle, de sorte qu'il peut ne pas être le plus efficace du bytecode. L'instanciation et l'utilisation explicite StringBuilder produirait probablement de meilleures performances.)

En fait, je pense que le fait d'avoir toute sorte de sortie (que ce soit sur disque ou sur l'écran) sera d'au moins un ordre de grandeur plus lent que d'avoir à vous soucier de la performance de la chaîne de concaténations.

Edit: Comme l'a souligné dans les commentaires, ci-dessus optimisation du compilateur est en effet la création d'une nouvelle instance de StringBuilder à chaque itération. (Que j'ai mentionné précédemment.)

Le plus optimisé la technique à utiliser sera la réponse par Paul Tomblin, car elle ne s'instancie un StringBuilder objet en dehors de la for boucle.

Réécrire 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());

Ne instancier la StringBuilder une fois à l'extérieur de la boucle, et de faire les deux appels à la append méthode à l'intérieur de la boucle, comme en témoigne cette bytecode (qui montre l'instanciation de StringBuilder et 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

Donc, en effet la main d'optimisation devrait être plus performants, comme l'intérieur de la for boucle est plus court et il n'est pas nécessaire d'instancier un StringBuilder à chaque itération.

S'il vous arrive de le faire sur Android, il y a une belle utilité pour cela appelé TextUtils qui a un .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 l'utiliser en dehors d'Android, mais pensé que je voudrais ajouter à ce fil...

C'est une jolie vieille question, mais je me dis que je pourrais bien ajouter un plus moderne réponse - utiliser le Menuiserie classe de Goyave:

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

Si vous avez été la recherche d'un rapide one-liner, comme de Java 5, vous pouvez le faire:

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

En outre, si votre but est simplement d'imprimer le contenu et sont moins concernés par le "\t", vous pouvez simplement faire ceci:

myList.toString()

qui retourne une chaîne de caractères comme

[str1, str2, str3]

Si vous avez un Tableau (pas de liste de tableaux), alors vous pouvez faire la même chose comme ceci:

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

La plupart des projets Java ont souvent apache commons lang disponibles. StringUtils.join() méthodes est très agréable et dispose de plusieurs saveurs pour satisfaire 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 Collecte de valeurs pour se joindre ensemble, peut être null

séparateur - le caractère séparateur à utiliser

Retourne: le joint de la Chaîne, la valeur null si
null itérateur en entrée

Depuis:
2.3

Une élégante façon de traiter avec fuite de la séparation des caractères est d'utiliser Classe Séparateur

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 la Classe Séparateur renvoie la separater, sauf pour le premier appel. Nous avons donc l'impression de la liste sans fuite (ou dans ce cas), conduisant à des séparateurs.

ArrayList classe (Java Docs) s'étend AbstractList classe, qui s'étend AbstractCollection classe qui contient une toString() méthode (Java Docs). Donc, il suffit d'écrire

listName.toString();

Les développeurs Java ont déjà trouvé le moyen le plus efficace, et vous ai donné que dans une, joliment emballé, et la méthode documentée. Simplement appeler cette méthode.

Dans le cas où vous arrive d'être sur Android, et vous n'êtes pas à l'aide de Jack encore (par exemple, parce que c'est encore un manque de soutien pour l'Instant de Lancer), 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 saut de ligne comme le séparateur d'éléments), et arriver à utiliser/vous désirez utiliser le StreamSupport bibliothèque (pour l'utilisation des cours d'eau sur Java 7 ou versions antérieures du compilateur), vous pouvez utiliser quelque chose comme ceci (j'ai mis cette méthode dans mon ListUtils classe):

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 de mettre en œuvre les méthodes toString() sur la liste des objets de la classe.

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

De sortie:

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

Suite être tout bon:

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

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

Vous passez à la new StringJoiner le char de la séquence que vous souhaitez être utilisé comme séparateur. Si vous voulez faire un CSV: new StringJoiner(", ");

Pour les séparant à l'aide d'onglets au lieu d'utiliser println vous pouvez utiliser impression

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'est un assez vieux conversation en maintenant et apache commons sont maintenant à l'aide d'un StringBuilder en interne: http://commons.apache.org/lang/api/src-html/org/apache/commons/lang/StringUtils.html#line.3045

Ce sera comme nous le savons améliorer les performances, mais si la performance est critique ensuite la méthode utilisée pourrait être quelque peu inefficace. Alors que l'interface est flexible et permettra constante de leur comportement à travers les différents types de Collection, il est quelque peu inefficace pour les Listes, qui est le type de Collecte dans la question d'origine.

Je me base que nous sommes encourir des frais généraux qui nous permettrait d'éviter simplement en parcourant les éléments traditionnels de la boucle. Au lieu de cela il y a certaines choses qui se passe derrière les coulisses de la vérification pour les modifications concurrentes, les appels de méthode etc. Le renforcement de boucle d'autre part de résultat dans les mêmes frais généraux depuis l'itérateur est utilisé sur l'objet Itérable (la Liste).

En une seule Ligne :
À partir de [12,0,1,78,12] 12 0 1 78 12

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