Java 8'de java.util.stream.Stream öğesinden bir Liste alma

Koleksiyonları kolayca filtrelemek için Java 8 lambdas ile oynuyordum. Ancak sonucu aynı ifadede yeni bir liste olarak almanın kısa bir yolunu bulamadım. İşte şimdiye kadarki en özlü yaklaşımım:

List<Long> sourceLongList = Arrays.asList(1L, 10L, 50L, 80L, 100L, 120L, 133L, 333L);
List<Long> targetLongList = new ArrayList<>();
sourceLongList.stream().filter(l -> l > 100).forEach(targetLongList::add);

İnternetteki örnekler soruma cevap vermedi çünkü yeni bir sonuç listesi oluşturmadan duruyorlar. Daha özlü bir yol olmalı. Bunu, umuyordum Streamsınıf olarak yöntemleri vardır toList(), toSet()...

Değişkenlerin targetLongListdoğrudan üçüncü satır tarafından atanabilmesinin bir yolu var mı ?

Yaptığınız şey, akışınızın sıralı kalması şartıyla en basit yol olabilir; aksi takdirde daha önce sequential () öğesine bir çağrı yapmanız gerekir forEach.

[daha sonraki düzenleme: ardışık () çağrısının gerekli olmasının nedeni forEach(targetLongList::add), akış paralel olsaydı, durduğu kodun ( ) açık olması. O zaman bile, açıkça belirleyici olmadığı gibi amaçlanan etkiyi elde etmeyecektir forEach- sıralı bir akışta bile eleman işleme sırası garanti edilmez. forEachOrderedDoğru siparişi sağlamak için kullanmanız gerekir. Stream API tasarımcılarının amacı bu durumda toplayıcıyı aşağıdaki gibi kullanmanızdır.]

Bir alternatif

targetLongList = sourceLongList.stream()
    .filter(l -> l > 100)
    .collect(Collectors.toList());

Güncellenmiş:

Başka bir yaklaşım kullanmak Collectors.toList:

targetLongList = 
    sourceLongList.stream().
    filter(l -> l > 100).
    collect(Collectors.toList());

Önceki Çözüm:

Başka bir yaklaşım kullanmak Collectors.toCollection:

targetLongList = 
    sourceLongList.stream().
    filter(l -> l > 100).
    collect(Collectors.toCollection(ArrayList::new));

İstediğim bu ArrayListolduğunda bir toplayıcı döndüren bir util yöntemi kullanmayı seviyorum .

Bence çözüm Collectors.toCollection(ArrayList::new)böyle yaygın bir işlem için biraz fazla gürültülü.

Misal:

ArrayList<Long> result = sourceLongList.stream()
    .filter(l -> l > 100)
    .collect(toArrayList());

public static <T> Collector<T, ?, ArrayList<T>> toArrayList() {
    return Collectors.toCollection(ArrayList::new);
}

Bu cevapla birlikte, genellikle çok yararlı olan özel koleksiyonerler oluşturmanın ve kullanmanın ne kadar basit olduğunu göstermek istiyorum.

Bir dizi temel öğe varsa, Eclipse Koleksiyonlarında bulunan ilkel koleksiyonları kullanabilirsiniz .

LongList sourceLongList = LongLists.mutable.of(1L, 10L, 50L, 80L, 100L, 120L, 133L, 333L);
LongList targetLongList = sourceLongList.select(l -> l > 100);

SourceLongList öğesini değiştiremiyorsanız List:

List<Long> sourceLongList = Arrays.asList(1L, 10L, 50L, 80L, 100L, 120L, 133L, 333L);
List<Long> targetLongList = 
    ListAdapter.adapt(sourceLongList).select(l -> l > 100, new ArrayList<>());

Kullanmak istiyorsanız LongStream:

long[] sourceLongs = new long[]{1L, 10L, 50L, 80L, 100L, 120L, 133L, 333L};
LongList targetList = 
    LongStream.of(sourceLongs)
    .filter(l -> l > 100)
    .collect(LongArrayList::new, LongArrayList::add, LongArrayList::addAll);

Not: Eclipse Koleksiyonlarına katkıda bulunuyorum.

Biraz daha etkili bir yol (kaynak listesini oluşturmaktan ve filtrenin otomatik olarak açılmasını önlemek):

List<Long> targetLongList = LongStream.of(1L, 10L, 50L, 80L, 100L, 120L, 133L, 333L)
    .filter(l -> l > 100)
    .boxed()
    .collect(Collectors.toList());

collect(Collectors.toList());

Bu, herhangi bir Akışı Listeye dönüştürmek için kullanabileceğiniz çağrıdır.

daha somut olarak:

    List<String> myList = stream.collect(Collectors.toList()); 

dan:

https://www.geeksforgeeks.org/collectors-tolist-method-in-java-with-examples/

Üçüncü taraf kitaplıklarını kullanmanın bir sakıncası yoksa, AOL'nin cyclops-tepki tepkisi (açıklama ben katkıda bulunuyorum) Liste de dahil olmak üzere tüm JDK Koleksiyonu türleri için uzantılara sahiptir . ListX arabirimi java.util.List öğesini genişletir ve filtre de dahil olmak üzere çok sayıda yararlı işleç ekler.

Yazabilirsiniz.

ListX<Long> sourceLongList = ListX.of(1L, 10L, 50L, 80L, 100L, 120L, 133L, 333L);
ListX<Long> targetLongList = sourceLongList.filter(l -> l > 100);

