Преобразование 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)); 
}

@Jonathan: Я могу ошибаться, но я считаю, что String.valueOf () в этом случае вызовет функцию String.valueOf (Object), а не будет вставлен в String.valueOf (int). String.valueOf (Object) просто возвращает «null», если он равен нулю, или вызывает Object.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()); 
}

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

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

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

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

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

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

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

CollectionUtils

Что следует учитывать, если вы уже используете в своем проекте общие коллекции.

То, что вы делаете, в порядке, но если вы чувствуете необходимость «Java-it-up», вы можете использовать Трансформатор и метод сбора из 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);

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

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

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

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

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

Просто для удовольствия, решение, использующее структуру 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(#(Integer i) String.valueOf(i))

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

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

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

Используя Коллекции Google от Guava-Project, вы можете использовать метод transform в классе Списки

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.

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

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

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

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

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

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

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

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

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

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

Удачи!

Решение для 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());

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

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

I didn't see any solution which is following the principal of space complexity. If list of integers has large number of elements then it's big problem.

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<String> stringList = integerList.stream().map((Object s)->String.valueOf(s)).collect(Collectors.toList())

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

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

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

Чуть более краткое решение с использованием метода 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)));