Cách dễ dàng để chuyển đổi Iterable thành Collection

Trong ứng dụng của mình, tôi sử dụng thư viện của bên thứ 3 (Chính xác là Spring Data cho MongoDB).

Các phương thức của thư viện này trả về Iterable<T>, trong khi phần còn lại của mã của tôi mong đợi Collection<T>.

Có phương pháp tiện ích nào ở đâu đó sẽ cho phép tôi nhanh chóng chuyển đổi cái này sang cái khác không? Tôi muốn tránh tạo ra một loạt các foreachvòng lặp trong mã của tôi cho một điều đơn giản như vậy.

Với Guava, bạn có thể sử dụng Lists.newArrayList (Iterable) hoặc Sets.newHashset (Iterable) , trong số các phương thức tương tự khác. Điều này tất nhiên sẽ sao chép tất cả các yếu tố vào bộ nhớ. Nếu điều đó không được chấp nhận, tôi nghĩ rằng mã của bạn hoạt động với những điều này nên lấy Iterablehơn là Collection. Quả ổi cũng tình cờ cung cấp các phương pháp thuận tiện để thực hiện những việc bạn có thể làm khi Collectionsử dụng Iterable(chẳng hạn như Iterables.isEmpty(Iterable)hoặc Iterables.contains(Iterable, Object)), nhưng ý nghĩa về hiệu suất thì rõ ràng hơn.

Trong JDK 8+, không sử dụng bất kỳ libs bổ sung nào:

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

Chỉnh sửa: Một ở trên là cho Iterator. Nếu bạn đang làm việc với Iterable,

iterable.forEach(target::add);

Bạn cũng có thể viết phương thức tiện ích của riêng bạn cho việc này:

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

Giải pháp ngắn gọn với Java 8 bằng cách sử dụng java.util.stream:

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

IteratorUtilstừ commons-collectionscó thể giúp đỡ (mặc dù họ không hỗ trợ thuốc generic trong phiên bản ổn định mới nhất 3.2.1):

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

Phiên bản 4.0 (trong SNAPSHOT tại thời điểm này) hỗ trợ thuốc generic và bạn có thể thoát khỏi @SuppressWarnings.

Cập nhật: Kiểm tra IterableAsListtừ Cactoos .

Từ CollectionUtils :

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

Dưới đây là các nguồn đầy đủ của phương pháp tiện ích này:

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

Trong khi ở đó, đừng quên rằng tất cả các bộ sưu tập là hữu hạn, trong khi Iterable không có bất kỳ lời hứa nào. Nếu một cái gì đó là Iterable, bạn có thể lấy Iterator và đó là nó.

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

sẽ được mở rộng thành:

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

it.hasNext () không bắt buộc phải trả về false. Do đó, trong trường hợp chung, bạn không thể mong đợi có thể chuyển đổi mọi Iterable thành Collection. Ví dụ: bạn có thể lặp lại tất cả các số tự nhiên dương, lặp đi lặp lại trên một cái gì đó có chu kỳ trong đó tạo ra kết quả tương tự lặp đi lặp lại, v.v.

Mặt khác: câu trả lời của Atrey khá ổn.

Tôi sử dụng FluentIterable.from(myIterable).toList()rất nhiều.

Đây không phải là một câu trả lời cho câu hỏi của bạn nhưng tôi tin rằng nó là giải pháp cho vấn đề của bạn. Giao diện org.springframework.data.repository.CrudRepositorythực sự có các phương thức trả về java.lang.Iterablenhưng bạn không nên sử dụng giao diện này. Thay vào đó sử dụng giao diện phụ, trong trường hợp của bạn org.springframework.data.mongodb.repository.MongoRepository. Giao diện này có các phương thức trả về các đối tượng thuộc loại java.util.List.

Tôi sử dụng tiện ích tùy chỉnh của mình để bỏ Bộ sưu tập hiện có nếu có.

Chủ yếu:

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