ListX ayrıca mevcut bir Listeden de oluşturulabilir (ListX.fromIterable aracılığıyla)

LongStream sınıfı ve benzer şekilde IntStream ve DoubleStream sınıfları tarafından sağlanan başka bir toplama yöntemi varyantı vardır.

<R> R collect(Supplier<R> supplier,
              ObjLongConsumer<R> accumulator,
              BiConsumer<R,R> combiner)

Bu akışın elemanları üzerinde değiştirilebilir bir azaltma işlemi gerçekleştirir. Değişken bir indirgeme, indirgenmiş değerin bir ArrayList gibi değişebilir bir sonuç kabı olduğu ve öğelerin, sonucu değiştirmek yerine sonucun durumunu güncelleyerek dahil edildiği bir indirgeme değeridir. Bu, aşağıdakine eşdeğer bir sonuç üretir:

R result = supplier.get();
  for (long element : this stream)
       accumulator.accept(result, element);
  return result;

Azaltma (uzun, LongBinaryOperator) gibi, toplama işlemleri ek senkronizasyon gerektirmeden paralelleştirilebilir. Bu bir terminal işlemidir.

Ve bu toplama yöntemi ile sorunuza cevap aşağıdaki gibidir:

    LongStream.of(1L, 2L, 3L, 3L).filter(i -> i > 2)
    .collect(ArrayList::new, (list, value) -> list.add(value)
    , (list1, list2) -> list1.addAll(list2));

Aşağıda oldukça akıllı ama anlaşılması zor olan yöntem referans varyantı:

     LongStream.of(1L, 2L, 3L, 3L).filter(i -> i > 2)
    .collect(ArrayList::new, List::add , List::addAll);

HashSet varyantı aşağıdadır:

     LongStream.of(1L, 2L, 3L, 3).filter(i -> i > 2)
     .collect(HashSet::new, HashSet::add, HashSet::addAll);

Benzer şekilde LinkedList varyantı şöyle:

     LongStream.of(1L, 2L, 3L, 3L)
     .filter(i -> i > 2)
     .collect(LinkedList::new, LinkedList::add, LinkedList::addAll);

Birinin (benim gibi) ilkel tipler yerine Nesnelerle başa çıkma yolları araması durumunda, mapToObj()

String ss = "An alternative way is to insert the following VM option before "
        + "the -vmargs option in the Eclipse shortcut properties(edit the "
        + "field Target inside the Shortcut tab):";

List<Character> ll = ss
                        .chars()
                        .mapToObj(c -> new Character((char) c))
                        .collect(Collectors.toList());

System.out.println("List type: " + ll.getClass());
System.out.println("Elem type: " + ll.get(0).getClass());
ll.stream().limit(50).forEach(System.out::print);

baskılar:

List type: class java.util.ArrayList
Elem type: class java.lang.Character
An alternative way is to insert the following VM o

String joined = 
                Stream.of(isRead?"read":"", isFlagged?"flagged":"", isActionRequired?"action":"", isHide?"hide":"")
                      .filter(s -> s != null && !s.isEmpty())
                      .collect(Collectors.joining(","));

İşte AbacusUtil kodu

LongStream.of(1, 10, 50, 80, 100, 120, 133, 333).filter(e -> e > 100).toList();

Açıklama ： AbacusUtil'in geliştiricisiyim.

Kodu aşağıdaki gibi yeniden yazabilirsiniz:

List<Long> sourceLongList = Arrays.asList(1L, 10L, 50L, 80L, 100L, 120L, 133L, 333L);
List<Long> targetLongList = sourceLongList.stream().filter(l -> l > 100).collect(Collectors.toList());

Değişken bir listede toplamak için:

targetList = sourceList.stream()
                       .filter(i -> i > 100) //apply filter
                       .collect(Collectors.toList());

Değişmez bir listede toplamak için:

targetList = sourceList.stream()
                       .filter(i -> i > 100) //apply filter
                       .collect(Collectors.toUnmodifiableList());

Açıklanması collectdan JavaDoc'u :

Bir Toplayıcı kullanarak bu akışın elemanları üzerinde değiştirilebilir bir azaltma işlemi gerçekleştirir. Bir Toplayıcı, toplama stratejilerinin yeniden kullanılmasına ve çok düzeyli gruplama veya bölümleme gibi toplama işlemlerinin kompozisyonuna izin vererek, toplama argümanları olarak kullanılan işlevleri (Tedarikçi, BiConsumer, BiConsumer) içerir. Akış paralelse ve Toplayıcı eşzamanlıysa ve akış sıralanmamışsa veya toplayıcı sıralanmamışsa, eşzamanlı bir azalma gerçekleştirilir (eşzamanlı azaltmayla ilgili ayrıntılar için Toplayıcı'ya bakın).

Bu bir terminal işlemidir.

Paralel olarak yürütüldüğünde, değiştirilebilir ara yapıların izolasyonunu sürdürmek için çoklu ara sonuçlar başlatılabilir, doldurulabilir ve birleştirilebilir. Bu nedenle, iş parçacığı için güvenli olmayan veri yapılarına (ArrayList gibi) paralel olarak yürütüldüğünde bile, paralel azaltma için ek senkronizasyon gerekmez.

Eğer kullanmazsanız parallel()bu işe yarayacak

List<Long> sourceLongList = Arrays.asList(1L, 10L, 50L, 80L, 100L, 120L, 133L, 333L);

List<Long> targetLongList =  new ArrayList<Long>();

sourceLongList.stream().peek(i->targetLongList.add(i)).collect(Collectors.toList());