Conversión de List <Integer> en List <String>

Tengo una lista de enteros List<Integer>y me gustaría convertir todos los objetos enteros en cadenas, terminando así con un nuevo List<String>.

Naturalmente, podría crear un nuevo List<String>y recorrer la lista llamando String.valueOf()a cada número entero, pero me preguntaba si había una forma mejor (léase: más automática ) de hacerlo.

Hasta donde yo sé, iterar e instanciar es la única forma de hacer esto. Algo como (para otros posibles ayuda, ya que estoy seguro de que sabe cómo hacer esto):

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

Usando Google Collections de Guava-Project , puede usar el transformmétodo en la clase 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());

El Listdevuelto por transformes una vista en la lista de respaldo: la transformación se aplicará en cada acceso a la lista transformada.

Tenga en cuenta que Functions.toStringFunction()arrojará un NullPointerExceptioncuando se aplique a nulo, por lo que solo utilícelo si está seguro de que su lista no contendrá nulos.

Solución para Java 8. Un poco más largo que el de Guava, pero al menos no tienes que instalar una biblioteca.

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

Lo que está haciendo está bien, pero si siente la necesidad de 'Java-it-up', puede usar un Transformer y el método de recopilación de Apache Commons , por ejemplo:

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

..y entonces..

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

La fuente de String.valueOf muestra esto:

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

No es que importe mucho, pero usaría toString.

En lugar de usar String.valueOf, usaría .toString (); evita parte del boxeo automático descrito por @ johnathan.holland

El javadoc dice que valueOf devuelve lo mismo que Integer.toString ().

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

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

Aquí hay una solución de una sola línea sin trampas con una biblioteca que no es JDK.

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

Otra solución usando Guava y Java 8

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

No es Java central ni genérico, pero la popular biblioteca de colecciones de bienes comunes de Yakarta tiene algunas abstracciones útiles para este tipo de tarea. Específicamente, eche un vistazo a los métodos de recopilación en

ColecciónUtils

Algo a tener en cuenta si ya está utilizando colecciones comunes en su proyecto.

Para las personas preocupadas por el "boxeo" en la respuesta de jsight: no hay ninguno. String.valueOf(Object)se utiliza aquí, y intnunca se realiza un desempaquetado .

Si usa Integer.toString()o String.valueOf(Object)depende de cómo quiera manejar posibles nulos. ¿Desea lanzar una excepción (probablemente) o tener cadenas "nulas" en su lista (tal vez)? Si es el primero, ¿quieres lanzar uno NullPointerExceptiono algún otro tipo?

Además, una pequeña falla en la respuesta de jsight: Listes una interfaz, no puede usar el nuevo operador en ella. Probablemente usaría un java.util.ArrayListen este caso, especialmente porque sabemos de antemano cuánto es probable que sea la lista.

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

@Jonathan: Podría estar equivocado, pero creo que String.valueOf () en este caso llamará a la función String.valueOf (Object) en lugar de encuadrarse en String.valueOf (int). String.valueOf (Object) simplemente devuelve "nulo" si es nulo o llama a Object.toString () si no es nulo, lo que no debería involucrar el boxeo (aunque obviamente la instanciación de nuevos objetos de cadena está involucrada).

Creo que usar Object.toString () para cualquier propósito que no sea la depuración es probablemente una muy mala idea, aunque en este caso los dos son funcionalmente equivalentes (asumiendo que la lista no tiene nulos). Los desarrolladores son libres de cambiar el comportamiento de cualquier método toString () sin ninguna advertencia, incluidos los métodos toString () de cualquier clase en la biblioteca estándar.

Ni siquiera se preocupe por los problemas de rendimiento causados ​​por el proceso de empaquetado / desembalaje. Si el rendimiento es crítico, simplemente use una matriz. Si es realmente crítico, no use Java. Tratar de ser más astuto que la JVM solo conducirá a dolores de cabeza.

Una respuesta solo para expertos:

    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 permite hacer eso de una manera muy simple y legible. Por ejemplo, suponiendo que tenga una lista de Integer y quiera convertirlos en la representación de String correspondiente, podría escribir algo así;

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 aplica la función de conversión solo mientras está iterando sobre el resultado.

No puede evitar la "sobrecarga de boxeo"; Los contenedores genéricos falsos de Java solo pueden almacenar objetos, por lo que sus entradas deben estar encasilladas en enteros. En principio, podría evitar la caída de Object a Integer (ya que no tiene sentido, porque Object es lo suficientemente bueno para String.valueOf y Object.toString) pero no sé si el compilador es lo suficientemente inteligente para hacer eso. La conversión de String a Object debería ser más o menos una operación no operativa, por lo que no estaría dispuesto a preocuparme por eso.

No vi ninguna solución que siga el principio de complejidad del espacio. Si la lista de enteros tiene una gran cantidad de elementos, entonces es un gran problema.

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

Podemos usar el iterador para lograr lo mismo.

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

Usando Streams: Si digamos que el resultado es una lista de enteros ( List<Integer> result) entonces:

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

Una de las formas de solucionarlo. Espero que esto ayude.

Una solución un poco más concisa usando el método forEach en la lista original:

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

Solo por diversión, una solución que usa el marco de unión de bifurcación jsr166y que debería estar en 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();

(Descargo de responsabilidad: no compilado. Las especificaciones no están finalizadas. Etc.)

Es poco probable que esté en JDK7 es un poco de inferencia de tipo y azúcar sintáctico para hacer que la llamada con Mapping sea menos detallada:

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

Esto es algo tan básico que no usaría una biblioteca externa (causará una dependencia en su proyecto que probablemente no necesite).

Tenemos una clase de métodos estáticos diseñados específicamente para realizar este tipo de trabajos. Debido a que el código para esto es tan simple, dejamos que Hotspot haga la optimización por nosotros. Este parece ser un tema en mi código recientemente: escriba un código muy simple (directo) y deje que Hotspot haga su magia. Rara vez tenemos problemas de rendimiento con un código como este: cuando aparece una nueva versión de VM, obtiene todos los beneficios de velocidad adicionales, etc.

Por mucho que me gusten las colecciones de Yakarta, no son compatibles con Genéricos y usan 1.4 como LCD. ¡Desconfío de las colecciones de Google porque se enumeran como nivel de soporte Alpha!

Solo quería intervenir con una solución orientada a objetos al problema.

Si modela objetos de dominio, la solución está en los objetos de dominio. El dominio aquí es una lista de enteros para los que queremos valores de cadena.

La forma más sencilla sería no convertir la lista en absoluto.

Dicho esto, para convertir sin convertir, cambie la lista original de Integer a List of Value, donde Value se parece a esto ...

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

Esto será más rápido y ocupará menos memoria que copiar la lista.

¡Buena suerte!