Преобразование List‹Integer› в List‹String›

Насколько я знаю, итерация и создание экземпляров - единственный способ сделать это. Что-то вроде (для потенциальной помощи другим, так как я уверен, что вы знаете, как это сделать):

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

Используя Коллекции Google от Guava-Project, вы можете использовать метод transform в класс 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());

List, возвращаемый transform, представляет собой представление в резервном списке — преобразование будет применяться при каждом доступе к преобразованному списку.

Имейте в виду, что Functions.toStringFunction() выдаст NullPointerException при применении к null, поэтому используйте его только в том случае, если вы уверены, что ваш список не будет содержать null.

Решение для Java 8. Немного дольше, чем решение для Guava, но, по крайней мере, вам не нужно устанавливать библиотеку.

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

То, что вы делаете, прекрасно, но если вы чувствуете потребность в «Java-it-up», вы можете использовать Transformer и метод сбора из Apache Commons, например:

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

..а потом..

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

Источник для String.valueOf показывает это:

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

Не то чтобы это имело большое значение, но я бы использовал toString.

Вместо использования String.valueOf я бы использовал .toString(); он избегает некоторых автобоксов, описанных @johnathan.holland

В javadoc сказано, что valueOf возвращает то же самое, что и Integer.toString().

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

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

Вот однострочное решение без обмана с библиотекой, отличной от JDK.

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

Другое решение с использованием Guava и Java 8

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

Не основная Java и не обобщенная, но в популярной библиотеке коллекций Jakarta Commons есть несколько полезных абстракций для такого рода задач. В частности, взгляните на методы сбора на

CollectionUtils

Кое-что, что следует учитывать, если вы уже используете коллекции Commons в своем проекте.

Людям, обеспокоенным «боксом» в jsight, ответ: его нет. Здесь используется String.valueOf(Object), и распаковка в int никогда не выполняется.

Используете ли вы Integer.toString() или String.valueOf(Object), зависит от того, как вы хотите обрабатывать возможные значения NULL. Вы хотите создать исключение (возможно) или иметь «нулевые» строки в своем списке (возможно). Если первое, вы хотите выбросить NullPointerException или какой-то другой тип?

Кроме того, один небольшой недостаток в ответе jsight: List — это интерфейс, вы не можете использовать новый оператор на нем. Я бы, вероятно, использовал java.util.ArrayList в этом случае, тем более что мы заранее знаем, насколько длинным будет список.

Немного более лаконичное решение с использованием метода forEach в исходном списке:

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

@Jonathan: я могу ошибаться, но я считаю, что String.valueOf() в этом случае вызовет функцию String.valueOf(Object), а не будет упакована в String.valueOf(int). String.valueOf(Object) просто возвращает "null", если оно равно null, или вызывает Object.toString(), если оно не равно null, что не должно включать бокс (хотя, очевидно, задействовано создание экземпляров новых строковых объектов).

Я думаю, что использование Object.toString() для любых целей, кроме отладки, вероятно, действительно плохая идея, хотя в этом случае они функционально эквивалентны (при условии, что в списке нет нулей). Разработчики могут без предупреждения изменять поведение любого метода toString(), включая методы toString() любых классов стандартной библиотеки.

Даже не беспокойтесь о проблемах с производительностью, вызванных процессом упаковки/распаковки. Если производительность критична, просто используйте массив. Если это действительно критично, не используйте Java. Попытка перехитрить JVM приведет только к сердечной боли.

Ответ только для экспертов:

    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 позволяет сделать это очень простым и удобочитаемым способом. Например, предположим, что у вас есть список целых чисел, и вы хотите преобразовать их в соответствующее строковое представление, вы можете написать что-то вроде этого;

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 применяет функцию преобразования только во время повторения результата.

Вы не можете избежать «накладных расходов на бокс»; Поддельные универсальные контейнеры Java могут хранить только объекты, поэтому ваши целые числа должны быть упакованы в целые числа. В принципе, можно было бы избежать преобразования Object в Integer (поскольку это бессмысленно, потому что Object достаточно хорош как для String.valueOf, так и для Object.toString), но я не знаю, достаточно ли умен компилятор для этого. Преобразование из строки в объект должно быть более или менее бесперспективным, поэтому я бы не стал беспокоиться об этом.

Я не видел решения, которое соответствовало бы принципу пространственной сложности. Если список целых чисел имеет большое количество элементов, то это большая проблема.

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

Мы можем использовать итератор для достижения того же самого.

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

Использование потоков: если, скажем, результатом является список целых чисел (List<Integer> result), то:

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

Один из способов ее решения. Надеюсь это поможет.

Просто для удовольствия, решение, использующее инфраструктуру fork-join jsr166y, которая должна быть в 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();

(Отказ от ответственности: не скомпилировано. Спецификация не завершена. И т. д.)

Маловероятно, что в JDK7 есть немного вывода типа и синтаксического сахара, чтобы сделать вызов withMapping менее подробным:

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

Это такая простая вещь, что я бы не стал использовать внешнюю библиотеку (это вызовет зависимость в вашем проекте, которая вам, вероятно, не нужна).

У нас есть класс статических методов, специально созданных для таких задач. Поскольку код для этого очень прост, мы позволили Hotspot сделать оптимизацию за нас. Кажется, это тема моего кода в последнее время: писать очень простой (прямой) код и позволить Hotspot делать свое волшебство. У нас редко возникают проблемы с производительностью, связанные с таким кодом — когда появляется новая версия виртуальной машины, вы получаете все дополнительные преимущества в скорости и т. д.

Как бы я ни любил коллекции Jakarta, они не поддерживают Generics и используют 1.4 в качестве ЖК-дисплея. Я настороженно отношусь к коллекциям Google, потому что они указаны как уровень поддержки Alpha!

Я просто хотел присоединиться к объектно-ориентированному решению проблемы.

Если вы моделируете объекты домена, то решение находится в объектах домена. Домен здесь представляет собой список целых чисел, для которых нам нужны строковые значения.

Самый простой способ — вообще не преобразовывать список.

При этом, чтобы преобразовать без преобразования, измените исходный список Integer на List of Value, где Value выглядит примерно так...

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

Это будет быстрее и займет меньше памяти, чем копирование списка.

Удачи!