Перетворення списку <Integer> у список <String>

У мене є список цілих чисел, List<Integer>і я хотів би перетворити всі цілі об'єкти в рядки, закінчивши таким чином новим List<String>.

Природно, я міг створити нове List<String>і циклічне виклик через список, що вимагає String.valueOf()кожного цілого числа, але мені було цікаво, чи існує кращий (читати: більш автоматичний ) спосіб зробити це?

Наскільки мені відомо, ітерація та інстанція - це єдиний спосіб зробити це. Щось на зразок (для інших потенційна допомога, оскільки я впевнений, що ви знаєте, як це зробити):

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метод у класі Списки

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()викинете a, 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», ви можете використовувати Трансформатор і метод збирання від 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, і не загальна, але популярна бібліотека колекцій Джакарти має кілька корисних абстракцій для подібних завдань. Зокрема, перегляньте методи збирання

CollectionUtils

Що варто врахувати, якщо ви вже використовуєте колекції commons у своєму проекті.

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

Використовуєте ви Integer.toString()чи String.valueOf(Object)залежить від того, як ви хочете обробити можливі нулі. Ви хочете викинути виняток (напевно) або мати "null" рядки у своєму списку (можливо). Якщо колишній, ви хочете кинути той NullPointerExceptionчи інший тип?

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

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

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

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

Навіть не хвилюйтеся з приводу продуктивних проблем, викликаних процесом боксу / розпакування. Якщо продуктивність критична, просто використовуйте масив. Якщо це дійсно критично, не використовуйте Java. Спроба перехитрити СВМ призведе лише до болю в серці.

Відповідь лише для експертів:

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

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), але я не знаю, чи компілятор досить розумний для цього. Перетворення з String в Object повинно бути більш-менш неоперативним, тому я не хочу переживати за це.

Я не бачив жодного рішення, яке б відповідало принципу складності простору. Якщо список цілих чисел містить велику кількість елементів, то це велика проблема.

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

Один із шляхів її вирішення. Сподіваюся, це допомагає.

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

Для задоволення - рішення, що використовує jsr166y fork-join Framework, який повинен бути в 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, це трохи виводу типу та синтаксичного цукру, щоб зробити це зMapping менш виразним:

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

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

У нас є клас статичних методів, спеціально створених для виконання таких завдань. Оскільки код для цього настільки простий, ми дозволяємо Hotspot зробити оптимізацію для нас. Здається, це тема в моєму коді останнім часом: написати дуже простий (прямолінійний) код і дозволити Hotspot зробити свою магію. У нас рідко виникають проблеми з таким кодом - коли з'являється нова версія VM, ви отримуєте всі додаткові переваги швидкості тощо.

Наскільки я люблю колекції Джакарти, вони не підтримують дженерики і використовують 1.4 як рідкокристалічний екран. Я насторожено ставлюся до колекцій Google, оскільки вони вказані як рівень підтримки Alpha!

Мені просто хотілося прислухатись до об'єктно-орієнтованого рішення проблеми.

Якщо ви моделюєте доменні об’єкти, то рішення знаходиться в об’єктах домену. Тут домен - це Перелік цілих чисел, для яких ми хочемо рядкових значень.

Найпростішим способом було б взагалі не конвертувати список.

Це було сказано, щоб перетворити без перетворення, змініть початковий список Цілочисника на Список Значень, де Значення виглядає приблизно так ...

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

Це буде швидше і займе менше пам'яті, ніж копіювання списку.

Щасти!