Простий спосіб конвертувати Iterable в колекцію

У своїй програмі я використовую сторонню бібліотеку (точні дані Spring для MongoDB).

Методи цієї бібліотеки повертаються Iterable<T>, а решта мого коду очікує Collection<T>.

Чи є десь корисний метод, який дозволить мені швидко перетворити один в інший? Я хотів би уникнути створення купок foreachциклів у своєму коді для такої простої речі.

За допомогою Guava ви можете використовувати Lists.newArrayList (Iterable) або Sets.newHashSet (Iterable) серед інших подібних методів. Це, звичайно, скопіює всі елементи в пам'ять. Якщо це не прийнятно, я думаю, що ваш код, який працює з цими, повинен брати, Iterableа не Collection. Також Guava пропонує зручні методи для виконання тих, що ви можете робити, Collectionвикористовуючи Iterable(наприклад, Iterables.isEmpty(Iterable)або Iterables.contains(Iterable, Object)), але наслідки для продуктивності більш очевидні.

У JDK 8+, не використовуючи додаткових ліб:

Iterator<T> source = ...;
List<T> target = new ArrayList<>();
source.forEachRemaining(target::add);

Редагувати: наведене вище для Iterator. Якщо ви маєте справу з Iterable,

iterable.forEach(target::add);

Ви також можете написати свій власний корисний метод для цього:

public static <E> Collection<E> makeCollection(Iterable<E> iter) {
    Collection<E> list = new ArrayList<E>();
    for (E item : iter) {
        list.add(item);
    }
    return list;
}

Коротке рішення з Java 8 за допомогою java.util.stream:

public static <T> List<T> toList(final Iterable<T> iterable) {
    return StreamSupport.stream(iterable.spliterator(), false)
                        .collect(Collectors.toList());
}

IteratorUtilsз commons-collectionsможе допомогти (хоча вони не підтримують генерики в останньої стабільної версії 3.2.1):

@SuppressWarnings("unchecked")
Collection<Type> list = IteratorUtils.toList(iterable.iterator());

Версія 4.0 (яка є в SNAPSHOT на даний момент) підтримує генеричні дані, і ви можете позбутися від @SuppressWarnings.

Оновлення: Перевірте IterableAsListвід кактусів .

З колекціїUtils :

List<T> targetCollection = new ArrayList<T>();
CollectionUtils.addAll(targetCollection, iterable.iterator())

Ось повні джерела цього корисного методу:

public static <T> void addAll(Collection<T> collection, Iterator<T> iterator) {
    while (iterator.hasNext()) {
        collection.add(iterator.next());
    }
}

Перебуваючи при цьому, не забувайте, що всі колекції є обмеженими, а Iterable взагалі не обіцяє. Якщо щось є Ітерабельним, ви можете отримати Ітератор, і це все.

for (piece : sthIterable){
..........
}

буде розширено до:

Iterator it = sthIterable.iterator();
while (it.hasNext()){
    piece = it.next();
..........
}

it.hasNext () не потрібно ніколи повертати помилкове. Таким чином, у загальному випадку ви не можете розраховувати, що зможете перетворити кожну Iterable в колекцію. Наприклад, ви можете перебирати будь-які позитивні натуральні числа, повторювати щось із циклами, що дають однакові результати знову і знову, і т.д.

Інакше: відповідь Атрі досить точна.

Я FluentIterable.from(myIterable).toList()багато використовую .

Це не відповідь на ваше запитання, але я вважаю, що це рішення вашої проблеми. В інтерфейсі org.springframework.data.repository.CrudRepositoryдійсно є методи, які повертаються, java.lang.Iterableале ви не повинні використовувати цей інтерфейс. Замість цього використовуйте допоміжні інтерфейси у вашому випадку org.springframework.data.mongodb.repository.MongoRepository. Цей інтерфейс має методи, що повертають об'єкти типу java.util.List.

Я використовую свою власну утиліту, щоб віддати наявну колекцію, якщо вона є.

Основні:

public static <T> Collection<T> toCollection(Iterable<T> iterable) {
    if (iterable instanceof Collection) {
        return (Collection<T>) iterable;
    } else {
        return Lists.newArrayList(iterable);
    }
}

В ідеалі вищезазначене використовувало б ImmutableList, але ImmutableCollection не дозволяє нульових значень, які можуть дати небажані результати.

Тести:

@Test
public void testToCollectionAlreadyCollection() {
    ArrayList<String> list = Lists.newArrayList(FIRST, MIDDLE, LAST);
    assertSame("no need to change, just cast", list, toCollection(list));
}

@Test
public void testIterableToCollection() {
    final ArrayList<String> expected = Lists.newArrayList(FIRST, null, MIDDLE, LAST);

    Collection<String> collection = toCollection(new Iterable<String>() {
        @Override
        public Iterator<String> iterator() {
            return expected.iterator();
        }
    });
    assertNotSame("a new list must have been created", expected, collection);
    assertTrue(expected + " != " + collection, CollectionUtils.isEqualCollection(expected, collection));
}

