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

В моем приложении я использую стороннюю библиотеку (точнее Spring Data для MongoDB).

Методы этой библиотеки возвращаются Iterable<T>, а остальная часть моего кода ожидает Collection<T>.

Есть ли где-нибудь полезный метод, который позволит мне быстро конвертировать один в другой? Я бы хотел избежать создания цикла foreachв моем коде для такой простой вещи.

С Guava вы можете использовать Lists.newArrayList (Iterable) или Sets.newHashSet (Iterable) , среди других подобных методов. Это, конечно, скопирует все элементы в память. Если это не приемлемо, я думаю, что ваш код, который работает с ними, должен взять, Iterableа не Collection. Гуава также предоставляет удобные методы для действий, которые вы можете делать на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());
}

IteratorUtilsfrom commons-collectionsможет помочь (хотя они не поддерживают дженерики в последней стабильной версии 3.2.1):

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

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

Обновление: проверка IterableAsListот Cactoos .

Из CollectionUtils :

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 () не требуется, чтобы когда-либо возвращать false. Таким образом, в общем случае вы не можете рассчитывать на то, что сможете конвертировать каждый 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);
    }
}

Я столкнулся с подобной ситуацией при попытке получить a Listиз Projects, а не по умолчанию, 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();
}

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

Два замечания

1. Нет необходимости конвертировать Iterable в Collection для использования цикла foreach - Iterable может использоваться непосредственно в таком цикле, нет синтаксической разницы, поэтому я с трудом понимаю, почему был задан исходный вопрос вообще.
2. Предложенный способ преобразования Iterable в Collection небезопасен (то же самое относится и к CollectionUtils) - нет гарантии, что последующие вызовы метода next () вернут разные экземпляры объекта. Более того, это беспокойство не чисто теоретическое. Например, итеративная реализация, используемая для передачи значений в метод Reduce Hadoop Reducer, всегда возвращает один и тот же экземпляр значения, только с разными значениями поля. Поэтому, если вы примените makeCollection сверху (или CollectionUtils.addAll (Iterator)), вы получите коллекцию со всеми идентичными элементами.

Попробуйте StickyListот Cactoos :

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 Collections.