java - remove - Meilleure façon de convertir une ArrayList en chaîne




java arraylist sublist (19)

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

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

https://code.i-harness.com

J'ai un ArrayList que je veux produire complètement en tant que chaîne. Essentiellement je veux le sortir dans l'ordre en utilisant le toString de chaque élément séparé par des tabulations. Y a-t-il un moyen rapide de le faire? Vous pouvez le parcourir (ou supprimer chaque élément) et le concaténer à une chaîne mais je pense que cela sera très lent.


Boucle à travers et appelle toString. Il n'y a pas de manière magique, et s'il y en avait, que pensez-vous qu'il ferait sous les couvertures autres que de boucler? A propos de la seule micro-optimisation serait d'utiliser StringBuilder au lieu de String, et même ce n'est pas une énorme victoire - chaînes de concaténation se transforme en StringBuilder sous les couvertures, mais au moins si vous é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();

C'est une conversation plutôt ancienne et les communs apache utilisent maintenant un StringBuilder en interne: http://commons.apache.org/lang/api/src-html/org/apache/commons/lang/StringUtils.html#line.3045

Ce sera comme nous savons améliorer la performance, mais si la performance est critique, la méthode utilisée peut être quelque peu inefficace. Alors que l'interface est flexible et permet un comportement cohérent entre différents types de collection, 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 itérant simplement à travers les éléments dans une boucle for traditionnelle. Au lieu de cela, il se passe des choses supplémentaires en arrière-scène pour vérifier les modifications simultanées, les appels de méthode, etc. La boucle for enhanced entraîne le même surcoût puisque l'itérateur est utilisé sur l'objet Iterable (la liste).


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

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

Dans le cas où vous êtes sur Android et que vous n'utilisez pas encore Jack (par exemple parce qu'il manque encore de support pour Instant Run), et si vous voulez plus de contrôle sur le formatage de la chaîne résultante (par exemple, le diviseur d'éléments), et il arrive 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 de vos objets listés.


En Java 8 ou plus tard:

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

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

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

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

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

Est-ce que ce qui suit serait bon?

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

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

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

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

La plupart des projets Java ont souvent des langages apache-commons disponibles. StringUtils.join () méthodes est très agréable et a 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 à joindre, peut être nulle

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

Retourne : l'entrée String, null si null itérateur

Depuis: 2.3


Peut ne pas être le meilleur moyen, mais de manière é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()));
        }
    }

Sortie

[Test, Test2]


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

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

cela fonctionne pour tout type de collection ...


Si vous faites cela sur Android, il y a un bon utilitaire pour ce qu'on appelle TextUtils qui a une .join(String delimiter, Iterable) .

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 figuré je l'ajouterais à ce fil ...


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

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) alors vous pouvez accomplir la même chose comme ceci:

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

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

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 ArrayList en FastList , vous pouvez vous débarrasser de l'adaptateur.

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

Note: Je suis un committer pour Eclipse Collections.


Une façon élégante de gérer les caractères de séparation à la fin est d'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 trailing (ou dans ce cas) des séparateurs principaux.


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

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

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

Vous passez au new StringJoiner la séquence char que vous voulez utiliser comme séparateur. Si vous voulez faire un CSV: new StringJoiner(", ");







arraylist