쉽게 컬렉션으로 변환할 수 있는 방법

쉽게 컬렉션으로 변환할 수 있는 방법

어플리케이션에서는 서드파티 라이브러리(정확히는 스프링 데이터)를 사용하고 있습니다.

는 반환됩니다.Iterable<T> 부분에는 '''가 기대되지만Collection<T>.

다른 방법으로 빠르게 변환할 수 있는 유틸리티 방법이 있나요? 것은 .foreach내 코드에 그런 간단한 루프가 있어

Guava에서는 Lists.newArrayList(Itable) 또는 Sets.newHashSet(Itable) 등의 유사한 메서드를 사용할 수 있습니다.이것에 의해, 물론, 모든 요소가 메모리에 카피됩니다.만약 그게 받아들여지지 않는다면, 이 코드들과 함께 작동되는 당신의 코드는IterableCollection에서 할 수 있는 CollectionIterable:Iterables.isEmpty(Iterable) ★★★★★★★★★★★★★★★★★」Iterables.contains(Iterable, Object)퍼포먼스에 미치는 영향은 더 명확합니다.

JDK 8+에서는 추가 lib를 사용하지 않고 다음을 수행합니다.

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

은 " " " 입니다.Iterator를 . . .를 with with 를 취급하고 경우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을 사용한 간결한 솔루션:

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

IteratorUtils 에서commons-collections될 수 3.2에서는 제네릭스를

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

4.0은하므로 4.0(현시점에서는을 삭제할 수 .@SuppressWarnings.

업데이트: 선인장에서 확인.

Collection 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스프링 데이터에는 몇 가지 다른 대안이 있습니다.

1. 수 .Iterable「」를에서, 「」를 참조해 주세요.List,Set또는 이 방법으로 Spring Data를 변환할 수 있습니다.

2. 모든 리포지토리 인터페이스에서 재정의를 반복할 필요가 없도록 리포지토리의 슈퍼 인터페이스에서 이를 수행할 수 있습니다.

3. Data JPA를 는 Spring Data JPA에서 .JpaRepository

4. 은 조금 에 말씀드린 '변환'을 .Streamable다음 중 하나:

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

화났다고 , 것 같은데, 화났다고 하다, 화났다고 한다, 화났다고 .Iterable도움이 됩니다.

1. 제로 a a a a a a a a a a a a a a a a를 필요로 하는 경우는 매우 드물 것으로 됩니다.Collection은은경경경경차차차차없겁
2. 할 수 .Collection하게 됩니다.Streamable모든 요소를 가져오기 전에 저장소에서 결과를 반환할 수 있는 경우를 대상으로 합니다.
3. Streamable 、 would would type type,,,,,,,,,,,,,,,,,,ionsionsions로 쉽게 할 수 에 실제로는 이 됩니다.왜냐하면 쉽게 변환할 수 있기 때문입니다.List,Set,Stream그 자체가Iterable 이 많은 을 어플리케이션에서

참조 문서에는 이에 대한 섹션이 있습니다.

그 동안, 모든 컬렉션은 유한하지만, Itable은 어떤 약속도 없다는 것을 잊지 마세요.만약 어떤 것이 견딜 수 있다면, 당신은 반복기를 얻을 수 있고, 그것으로 끝이다.

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

다음과 같이 확장됩니다.

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

it.hasNext()는 false를 반환할 필요가 없습니다.따라서 일반적인 경우 모든 Itable을 Collection으로 변환할 수 없습니다.예를 들어, 모든 양의 자연수에 대해 반복하거나, 동일한 결과를 반복적으로 생성하는 주기가 있는 무언가에 대해 반복할 수 있습니다.

그렇지 않은 경우:Atrey의 대답은 꽤 괜찮다.

용 i i i i를 쓴다.FluentIterable.from(myIterable).toList()

비슷한 상황을 맞닥뜨렸습니다.ListProject 「」가 「」를 참조해 .Iterable<T> findAll()되어 있다CrudRepository인터페이스입니다.제 래래 my my my 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();
}

이것은 변환 로직이나 외부 라이브러리를 사용하지 않고 가장 간단한 해결책이라고 생각합니다.

이것은 당신의 질문에 대한 답은 아니지만, 저는 이것이 당신의 문제에 대한 해결책이라고 생각합니다. " " "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);
    }
}

이상적으로는 상기의 경우 UnmutableList를 사용하지만 UnmutableCollection에서는 바람직하지 않은 결과를 얻을 수 있는 늘을 허용하지 않습니다.

테스트:

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

의존 관계가 없는 단순한 한 줄짜리 솔루션은 보이지 않았습니다.간단한 사용

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

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

두 가지 발언

1. Foreach 루프를 사용하기 위해 Itable을 Collection으로 변환할 필요는 없습니다.이러한 루프는 직접 사용할 수 있으며 구문적인 차이는 없기 때문에 원래 질문이 왜 나왔는지 전혀 이해할 수 없습니다.
2. Itable을 Collection으로 변환하는 권장 방법은 안전하지 않습니다(Collection Utils와 동일). next() 메서드에 대한 후속 호출이 다른 개체 인스턴스를 반환한다는 보장은 없습니다.게다가, 이 우려는 순전히 이론적인 것이 아니다.예를 들어, Hadoop Reducer의 축소 방법에 값을 전달하는 데 사용되는 반복 가능한 구현은 항상 다른 필드 값을 사용하여 동일한 값 인스턴스를 반환합니다.따라서 위에서 makeCollection(또는 CollectionUtils.addAll(Iterator))을 적용하면 모든 요소가 동일한 컬렉션이 됩니다.

★★를 해 보세요.StickyList선인장:

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

파티에는 늦었지만, 라이브러리 없이 T의 반복 가능을 T의 컬렉션으로 변환할 수 있는 매우 우아한 Java 8 솔루션을 만들었습니다.

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

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 a까지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의 커밋입니다.

캐스팅을 시험해 보세요:(List<iterable_type>)iterable;

언급URL : https://stackoverflow.com/questions/6416706/easy-way-to-convert-iterable-to-collection