Tekrarlanabilir Öğeleri Koleksiyona Dönüştürmenin Kolay Yolu

Benim uygulamada 3. parti kitaplığı (MongoDB için Bahar Verileri kesin) kullanın.

Iterable<T>Kodumu geri kalanı beklerken, bu kitaplığın yöntemleri döner Collection<T>.

Bir yerde hızlı bir şekilde diğerine dönüştürmeme izin verecek herhangi bir yardımcı yöntem var mı? foreachBöyle basit bir şey için kodumda bir sürü döngü oluşturmaktan kaçınmak istiyorum .

İle Guava kullanabileceğiniz Lists.newArrayList (iterable) veya Sets.newHashSet (iterable) diğer benzer yöntemleri arasında. Bu elbette tüm öğeleri belleğe kopyalar. Bu kabul edilebilir değilse, bence bu ile çalışan kod Iterableyerine almak gerekir Collection. Guava, Collectionbir Iterable( Iterables.isEmpty(Iterable)veya gibi Iterables.contains(Iterable, Object)) kullanarak yapabileceğiniz şeyleri yapmak için uygun yöntemler sağlar , ancak performans sonuçları daha açıktır.

JDK 8+ sürümünde, ek kitap kullanmadan:

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

Edit: Yukarıdaki bir içindir Iterator. Eğer uğraşıyorsanız Iterable,

iterable.forEach(target::add);

Bunun için kendi yardımcı yönteminizi de yazabilirsiniz:

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

Kullanarak Java 8 ile özlü çözüm java.util.stream:

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

IteratorUtilsdan commons-collections(onlar son kararlı sürümü 3.2.1 de jeneriği desteklemez rağmen) mayıs yardım:

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

Sürüm 4.0 (şu anda SNAPSHOT'ta bulunan) jenerikleri desteklemektedir ve kurtulabilirsiniz @SuppressWarnings.

Güncelleme: Kontrol IterableAsListdan Cactoos .

Gönderen CollectionUtils :

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

İşte bu yardımcı programın tüm kaynakları:

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

O sırada, tüm koleksiyonların sonlu olduğunu unutmayın, Yinelenebilir'in hiçbir vaadi yoktur. Eğer bir şey yinelenebilir ise bir yineleyici alabilirsiniz ve hepsi bu.

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

genişletilecek:

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

it.hasNext () işlevinin hiçbir zaman false döndürmesi gerekmez. Böylece, genel durumda, her Yinelenebiliri bir Koleksiyona dönüştürmeyi bekleyemezsiniz. Örneğin, tüm pozitif doğal sayılar üzerinde tekrarlayabilir, içinde aynı sonuçları tekrar tekrar üreten döngüler içeren bir şey üzerinde tekrarlayabilirsiniz.

Aksi takdirde: Atrey'in cevabı gayet iyi.

Çok kullanıyorum FluentIterable.from(myIterable).toList().

Bu, sorunuzun bir cevabı değil, ama bunun sorununun çözümü olduğuna inanıyorum. Arayüz org.springframework.data.repository.CrudRepositorygerçekten dönen yöntemlere sahiptir, java.lang.Iterableancak bu arayüzü kullanmamalısınız. Bunun yerine sizin durumunuzda alt arayüzler kullanın org.springframework.data.mongodb.repository.MongoRepository. Bu arabirim, türdeki nesneleri döndüren yöntemlere sahiptir java.util.List.

Varsa, mevcut bir Koleksiyonu yayınlamak için özel yardımcı programımı kullanıyorum.

Ana:

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

İdeal olarak yukarıda belirtilenler ImmutableList kullanır, ancak ImmutableCollection istenmeyen sonuçlar verebilecek boş değerlere izin vermez.

Testler:

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

Koleksiyonların tüm alt türleri (Set, List, vb.) İçin benzer yardımcı programlar uygularım. Bunların zaten Guava'nın bir parçası olacağını düşünürdüm, ama bulamadım.

En kısa zamanda dediğimiz gibi contains, containsAll, equals, hashCode, remove, retainAll, sizeveya toArray, yine unsurları çapraz gerekirdi.

Zaman zaman yalnızca böyle yöntemleri çağırıyorsanız isEmptyveya cleartembel bir şekilde koleksiyon oluşturarak daha iyi olacağını düşünürseniz. Örneğin, ArrayListdaha önce yinelenen öğeleri depolamak için bir desteğiniz olabilir .

Herhangi bir kütüphanede böyle bir sınıf bilmiyorum, ama yazmak oldukça basit bir alıştırma olmalı.

Java 8'de bir gelen tüm unsurları eklemek için bunu yapabilirsiniz Iterableiçin Collectionve iade:

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

@Afreys yanıtından esinlenmiştir.

RxJava bir çekiç olduğundan ve bu bir çivi gibi göründüğünden,

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

Java 8'de bunu yapmanın harika bir yolu için bir 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);
    }
}

İki açıklama

1. Her döngü için kullanmak için Yinelenebilir Koleksiyonu Koleksiyona dönüştürmeye gerek yoktur - Yinelenebilir doğrudan bu döngüde kullanılabilir, sözdizimsel bir fark yoktur, bu yüzden orijinal sorunun neden sorulduğunu anlayamıyorum.
2. Yinelenebilir öğeyi Koleksiyona dönüştürmenin önerilen yolu güvensizdir (aynısı CollectionUtils ile ilgilidir) - next () yöntemine yapılan sonraki çağrıların farklı nesne örnekleri döndürdüğünün garantisi yoktur. Dahası, bu endişe saf teorik değildir. Örneğin, değerleri bir Hadoop Redüktör azaltma yöntemine aktarmak için kullanılan yinelenebilir uygulama, yalnızca farklı alan değerleriyle her zaman aynı değer örneğini döndürür. Bu nedenle, makeCollection uygulamasını yukarıdan (veya CollectionUtils.addAll (Yineleyici)) uygularsanız, tüm özdeş öğeleri içeren bir koleksiyon elde edersiniz.

Arayüzde bildirilen varsayılandan ziyade List, Projects'yi almaya çalışırken benzer bir durumla karşılaştım . Yani, arayüzümden (ki bu da uzanıyor ), sadece yerine dönmek için yöntemi beyan ettim .Iterable<T> findAll()CrudRepositoryProjectRepositoryCrudRepositoryfindAll()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();
}

Bence, en basit çözüm, dönüştürme mantığı veya harici kütüphanelerin kullanımına gerek kalmadan.

Deneyin StickyListgelen Cactoos :

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

Herhangi bir bağımlılığı olmayan basit bir tek çözüm görmedim . Basit kullanım

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

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

Eclipse Collections fabrikalarını kullanabilirsiniz :

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

Ayrıca dönüştürebilirsiniz Iterablebir etmek LazyIterableve dönüştürücü yöntemlerini veya mevcut diğer kullanılabilir API'leri herhangi birini kullanabilirsiniz.

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

Yukarıdaki Mutabletiplerin tümü uzanırjava.util.Collection .

Not: Eclipse Collections için bir komisyoncuyum.