Liste De Conversion<Integer> à la Liste<String>

Question

J'ai une liste d'entiers, List<Integer> et je voudrais convertir tous les entiers d'objets dans les Cordes, donc de finir avec un nouveau List<String>.

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

Answer 1

Autant que je sache, itérer et instancier est la seule façon de le faire.Quelque chose comme (pour les autres potentiels de l'aide, car je suis sûr que vous savez comment le faire):

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

Answer 2

À l'aide de Google Collections de Goyave-Projet, vous pouvez utiliser le transform méthode dans le Listes classe

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

L' List renvoyé par transform est un vue sur la liste de sauvegarde - de la transformation sera appliquée sur chaque accès à la transformée de liste.

Sachez que Functions.toStringFunction() va jeter un NullPointerException lorsqu'il est appliqué à la valeur null, donc à n'utiliser que si vous êtes sûr que votre liste ne contiendra la valeur null.

Answer 3

Solution pour Java 8.Un peu plus de temps que la Goyave une, mais au moins vous n'avez pas à installer une 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());

Answer 4

Ce que vous faites est très bien, mais si vous sentez le besoin de "Java-it-up", vous pourriez utiliser un Transformateur et la recueillir méthode à partir de Apache Commons, par exemple:

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

..et puis..

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

Answer 5

La source de la Chaîne.valueOf montre ceci:

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

Non pas que cela importe beaucoup, mais je voudrais utiliser toString.

Answer 6

Au lieu de l'aide de la Chaîne.valueOf je ne l'utiliserais .toString();il évite certains de l'auto de boxe décrite par @johnathan.hollande

La javadoc dit que valueOf renvoie la même chose que Entier.toString().

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

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

Answer 7

Voici un one-liner solution sans tricher avec un non-JDK bibliothèque.

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

Answer 8

Une autre Solution à l'aide de Goyave et de Java 8

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

Answer 9

Pas de base de Java, et pas des génériques identifiés, mais la populaire Jakarta commons collections de la bibliothèque a quelques abstractions utiles pour ce genre de tâche.Plus précisément, ont un coup d'oeil à la collecte des méthodes sur

CollectionUtils

Quelque chose à considérer si vous êtes déjà à l'aide de communes des collections dans votre projet.

Answer 10

Pour les personnes concernées au sujet de "boxe" dans jsight de réponse:il n'y a aucun. String.valueOf(Object) est utilisé ici, et pas unboxing à int est jamais réalisé.

Si vous utilisez Integer.toString() ou String.valueOf(Object) dépend de la façon dont vous souhaitez gérer les éventuelles valeurs null.Voulez-vous lancer une exception (probablement), ou "null" des Chaînes dans votre liste (peut-être).Si l'ancien, vous souhaitez lancer une NullPointerException ou d'un autre type?

Aussi, une petite faille dans jsight réponse: List est une interface, vous ne pouvez pas utiliser l'opérateur de nouveau sur elle.Je serais probablement utiliser un java.util.ArrayList dans ce cas, surtout depuis que nous savons à l'avant combien de temps la liste est susceptible d'être.

Answer 11

@Jonathan:J'ai peut être tort, mais je crois que Chaîne de caractères.valueOf() dans ce cas, appelez la Chaîne.valueOf(Objet) de la fonction plutôt que de sortir en boîte de Chaîne.valueOf(int).Chaîne de caractères.valueOf(Objet) retourne "null" si elle est nulle ou des appels de l'Objet.toString() si la non-nulle, ce qui ne devrait pas impliquer de boxe (bien que, évidemment, l'instanciation de nouveaux objets de chaîne est impliqué).

Answer 12

Je pense que l'utilisation de l'Objet.toString() pour toute autre fin que la mise au point 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 null).Les développeurs sont libres de modifier le comportement de la méthode toString() sans aucun avertissement, y compris les méthodes toString() les méthodes de toutes les classes de la bibliothèque standard.

Ne vous inquiétez pas sur les problèmes de performance causés par le boxing/unboxing processus.Si la performance est critique, il suffit d'utiliser un tableau.Si c'est vraiment essentiel, ne pas utiliser Java.Tente de déjouer la JVM ne fera que conduire à chagrin d'amour.

Answer 13

Une réponse pour experts seulement:

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

Answer 14

Lambdaj permet de le faire dans un très simple et très lisible.Par exemple, supposons que vous disposez d'une liste d'Entier et que vous souhaitez les convertir dans la représentation de Chaîne vous pouvez écrire quelque chose comme cela;

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 seulement alors que vous êtes en itérant sur le résultat.

Answer 15

Vous ne pouvez pas éviter la "boxe-dessus de la tête;Java est faux générique conteneurs ne peuvent stocker des Objets, de sorte que votre ints doit être mis en boîte en nombres Entiers.En principe, il pourrait éviter les humbles de l'Objet en Entier (car il est inutile, parce que l'Objet est assez bon pour les deux Cordes.valueOf et de l'Objet.toString) mais je ne sais pas si le compilateur est assez intelligent pour le faire.La conversion de la Chaîne de l'Objet doit être plus ou moins no-op, donc je serais pas enclin à vous soucier de cela.

Answer 16

Juste pour le fun, une solution à l'aide de la jsr166y fork-join cadre 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:Pas compilé.Spec n'est pas finalisé.Etc.)

Peu de chances d'être JDK7 est un peu de l'inférence de type et de syntaxe de sucre pour faire que withMapping appeler moins verbeux:

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

Answer 17

C'est un chose à faire, je ne voudrais pas utiliser une bibliothèque externe (il va provoquer une dépendance dans votre projet, que vous avez probablement n'avez pas besoin).

Nous avons une classe de méthodes statiques spécialement pour faire ce genre de travaux.Parce que le code est si simple de nous laisser Hotspot ne l'optimisation pour nous.Cela semble être un thème récurrent dans mon code récemment:écriture très simple (simple) et le code de laisser Hotspot faire sa magie.Nous avons rarement des problèmes de performances autour de ce type de code - lorsqu'une nouvelle VM version vient vous obtenez tous les avantages de rapidité etc.

Autant que j'aime Jakarta collections, ils ne prennent pas en charge les Génériques et l'utilisation 1.4 comme l'écran LCD.Je me méfie de Google Collections parce qu'ils sont répertoriés comme l'Alpha niveau de soutien!

Answer 18

Je ne vois pas de solution qui est la suite de la directrice de l'espace la complexité.Si la liste d'entiers a grand nombre d'éléments, alors il est 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 atteindre le même.

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

Answer 19

Je voulais juste carillon avec un orientée objet, la solution au problème.

Si vous modèle des objets du domaine, puis la solution est dans le domaine des objets.Le domaine ici est une Liste de nombres entiers pour lesquels nous voulons de la chaîne de valeurs.

Le plus simple serait de ne pas convertir la liste à tous.

Cela étant dit, afin de convertir sans avoir à les convertir, modifier l'original de la liste des Entiers de la Liste de Valeur, où la Valeur 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 prendre moins de mémoire que la copie de la Liste.

Bonne Chance!