Conversion de la liste <Integer> en liste <String>

J'ai une liste d'entiers List<Integer>et j'aimerais convertir tous les objets entiers en chaînes, finissant ainsi avec un nouveau List<String>.

Naturellement, je pourrais créer un nouveau List<String>et faire une boucle dans la liste en appelant String.valueOf()chaque entier, mais je me demandais s'il y avait une meilleure façon (lire: plus automatique ) de le faire?

Autant que je sache, itérer et instancier est le seul moyen de le faire. Quelque chose comme (pour d'autres, une aide potentielle, car je suis sûr que vous savez comment faire cela):

List<Integer> oldList = ...
/* Specify the size of the list up front to prevent resizing. */
List<String> newList = new ArrayList<>(oldList.size());
for (Integer myInt : oldList) { 
  newList.add(String.valueOf(myInt)); 
}

En utilisant Google Collections de Guava-Project , vous pouvez utiliser la transformméthode de la classe Lists

import com.google.common.collect.Lists;
import com.google.common.base.Functions

List<Integer> integers = Arrays.asList(1, 2, 3, 4);

List<String> strings = Lists.transform(integers, Functions.toStringFunction());

Le Listrenvoyé par transformest une vue sur la liste de sauvegarde - la transformation sera appliquée à chaque accès à la liste transformée.

Sachez que Functions.toStringFunction()cela lèvera un NullPointerExceptionlorsqu'il est appliqué à null, donc ne l'utilisez que si vous êtes sûr que votre liste ne contiendra pas null.

Solution pour Java 8. Un peu plus longue que celle de Guava, mais au moins vous n'avez pas besoin d'installer de bibliothèque.

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

//...

List<Integer> integers = Arrays.asList(1, 2, 3, 4);
List<String> strings = integers.stream().map(Object::toString)
                                        .collect(Collectors.toList());

Ce que vous faites est bien, mais si vous ressentez le besoin de «Java-it-up», vous pouvez utiliser un Transformer et la méthode collect d' Apache Commons , par exemple:

public class IntegerToStringTransformer implements Transformer<Integer, String> {
   public String transform(final Integer i) {
      return (i == null ? null : i.toString());
   }
}

..puis..

CollectionUtils.collect(
   collectionOfIntegers, 
   new IntegerToStringTransformer(), 
   newCollectionOfStrings);

La source de String.valueOf montre ceci:

public static String valueOf(Object obj) {
    return (obj == null) ? "null" : obj.toString();
}

Pas que cela compte beaucoup, mais j'utiliserais toString.

Au lieu d'utiliser String.valueOf, j'utiliserais .toString (); cela évite une partie de la boxe automatique décrite par @ johnathan.holland

Le javadoc dit que valueOf renvoie la même chose que Integer.toString ().

List<Integer> oldList = ...
List<String> newList = new ArrayList<String>(oldList.size());

for (Integer myInt : oldList) { 
  newList.add(myInt.toString()); 
}

Voici une solution unique sans tricher avec une bibliothèque non-JDK.

List<String> strings = Arrays.asList(list.toString().replaceAll("\\[(.*)\\]", "$1").split(", "));

Une autre solution utilisant Guava et Java 8

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<String> strings = Lists.transform(numbers, number -> String.valueOf(number));

Pas le noyau Java, ni générique, mais la populaire bibliothèque de collections Jakarta commons a quelques abstractions utiles pour ce type de tâche. Plus précisément, jetez un œil aux méthodes de collecte sur

CollectionUtils

Quelque chose à considérer si vous utilisez déjà des collections communes dans votre projet.

Aux personnes concernées par la "boxe" dans la réponse de jsight: il n'y en a pas. String.valueOf(Object)est utilisé ici, et aucun déballage intn'est jamais effectué.

Le fait que vous utilisiez Integer.toString()ou String.valueOf(Object)dépend de la manière dont vous souhaitez gérer les valeurs nulles possibles. Voulez-vous lever une exception (probablement), ou avoir des chaînes «nulles» dans votre liste (peut-être). Si c'est le premier, voulez-vous lancer un NullPointerExceptionou un autre type?

De plus, un petit défaut dans la réponse de jsight: Listc'est une interface, vous ne pouvez pas utiliser le nouvel opérateur dessus. J'utiliserais probablement un java.util.ArrayListdans ce cas, d'autant plus que nous savons à l'avance combien de temps la liste est susceptible d'être.

List<String> stringList = integerList.stream().map((Object s)->String.valueOf(s)).collect(Collectors.toList())

@Jonathan: Je peux me tromper, mais je crois que String.valueOf () dans ce cas appellera la fonction String.valueOf (Object) plutôt que d'être encadré par String.valueOf (int). String.valueOf (Object) renvoie simplement "null" s'il est nul ou appelle Object.toString () s'il n'est pas nul, ce qui ne devrait pas impliquer de boxe (bien que l'instanciation de nouveaux objets chaîne soit évidemment impliquée).

Je pense que l'utilisation d'Object.toString () à des fins autres que le débogage est probablement une très mauvaise idée, même si dans ce cas, les deux sont fonctionnellement équivalents (en supposant que la liste n'a pas de valeurs nulles). Les développeurs sont libres de modifier le comportement de toute méthode toString () sans aucun avertissement, y compris les méthodes toString () de toutes les classes de la bibliothèque standard.

Ne vous inquiétez même pas des problèmes de performances causés par le processus de boxe / déballage. Si les performances sont essentielles, utilisez simplement une baie. Si c'est vraiment critique, n'utilisez pas Java. Essayer de déjouer la JVM ne conduira qu'à un chagrin d'amour.

Une réponse réservée aux experts:

    List<Integer> ints = ...;
    String all = new ArrayList<Integer>(ints).toString();
    String[] split = all.substring(1, all.length()-1).split(", ");
    List<String> strs = Arrays.asList(split);

Lambdaj permet de le faire d'une manière très simple et lisible. Par exemple, en supposant que vous ayez une liste d'entiers et que vous vouliez les convertir dans la représentation String correspondante, vous pourriez écrire quelque chose comme ça;

List<Integer> ints = asList(1, 2, 3, 4);
Iterator<String> stringIterator = convertIterator(ints, new Converter<Integer, String> {
    public String convert(Integer i) { return Integer.toString(i); }
}

Lambdaj applique la fonction de conversion uniquement pendant que vous itérez sur le résultat.

Vous ne pouvez pas éviter les "frais généraux de boxe"; Les faux conteneurs génériques de Java ne peuvent stocker que des objets, donc vos entiers doivent être encadrés dans des entiers. En principe, cela pourrait éviter le downcast d'Object en Integer (car c'est inutile, car Object est assez bon pour String.valueOf et Object.toString) mais je ne sais pas si le compilateur est assez intelligent pour le faire. La conversion de String en Object devrait être plus ou moins un no-op, donc je serais peu enclin à m'inquiéter à ce sujet.

Je n'ai vu aucune solution qui suit le principe de la complexité spatiale. Si la liste d'entiers a un grand nombre d'éléments, c'est un gros problème.

It will be really good to remove the integer from the List<Integer> and free
the space, once it's added to List<String>.

Nous pouvons utiliser l'itérateur pour réaliser la même chose.

    List<Integer> oldList = new ArrayList<>();
    oldList.add(12);
    oldList.add(14);
    .......
    .......

    List<String> newList = new ArrayList<String>(oldList.size());
    Iterator<Integer> itr = oldList.iterator();
    while(itr.hasNext()){
        newList.add(itr.next().toString());
        itr.remove();
    }

Utilisation des flux: si le résultat est une liste d'entiers ( List<Integer> result), alors:

List<String> ids = (List<String>) result.stream().map(intNumber -> Integer.toString(intNumber)).collect(Collectors.toList());

Une des façons de le résoudre. J'espère que cela t'aides.

Une solution légèrement plus concise en utilisant la méthode forEach sur la liste d'origine:

    List<Integer> oldList = Arrays.asList(1, 2, 3, 4, 5);
    List<String> newList = new ArrayList<>(oldList.size());
    oldList.forEach(e -> newList.add(String.valueOf(e)));

Juste pour le plaisir, une solution utilisant le framework jsr166y fork-join qui devrait dans JDK7.

import java.util.concurrent.forkjoin.*;

private final ForkJoinExecutor executor = new ForkJoinPool();
...
List<Integer> ints = ...;
List<String> strs =
    ParallelArray.create(ints.size(), Integer.class, executor)
    .withMapping(new Ops.Op<Integer,String>() { public String op(Integer i) {
        return String.valueOf(i);
    }})
    .all()
    .asList();

(Avertissement: non compilé. Les spécifications ne sont pas finalisées. Etc.)

Il est peu probable que JDK7 soit un peu d'inférence de type et de sucre syntaxique pour rendre l'appel withMapping moins verbeux:

    .withMapping(#(Integer i) String.valueOf(i))

C'est une chose tellement basique à faire que je n'utiliserais pas de bibliothèque externe (cela entraînerait une dépendance dans votre projet dont vous n'avez probablement pas besoin).

Nous avons une classe de méthodes statiques spécialement conçues pour faire ce genre de travail. Parce que le code est si simple, nous laissons Hotspot faire l'optimisation pour nous. Cela semble être un thème dans mon code récemment: écrivez du code très simple (simple) et laissez Hotspot faire sa magie. Nous avons rarement des problèmes de performances autour d'un code comme celui-ci - lorsqu'une nouvelle version de VM arrive, vous bénéficiez de tous les avantages de vitesse supplémentaires, etc.

Même si j'aime les collections Jakarta, elles ne prennent pas en charge les génériques et utilisent la version 1.4 comme écran LCD. Je me méfie des collections Google car elles sont répertoriées comme niveau de support Alpha!

Je voulais juste intervenir avec une solution orientée objet au problème.

Si vous modélisez des objets de domaine, la solution se trouve dans les objets de domaine. Le domaine ici est une liste d'entiers pour lesquels nous voulons des valeurs de chaîne.

Le moyen le plus simple serait de ne pas convertir du tout la liste.

Cela étant dit, pour convertir sans convertir, changez la liste d'origine des entiers en Liste de valeurs, où Value ressemble à quelque chose comme ça ...

class Value {
    Integer value;
    public Integer getInt()
    {
       return value;
    }
    public String getString()
    {
       return String.valueOf(value);
    }
}

Ce sera plus rapide et occupera moins de mémoire que la copie de la liste.

Bonne chance!