Convertendo List <Integer> em List <String>

Eu tenho uma lista de inteiros List<Integer>e gostaria de converter todos os objetos inteiros em Strings, terminando assim com um novo List<String>.

Naturalmente, eu poderia criar um novo List<String>e percorrer a lista chamando String.valueOf()cada número inteiro, mas gostaria de saber se há uma maneira melhor (leia-se: mais automática ) de fazer isso?

Pelo que eu sei, iterar e instanciar é a única maneira de fazer isso. Algo como (para outros ajuda em potencial, já que tenho certeza que você sabe fazer isso):

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 as coleções do Google do Guava-Project , você pode usar o transformmétodo na 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());

O Listretornado por transformé uma visualização na lista de apoio - a transformação será aplicada em cada acesso à lista transformada.

Esteja ciente de que Functions.toStringFunction()lançará um NullPointerExceptionquando aplicado a null, portanto, use-o somente se tiver certeza de que sua lista não conterá null.

Solução para Java 8. Um pouco mais longa que a Guava, mas pelo menos não precisa instalar 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());

O que você está fazendo está bem, mas se sentir a necessidade de fazer um 'Java-it-up', você pode usar um Transformer e o método de coleta do Apache Commons , por exemplo:

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

..e depois..

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

A fonte de String.valueOf mostra isso:

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

Não que isso importe muito, mas eu usaria toString.

Em vez de usar String.valueOf, eu usaria .toString (); evita alguns dos boxe automático descritos por @ johnathan.holland

O javadoc diz que valueOf retorna a mesma coisa que Integer.toString ().

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

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

Aqui está uma solução de uma linha sem trapacear com uma biblioteca não JDK.

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

Outra solução usando Guava e Java 8

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

Não é o núcleo do Java e não é genérico, mas a popular biblioteca de coleções comuns de Jakarta tem algumas abstrações úteis para esse tipo de tarefa. Especificamente, dê uma olhada nos métodos de coleta em

CollectionUtils

Algo a considerar se você já estiver usando coleções comuns em seu projeto.

Para as pessoas preocupadas com o "boxe" na resposta de jsight: não há nenhum. String.valueOf(Object)é usado aqui, e nenhum unboxing para inté executado.

Se você usa Integer.toString()ou String.valueOf(Object)depende de como deseja tratar possíveis nulos. Você deseja lançar uma exceção (provavelmente) ou ter Strings "nulas" em sua lista (talvez). Se for o primeiro, você quer jogar um NullPointerExceptionou algum outro tipo?

Além disso, uma pequena falha na resposta do jsight: Listé uma interface, você não pode usar o novo operador nela. Eu provavelmente usaria um java.util.ArrayListneste caso, especialmente porque sabemos de antemão o tamanho provável da lista.

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

@Jonathan: Posso estar enganado, mas acredito que String.valueOf () neste caso chamará a função String.valueOf (Object) em vez de ser encaixotado em String.valueOf (int). String.valueOf (Object) apenas retorna "nulo" se for nulo ou chama Object.toString () se não nulo, o que não deve envolver boxing (embora, obviamente, instanciar novos objetos de string esteja envolvido).

Acho que usar Object.toString () para qualquer propósito diferente de depuração é provavelmente uma ideia muito ruim, embora, nesse caso, os dois sejam funcionalmente equivalentes (assumindo que a lista não tenha nulos). Os desenvolvedores são livres para alterar o comportamento de qualquer método toString () sem qualquer aviso, incluindo os métodos toString () de qualquer classe na biblioteca padrão.

Nem se preocupe com os problemas de desempenho causados ​​pelo processo de boxing / unboxing. Se o desempenho for crítico, basta usar um array. Se for realmente crítico, não use Java. Tentar ser mais esperto que o JVM só levará à dor de cabeça.

Uma resposta apenas para especialistas:

    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 fazer isso de uma forma muito simples e legível. Por exemplo, supondo que você tenha uma lista de Inteiros e deseja convertê-los na representação String correspondente, você poderia escrever algo assim;

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 a função de conversão apenas enquanto você está iterando no resultado.

Você não pode evitar a "sobrecarga do boxe"; Os falsos contêineres genéricos do Java só podem armazenar objetos, então seus ints devem ser encaixotados em inteiros. Em princípio, isso poderia evitar o downcast de Object para Integer (uma vez que é inútil, porque Object é bom o suficiente para String.valueOf e Object.toString), mas não sei se o compilador é inteligente o suficiente para fazer isso. A conversão de String para Object deve ser mais ou menos autônoma, então eu não gostaria de me preocupar com isso.

Não vi nenhuma solução que siga o princípio da complexidade do espaço. Se a lista de inteiros tiver um grande número de elementos, é um grande 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 o iterador para conseguir o mesmo.

    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: Se digamos que o resultado é uma lista de inteiros ( List<Integer> result), então:

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

Uma das maneiras de resolver isso. Espero que isto ajude.

Uma solução um pouco mais concisa usando o método forEach na 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)));

Apenas por diversão, uma solução usando a estrutura de junção de garfo jsr166y que deveria estar no 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();

(Isenção de responsabilidade: não compilado. A especificação não foi finalizada. Etc.)

O improvável de estar no JDK7 é um pouco de inferência de tipo e açúcar sintático para tornar a chamada withMapping menos detalhada:

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

Isso é algo tão básico que eu não usaria uma biblioteca externa (isso causará uma dependência em seu projeto que você provavelmente não precisa).

Temos uma classe de métodos estáticos criados especificamente para esse tipo de trabalho. Como o código para isso é tão simples, deixamos o Hotspot fazer a otimização para nós. Este parece ser um tema em meu código recentemente: escrever código muito simples (direto) e deixar o Hotspot fazer sua mágica. Raramente temos problemas de desempenho em torno de código como este - quando uma nova versão VM chega, você obtém todos os benefícios extras de velocidade, etc.

Por mais que eu ame as coleções Jakarta, elas não suportam Genéricos e usam 1.4 como LCD. Desconfio das Coleções do Google porque elas estão listadas como nível de suporte Alfa!

Eu só queria sugerir uma solução orientada a objetos para o problema.

Se você modelar objetos de domínio, a solução está nos objetos de domínio. O domínio aqui é uma lista de inteiros para os quais queremos valores de string.

A maneira mais fácil seria não converter a lista.

Dito isso, para converter sem converter, altere a lista original de Inteiro para Lista de Valor, onde Valor se parece com isto ...

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

Isso será mais rápido e ocupará menos memória do que copiar a lista.

Boa sorte!