Простой способ преобразовать Iterable в Collection

С Guava вы можете использовать Lists.newArrayList (Iterable) или Наборы .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());
}

_1 _ от 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 нет никаких обещаний. Если что-то Iterable, вы можете получить Iterator, и все.

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

будет расширен до:

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

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

В противном случае: ответ Атри вполне хорош.

Я использую FluentIterable.from(myIterable).toList() много.

Я столкнулся с аналогичной ситуацией при попытке получить 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();
}

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

Когда вы получаете свой Iterable из Spring Data, у вас есть пара дополнительных альтернатив.

1. Вы можете переопределить метод, который возвращает Iterable в репозитории с версией, которая возвращает List, Set или _ 5_. Таким образом, Spring Data выполняет преобразование за вас.

2. Вы можете сделать это в супер-интерфейсе ваших репозиториев, чтобы вам не приходилось повторять переопределение во всех ваших интерфейсах репозитория.

3. Если вы используете Spring Data JPA, это уже сделано за вас в JpaRepository

4. Вы можете выполнить преобразование, используя только что упомянутый Streamable:

   Iterable<X> iterable = repo.findAll();
   List<X> list = Streamable.of(iterable).toList();
   

И, поскольку вы упомянули, что расстроены, возможно, это немного предыстории для решения использовать Iterable помощь.

1. Ожидается, что на самом деле очень редко требуется Collection, поэтому во многих случаях это не имеет значения.
2. Используя механизм переопределения, можно возвращать разные типы, что было бы невозможно с более конкретным типом возврата, таким как Collection. Это сделало бы невозможным возврат Streamable, который предназначен для случаев, когда магазин может решить вернуть результат до того, как будут извлечены все элементы.
3. Streamable на самом деле был бы гибким типом возврата, поскольку он предлагает простые преобразования в List, Set, Stream и сам по себе является Iterable. Но для этого вам потребуется использовать в своем приложении конкретный тип Spring Data, что не нравится многим пользователям.

Об этом есть раздел в справочная документация.

Это не ответ на ваш вопрос, но я считаю, что это решение вашей проблемы. Интерфейс 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 не допускает значений NULL, которые могут привести к нежелательным результатам.

Тесты:

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

Реализую аналогичные утилиты для всех подтипов Коллекций (Набор, Список и т. Д.). Я бы подумал, что это уже будет частью Guava, но я не нашел его.

Как только вы вызываете 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<Users> list;
Iterable<IterableUsers> users = getUsers();

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

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

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

Вы можете использовать фабрики 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);

Вы также можете преобразовать Iterable в 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.

Довольно поздно для вечеринки, но я создал очень элегантное решение для Java 8, которое позволяет преобразовывать Iterable of T в любую коллекцию T без каких-либо библиотек:

public static <T, C extends Collection<T>> C toCollection(Iterable<T> iterable, Supplier<C> baseSupplier) 
{
    C collection = baseSupplier.get();
    
    iterable.forEach(collection::add);
    
    return collection;
}

Пример использования:

Iterable<String> iterable = ...;
List<String> list = toCollection(iterable, ArrayList::new);