Mengambil Daftar dari java.util.stream.Stream di Java 8

Saya sedang bermain-main dengan Java 8 lambdas untuk dengan mudah menyaring koleksi. Tetapi saya tidak menemukan cara ringkas untuk mengambil hasilnya sebagai daftar baru dalam pernyataan yang sama. Inilah pendekatan saya yang paling ringkas sejauh ini:

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

Contoh di internet tidak menjawab pertanyaan saya karena berhenti tanpa menghasilkan daftar hasil baru. Pasti ada cara yang lebih ringkas. Saya akan diharapkan, bahwa Streamkelas memiliki metode seperti toList(), toSet()...

Apakah ada cara agar variabel targetLongListdapat langsung ditugaskan oleh baris ketiga?

Apa yang Anda lakukan mungkin merupakan cara paling sederhana, asalkan aliran Anda tetap berurutan — jika tidak, Anda harus melakukan panggilan ke sekuensial () sebelumnya forEach.

[sunting kemudian: alasan pemanggilan sekuensial () diperlukan adalah karena kode yang ada ( forEach(targetLongList::add)) akan bersemangat jika alirannya paralel. Bahkan kemudian, itu tidak akan mencapai efek yang dimaksudkan, seperti forEachyang secara eksplisit tidak ditentukan - bahkan dalam aliran berurutan urutan pemrosesan elemen tidak dijamin. Anda harus menggunakan forEachOrdereduntuk memastikan pemesanan yang benar. Maksud dari perancang Stream API adalah Anda akan menggunakan kolektor dalam situasi ini, seperti di bawah ini.]

Alternatifnya adalah

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

Diperbarui:

Pendekatan lain adalah menggunakan Collectors.toList:

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

Solusi Sebelumnya:

Pendekatan lain adalah menggunakan Collectors.toCollection:

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

Saya suka menggunakan metode util yang mengembalikan kolektor untuk ArrayList ketika itulah yang saya inginkan.

Saya pikir solusinya menggunakan Collectors.toCollection(ArrayList::new) agak terlalu berisik untuk operasi yang umum.

Contoh:

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

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

Dengan jawaban ini saya juga ingin menunjukkan betapa sederhananya membuat dan menggunakan kolektor khusus, yang umumnya sangat berguna.

Jika Anda memiliki larik primitif, Anda dapat menggunakan koleksi primitif yang tersedia di Eclipse Collections .

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

Jika Anda tidak dapat mengubah sourceLongList dari 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<>());

Jika Anda ingin menggunakan 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);

Catatan: Saya adalah kontributor untuk Eclipse Collections.

Cara yang sedikit lebih efisien (hindari pembuatan Daftar sumber dan buka otomatis oleh filter):

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

collect(Collectors.toList());

Ini adalah panggilan yang dapat Anda gunakan untuk mengonversi Streaming apa pun ke Daftar.

lebih konkret:

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

dari:

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

Jika Anda tidak keberatan menggunakan perpustakaan pihak ketiga, cyclop-react lib (pengungkapan Saya adalah kontributor) AOL memiliki ekstensi untuk semua jenis Koleksi JDK , termasuk Daftar . Antarmuka ListX memperluas java.util.List dan menambahkan sejumlah besar operator yang berguna, termasuk filter.

Anda cukup menulis-

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

ListX juga dapat dibuat dari Daftar yang ada (via ListX.fromIterable)

Ada varian lain dari metode kumpulkan yang disediakan oleh kelas LongStream dan juga oleh kelas IntStream dan DoubleStream.

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

Melakukan operasi pengurangan yang bisa berubah pada elemen aliran ini. Pengurangan yang bisa berubah adalah di mana nilai yang dikurangi adalah wadah hasil yang bisa berubah, seperti ArrayList, dan elemen digabungkan dengan memperbarui status hasil alih-alih dengan mengganti hasilnya. Ini menghasilkan hasil yang setara dengan:

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

Seperti mengurangi (panjang, LongBinaryOperator), operasi pengumpulan dapat diparalelkan tanpa memerlukan sinkronisasi tambahan. Ini adalah operasi terminal.

Dan jawaban untuk pertanyaan Anda dengan metode kumpulkan ini adalah sebagai berikut:

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

Di bawah ini adalah varian referensi metode yang cukup pintar tetapi beberapa yang sulit dipahami:

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

Di bawah ini akan menjadi varian HashSet:

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

Varian LinkedList serupa adalah seperti ini:

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

Dalam kasus seseorang (seperti saya) di luar sana sedang mencari cara berurusan dengan Objek, bukan tipe primitif kemudian gunakan 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);

cetakan:

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

Berikut ini kode dari AbacusUtil

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

Pengungkapan ： Saya pengembang AbacusUtil.

Anda dapat menulis ulang kode seperti di bawah ini:

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

Untuk mengumpulkan dalam daftar yang dapat diubah:

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

Untuk mengumpulkan dalam daftar yang tidak berubah:

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

Penjelasan collectdari javadoc :

Melakukan operasi pengurangan yang bisa berubah pada elemen aliran ini menggunakan Kolektor. Seorang Kolektor merangkum fungsi yang digunakan sebagai argumen untuk mengumpulkan (Pemasok, BiConsumer, BiConsumer), memungkinkan untuk menggunakan kembali strategi pengumpulan dan komposisi operasi pengumpulan seperti pengelompokan atau partisi multi-level. Jika aliran paralel, dan Kolektor bersamaan, dan aliran tidak berurutan atau kolektor tidak berurutan, maka pengurangan bersamaan akan dilakukan (lihat Kolektor untuk detail tentang reduksi bersamaan.)

Ini adalah operasi terminal.

Ketika dieksekusi secara paralel, beberapa hasil antara dapat dipakai, diisi, dan digabungkan untuk menjaga isolasi struktur data yang bisa berubah. Oleh karena itu, bahkan ketika dieksekusi secara paralel dengan struktur data yang tidak aman (seperti ArrayList), tidak diperlukan sinkronisasi tambahan untuk pengurangan paralel.

Jika Anda tidak menggunakan parallel()ini akan berhasil

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