Java 8でjava.util.stream.Streamからリストを取得する

コレクションを簡単にフィルター処理するために、Java 8ラムダをいじっていました。しかし、同じステートメント内で新しいリストとして結果を取得する簡潔な方法は見つかりませんでした。これまでのところ、私の最も簡潔なアプローチは次のとおりです。

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

新しい結果リストを生成せずに停止したため、ネット上の例は私の質問に答えませんでした。より簡潔な方法があるはずです。私がいることを、期待したStreamクラスには、などのメソッドがありtoList()、toSet()...

targetLongList3行目で変数を直接割り当てる方法はありますか？

ストリームがシーケンシャルのままである限り、あなたがやっていることは最も簡単な方法かもしれませんforEach。

[後の編集：sequential（）の呼び出しが必要な理由はforEach(targetLongList::add)、ストリームが並列である場合、現状のコード（）が際どいためです。それでも、forEach明確に非決定的であるように、意図した効果は達成されません。シーケンシャルストリームでも、要素処理の順序は保証されません。forEachOrdered正しい順序を保証するために使用する必要があります。Stream APIデザイナーの意図は、以下のように、この状況でコレクターを使用することです。]

代替案は

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

更新しました：

別のアプローチは使用することCollectors.toListです：

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

以前のソリューション：

別のアプローチは使用することCollectors.toCollectionです：

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

コレクターを返すutilメソッドを使用しArrayListたいのですが、それが必要な場合に使用します。

私が使用するソリューションCollectors.toCollection(ArrayList::new)は、そのような一般的な操作には少しうるさすぎると思います。

例：

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

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

この回答では、カスタムコレクターの作成と使用がいかに簡単かを示したいと思います。

プリミティブの配列がある場合は、Eclipseコレクションで利用可能なプリミティブコレクションを使用できます。

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

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

使用したい場合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);

注：私はEclipseコレクションの寄稿者です。

もう少し効率的な方法（ソースリストの作成とフィルターによる自動アンボックス化を避けます）：

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

collect(Collectors.toList());

これは、任意のストリームをリストに変換するために使用できる呼び出しです。

より具体的に：

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

から：

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

サードパーティのライブラリを使用してもかまわない場合は、AOLのcyclops-react lib（私が寄稿者である開示）に、Listを含むすべてのJDKコレクションタイプの拡張機能があります。ListXインターフェースはjava.util.Listを拡張し、フィルターを含む多数の便利な演算子を追加します。

あなたは単に書くことができます

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

ListXは、既存のリストから作成することもできます（ListX.fromIterableを使用）。

LongStreamクラスによって提供されるcollectメソッドの別のバリアントがあり、同様にIntStreamおよびDoubleStreamクラスによっても提供されます。

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

このストリームの要素に対して変更可能な縮小操作を実行します。変更可能な削減とは、削減された値がArrayListなどの変更可能な結果コンテナーであり、要素は、結果を置き換えるのではなく、結果の状態を更新することによって組み込まれるものです。これにより、次と同等の結果が生成されます。

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

reduce（long、LongBinaryOperator）と同様に、追加の同期を必要とせずに収集操作を並列化できます。これは端末操作です。

そして、この収集方法であなたの質問に答えるのは以下の通りです：

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

以下は、非常にスマートなメソッド参照バリアントですが、理解するのが難しいものもあります。

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

HashSetのバリアントは次のとおりです。

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

同様に、LinkedListバリアントは次のようになります。

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

（私のような）誰かがプリミティブ型ではなくオブジェクトを処理する方法を探している場合は、 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);

プリント：

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

ここにAbacusUtilによるコードがあります

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

情報開示：私はAbacusUtilの開発者です。

以下のようにコードを書き直すことができます：

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

変更可能なリストを収集するには：

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

不変リストを収集するには：

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

JavaDoccollectからの説明：

Collectorを使用して、このストリームの要素に対して変更可能な縮小操作を実行します。Collectorは、collect（Supplier、BiConsumer、BiConsumer）の引数として使用される関数をカプセル化し、収集戦略の再利用や、複数レベルのグループ化やパーティション化などの収集操作の構成を可能にします。ストリームが並列で、コレクターが並行であり、ストリームが順序付けされていないか、コレクターが順序付けられていない場合、並行削減が実行されます（並行削減の詳細については、コレクターを参照してください）。

これは端末操作です。

並列で実行すると、複数の中間結果がインスタンス化され、データが入力され、マージされて、可変データ構造の分離が維持されます。したがって、スレッドセーフでないデータ構造（ArrayListなど）と並行して実行された場合でも、並列縮小のために追加の同期を行う必要はありません。

使用しない場合はparallel()これでうまくいきます

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