วิธีง่ายๆในการแปลง Iterable เป็น Collection

ในแอปพลิเคชันของฉันฉันใช้ห้องสมุดบุคคลที่สาม (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+ โดยไม่ใช้ libs เพิ่มเติม:

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

IteratorUtilsจากcommons-collectionsอาจช่วย (แม้ว่าพวกเขาไม่สนับสนุน generics ในรุ่นเสถียรล่าสุด 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 () ไม่จำเป็นต้องส่งคืนค่าเท็จ ดังนั้นในกรณีทั่วไปคุณไม่สามารถคาดหวังได้ว่าจะสามารถแปลง Iterable ทุกชุดเป็นคอลเล็กชันได้ ตัวอย่างเช่นคุณสามารถวนซ้ำจำนวนธรรมชาติทั้งหมดบวกซ้ำสิ่งที่มีรอบในนั้นที่ให้ผลลัพธ์เดียวกันซ้ำแล้วซ้ำอีก ฯลฯ

มิฉะนั้น: คำตอบของ 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));
}

ฉันใช้ยูทิลิตีที่คล้ายกันสำหรับประเภทย่อยทั้งหมดของคอลเลกชัน (ชุดรายการ ฯลฯ ) ฉันคิดว่าสิ่งเหล่านี้จะเป็นส่วนหนึ่งของ 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 loop - Iterable อาจใช้ใน loop ดังกล่าวโดยตรงไม่มีความแตกต่างทางไวยากรณ์ดังนั้นฉันจึงไม่เข้าใจว่าทำไมคำถามเดิมจึงถูกถามเลย
2. วิธีที่แนะนำในการแปลง Iterable เป็น Collection ไม่ปลอดภัย (เช่นเดียวกับ CollectionUtils) - ไม่มีการรับประกันว่าการเรียกที่ตามมาไปยังเมธอดถัดไป () จะส่งคืนอินสแตนซ์ของวัตถุที่แตกต่างกัน นอกจากนี้ความกังวลนี้ไม่ได้เป็นทฤษฎีบริสุทธิ์ เช่นการนำ Iterable ไปใช้เพื่อส่งผ่านค่าไปยังวิธีลดขนาดของ Hadoop Reducer จะส่งกลับค่าอินสแตนซ์ค่าเดียวกันเสมอโดยมีค่าของฟิลด์ต่างกัน ดังนั้นถ้าคุณใช้ makeCollection จากด้านบน (หรือ CollectionUtils.addAll (Iterator)) คุณจะได้คอลเลคชั่นที่มีองค์ประกอบที่เหมือนกันทั้งหมด

ฉันเจอสถานการณ์ที่คล้ายกันในขณะที่พยายามดึง a 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();
}

ฉันคิดว่านี่เป็นวิธีที่ง่ายที่สุดโดยไม่ต้องใช้ตรรกะการแปลงหรือการใช้ไลบรารีภายนอก

ลอง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();

ทั้งหมดข้างต้นประเภทขยายMutablejava.util.Collection

หมายเหตุ: ฉันเป็นคอมมิชชันสำหรับ Eclipse Collections