Lý tưởng nhất là ở trên sẽ sử dụng ImmutableList, nhưng ImmutableCollection không cho phép null có thể cung cấp kết quả không mong muốn.

Các xét nghiệm:

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

Tôi triển khai các tiện ích tương tự cho tất cả các kiểu con của Bộ sưu tập (Bộ, Danh sách, v.v.). Tôi nghĩ những thứ này đã là một phần của ổi, nhưng tôi không tìm thấy nó.

Ngay sau khi bạn gọi contains, containsAll, equals, hashCode, remove, retainAll, sizehay toArray, bạn sẽ phải đi qua các yếu tố nào.

Nếu bạn thỉnh thoảng chỉ gọi các phương thức như isEmptyhoặc cleartôi cho rằng bạn sẽ tốt hơn bằng cách tạo ra bộ sưu tập một cách lười biếng. Ví dụ, bạn có thể có một bản sao lưu ArrayListđể lưu trữ các phần tử được lặp trước đó.

Tôi không biết về bất kỳ lớp nào như vậy trong bất kỳ thư viện nào, nhưng nó nên là một bài tập khá đơn giản để viết lên.

Trong Java 8, bạn có thể làm điều này để thêm tất cả các phần tử từ một Iterableđến Collectionvà trả lại nó:

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

Lấy cảm hứng từ câu trả lời @Afreys.

Vì RxJava là một cái búa và loại này trông giống như một cái đinh, bạn có thể làm

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

Đây là một SSCCE cho một cách tuyệt vời để làm điều này trong 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);
    }
}

Hai nhận xét

1. Không cần phải chuyển đổi Iterable thành Collection để sử dụng vòng lặp foreach - Iterable có thể được sử dụng trực tiếp trong vòng lặp đó, không có sự khác biệt về cú pháp, vì vậy tôi hầu như không hiểu tại sao câu hỏi ban đầu được hỏi.
2. Cách được đề xuất để chuyển đổi Iterable thành Collection là không an toàn (tương tự liên quan đến CollectionUtils) - không có gì đảm bảo rằng các cuộc gọi tiếp theo đến phương thức next () trả về các thể hiện đối tượng khác nhau. Hơn nữa, mối quan tâm này không phải là lý thuyết thuần túy. Ví dụ: Việc thực hiện lặp lại được sử dụng để truyền các giá trị cho phương thức rút gọn của Hadoop Reducer luôn trả về cùng một thể hiện giá trị, chỉ với các giá trị trường khác nhau. Vì vậy, nếu bạn áp dụng makeCollection từ phía trên (hoặc CollectionUtils.add ALL (Iterator)), bạn sẽ kết thúc với một bộ sưu tập với tất cả các yếu tố giống hệt nhau.

Thử StickyListtừ Cactoos :

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

Tôi đã không thấy một giải pháp một dòng đơn giản mà không có bất kỳ sự phụ thuộc nào. Tôi sử dụng đơn giản

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

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

Tôi đã xem qua một tình huống tương tự khi cố gắng lấy một Listcủa Projects, chứ không phải là mặc định Iterable<T> findAll()khai báo trong CrudRepositorygiao diện. Vì vậy, trong ProjectRepositorygiao diện của tôi (kéo dài từ CrudRepository), tôi chỉ đơn giản khai báo findAll()phương thức để trả về một List<Project>thay vì 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();
}

Đây là giải pháp đơn giản nhất, tôi nghĩ, không yêu cầu logic chuyển đổi hoặc sử dụng các thư viện bên ngoài.

Bạn có thể sử dụng các nhà máy Bộ sưu tập Eclipse :

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

Bạn cũng có thể chuyển đổi Iterablesang a LazyIterablevà sử dụng các phương thức chuyển đổi hoặc bất kỳ API nào có sẵn khác.

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

Tất cả các Mutableloại trên mở rộng java.util.Collection.

Lưu ý: Tôi là người đi làm cho Bộ sưu tập Eclipse.