Я реалізую подібні утиліти для всіх підтипів колекцій (Set, List тощо). Я думаю, що вони вже будуть частиною Гуави, але я цього не знайшов.

Як тільки ви телефонуєте contains, containsAll, equals, hashCode, remove, retainAll, sizeабоtoArray , ви повинні пройти через елементи в будь-якому випадку.

Якщо ви час від часу викликаєте лише такі способи, як, isEmptyабо, clearя вважаю, вам буде краще, створивши колекцію ліниво. Наприклад, у вас може бути підкладкаArrayList для зберігання раніше повторених елементів.

Я не знаю жодного такого класу в будь-якій бібліотеці, але писати слід досить просто.

У Java 8 ви можете зробити це, щоб додати всі елементи з а Iterableдо Collectionі повернути його:

public static <T> Collection<T> iterableToCollection(Iterable<T> iterable) {
  Collection<T> collection = new ArrayList<>();
  iterable.forEach(collection::add);
  return collection;
}

Натхненний відповіддю @Afreys

Оскільки RxJava - молоток, і це виглядає як цвях, ви можете це зробити

Observable.from(iterable).toList().toBlocking().single();

Ось SSCCE для чудового способу зробити це в Java 8

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class IterableToCollection {
    public interface CollectionFactory <T, U extends Collection<T>> {
        U createCollection();
    }

    public static <T, U extends Collection<T>> U collect(Iterable<T> iterable, CollectionFactory<T, U> factory) {
        U collection = factory.createCollection();
        iterable.forEach(collection::add);
        return collection;
    }

    public static void main(String[] args) {
        Iterable<Integer> iterable = IntStream.range(0, 5).boxed().collect(Collectors.toList());
        ArrayList<Integer> arrayList = collect(iterable, ArrayList::new);
        HashSet<Integer> hashSet = collect(iterable, HashSet::new);
        LinkedList<Integer> linkedList = collect(iterable, LinkedList::new);
    }
}

Два зауваження

1. Немає необхідності перетворювати Iterable в Collection для використання циклу foreach - Iterable може використовуватися безпосередньо в такому циклі, немає синтаксичної різниці, тому я навряд чи розумію, чому взагалі задавали оригінальне питання.
2. Запропонований спосіб перетворення Iterable у Collection є небезпечним (те саме стосується CollectionUtils) - немає гарантії, що наступні виклики методу next () повертають різні екземпляри об'єкта. Більше того, ця проблема не є чисто теоретичною. Наприклад, ітерабельна реалізація, що використовується для передачі значень методу зменшення Hadoop Reducer, завжди повертає один і той же екземпляр значення, лише з різними значеннями поля. Тож якщо застосувати makeCollection зверху (або CollectionUtils.addAll (Iterator)), ви отримаєте колекцію з усіма однаковими елементами.

Я натрапив на подібну ситуацію, намагаючись отримати бонус в Listпро Projectе, а не за замовчуванням Iterable<T> findAll()оголошуються в CrudRepositoryінтерфейсі. Отже, у своєму ProjectRepositoryінтерфейсі (який поширюється на CrudRepository) я просто оголосив findAll()метод повернення List<Project>замість Iterable<Project>.

package com.example.projectmanagement.dao;

import com.example.projectmanagement.entities.Project;
import org.springframework.data.repository.CrudRepository;
import java.util.List;

public interface ProjectRepository extends CrudRepository<Project, Long> {

    @Override
    List<Project> findAll();
}

Думаю, це найпростіше рішення, не вимагаючи логіки перетворення або використання зовнішніх бібліотек.

Спробуйте StickyListвід кактусів :

List<String> list = new StickyList<>(iterable);

Я не бачив простого однолінійного рішення без будь-яких залежностей. Я просте використання

List<Users> list;
Iterable<IterableUsers> users = getUsers();

// one line solution
list = StreamSupport.stream(users.spliterator(), true).collect(Collectors.toList());

Ви можете використовувати фабрики Eclipse Collections :

Iterable<String> iterable = Arrays.asList("1", "2", "3");

MutableList<String> list = Lists.mutable.withAll(iterable);
MutableSet<String> set = Sets.mutable.withAll(iterable);
MutableSortedSet<String> sortedSet = SortedSets.mutable.withAll(iterable);
MutableBag<String> bag = Bags.mutable.withAll(iterable);
MutableSortedBag<String> sortedBag = SortedBags.mutable.withAll(iterable);

Ви також можете конвертувати в Iterablea LazyIterableі використовувати методи перетворювача або будь-який інший доступний API.

Iterable<String> iterable = Arrays.asList("1", "2", "3");
LazyIterable<String> lazy = LazyIterate.adapt(iterable);

MutableList<String> list = lazy.toList();
MutableSet<String> set = lazy.toSet();
MutableSortedSet<String> sortedSet = lazy.toSortedSet();
MutableBag<String> bag = lazy.toBag();
MutableSortedBag<String> sortedBag = lazy.toSortedBag();

Всі перераховані вище Mutableтипи поширюються java.util.Collection.

Примітка. Я є членом колекції Eclipse.