Iterable을 Collection으로 변환하는 쉬운 방법

내 응용 프로그램에서 타사 라이브러리 (MongoDB의 스프링 데이터가 정확함)를 사용합니다.

이 라이브러리의 메소드는 반환 Iterable<T>하지만 나머지 코드는 예상 Collection<T>합니다.

어딘가에 빠르게 변환 할 수있는 유틸리티 방법이 있습니까? foreach그런 간단한 일을 위해 코드에 많은 루프를 만드는 것을 피하고 싶습니다 .

함께 구아바 당신이 사용할 수있는 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-collectionsmay help (최신 안정 버전 3.2.1에서는 제네릭을 지원하지 않지만) :

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

버전 4.0 (현재 SNAPSHOT에 있음)은 제네릭을 지원하며 @SuppressWarnings .

업데이트 : CactoosIterableAsList 에서 확인하십시오 .

에서 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으로 변환 할 수는 없습니다. 예를 들어, 모든 양수의 자연수를 반복하고,주기가 같은 것을 반복하여 동일한 결과를 반복해서 반복 할 수 있습니다.

그렇지 않으면 : Atrey의 대답은 꽤 좋습니다.

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

컬렉션의 모든 하위 유형 (Set, List 등)에 대해 유사한 유틸리티를 구현합니다. 나는 이것이 이미 구아바의 일부라고 생각하지만 찾지 못했습니다.

즉시 전화로 contains, containsAll, equals, hashCode, remove, retainAll, size또는toArray , 당신은 어쨌든 요소를 통과해야 할 것이다.

가끔과 같은 메소드를 호출 isEmpty하거나 clear컬렉션을 느리게 만드는 것이 더 낫다고 생각합니다. 예를 들어 백업을 할 수 있습니다ArrayList 이전에 반복 된 요소를 저장하기 있습니다.

나는 어떤 도서관에서 그런 클래스를 알지 못하지만 작성하는 것은 매우 간단한 연습이어야합니다.

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

Java 8 에서이 작업을 수행하는 좋은 방법에 대한 SSCCE가 있습니다.

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. foreach 루프를 사용하기 위해 Iterable을 Collection으로 변환 할 필요가 없습니다 .Iterable은 그러한 루프에서 직접 사용될 수 있으므로 구문상의 차이가 없으므로 원래 질문이 왜 요청되었는지 전혀 이해하지 못합니다.
2. Iterable을 Collection으로 변환하는 권장 방법은 안전하지 않습니다 (CollectionUtils와 동일). next () 메서드에 대한 후속 호출이 다른 객체 인스턴스를 반환한다고 보장 할 수 없습니다. 게다가이 문제는 이론적으로 순수한 것은 아닙니다. 예를 들어 Hadoop Reducer의 reduce 메소드에 값을 전달하는 데 사용되는 반복 가능한 구현은 다른 필드 값과 함께 항상 동일한 값 인스턴스를 리턴합니다. 따라서 위에서 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();
}

이것은 변환 논리 또는 외부 라이브러리 사용이 필요없는 가장 간단한 해결책이라고 생각합니다.

CactoosStickyList 에서 시도하십시오 :

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의 커미터입니다.