型パラメータ:: T - ストリー� 要� の型

すべてのスーパー・インタフェース:: AutoCloseable, BaseStream<T, Stream<T>>

public interface Stream<T> extends BaseStream<T, Stream<T>>

� �次および並列の集約操作をサポートする要� のシーケンスです。次の例は、StreamとIntStreamを使用する集計操作を示したものです。


     int sum = widgets.stream()
                      .filter(w -> w.getColor() == RED)
                      .mapToInt(w -> w.getWeight())
                      .sum();

この例では、widgetsはCollection<Widget>です。 Collection.stream()経由でWidgetオブジェクトのストリー� が作成され、その結果がフィルタリングされて赤色のウィジェットのみを含むストリー� が生成された後、それが、各赤色ウィジェットの重量を表すint値のストリー� に変換されます。続いてこのストリー� が合計され、合計重量が生成されます。

オブジェクト参照のストリー� であるStreamのほかに、IntStream、LongStreamおよびDoubleStream用のプリミティブ特殊化も存在しており、これらもすべてストリー� と呼ばれ、ここで記述する特性や制限に準� します。

計算を実行できるように、複数のストリー� 操作を組み合わせて1つのストリー� ・パイプラインが形成されます。ストリー� ・パイプラインは、1つのソース(配列、コレクション、ジェネレータ関数、入出力チャネルなど)、0個以上の中間操作(filter(Predicate)など、あるストリー� を別のストリー� に変換する操作)および1つの終端操作(count()やforEach(Consumer)など、結果または副作用を生成する操作)から構成されます。ストリー� は遅延処理されます。ソース・データに対する計算は終端操作が起動されるまで実行されず、ソース要� も必要な� けしか消費されません。

ストリー� 実装では、結果の計算を最適化する際にかなりの緯度が許可されます。たとえば、ストリー� 実装は、ストリー� ・パイプラインから操作(または全ステージ)を自由に除去できます -- したがって、行動パラメータの呼び出しを無効にします -- 計算の結果に影響しないことを証明できる� �合。これは、特に(端末操作forEachおよびforEachOrderedなどによる)が指定されていないかぎり、動作パラメータの副作用が常に実行されるわけではなく、依存すべきではないことを意味します。 (このような最適化の具体的な例は、count()操作に記載されているAPIノートを参照してく� さい。詳細は、ストリー� ・パッケージのドキュメントのside-effectsの� �を参照してく� さい。)

コレクションとストリー� は、表面上似た点があるものの、異なる目的を持っています。コレクションは主に、要� の効率的な管理やアクセスに注力しています。これに対し、ストリー� は要� の直接アクセスや操作の手段を持たず、代わりにソースやそのソースに対して集約的に実行される計算操作を宣言的に記述することに注力しています。た� し、用意されたストリー� 操作が必要な機能を提供しない� �合には、BaseStream.iterator()およびBaseStream.spliterator()操作を使って制御されたトラバーサルを実行することもできます。

ストリー� ・パイプラインは、上の「widgets」の例のように、ストリー� ・ソースに対する問合せとみなすことができます。ソースが明示的に同時変更向けに設計されたもの(ConcurrentHashMapなど)でないかぎり、ストリー� のソースを照会中に変更すると、予測不可能な動作や間違った動作が発生する可能性があります。

ほとんどのストリー� 操作は、上の例でmapToIntに渡されたラ� ダ式w -> w.getWeight()のような、ユーザー指定の動作を記述するパラメータを受け取ります。正しい動作を維持するには、これらの動作パラメータは次を満たす必要があります。

非干渉でなければいけない(ストリー� のソースを変更しない)、および
ほとんどの� �合、ステートレスでなければいけない(その結果は、ストリー� ・パイプラインの実行中に変化する可能性のあるどの状態にも依存すべきでない)。

そのようなパラメータは常に関数型インタフェース(Functionなど)のインスタンスであり、通常はラ� ダ式やメソッド参照になります。特に明記されていないかぎり、これらのパラメータはnull以外でなければいけません。

(中間または終端ストリー� 操作を呼び出して)ストリー� を操作するのは、一度� けにすべきです。このため、たとえば同じソースが2つ以上のパイプラインに対してデータを供給する「フォークされた」ストリー� や、同じストリー� を複数回トラバースすることなどは、禁止されます。ストリー� 実装は、ストリー� が再利用されているのを検出すると、IllegalStateExceptionをスローします。た� し、一部のストリー� 操作からは新しいストリー� ・オブジェクトではなくレシーバが返されることがあるため、� �合によっては再利用を検出できない可能性があります。

ストリー� はBaseStream.close()メソッドを持ち、AutoCloseableを実装します。ストリー� が閉じられた後でストリー� を操作すると、IllegalStateExceptionがスローされます。ほとんどのストリー� ・インスタンスは、特別なリソース管理を必要としないコレクション、配列または生成関数によってバックアップされるため、使用後にクローズする必要はありません。一般に、ソースがIOチャネルであるストリー� (Files.lines(Path)によって返されるストリー� など)のみ、クローズが必要です。ストリー� を閉じる必要がある� �合は、try-with-resources文または同様の制御構� 内のリソースとして開いて、操作の完了後にすぐに閉じられるようにする必要があります。

ストリー� ・パイプラインは� �次、並列のいずれかで実行できます。この実行モードは、ストリー� のプロパティの1つです。ストリー� の作成時には、� �次実行または並列実行の初期選択が行われます。 (たとえば、Collection.stream()では� �次ストリー� が作成され、Collection.parallelStream()では並列ストリー� が作成されます。) この実行モードの選択を変更するにはBaseStream.sequential()またはBaseStream.parallel()メソッドを使用し、実行モードを照会するにはBaseStream.isParallel()メソッドを使用します。

導入されたバージョン:

1.8

関連� �目:

ネストされたクラスのサマリー

ネストされたクラス

修飾子と型

インタフェース

説明

static interface

Stream.Builder<T>

Streamの可変ビルダーです。
メソッドのサマリー

修飾子と型

メソッド

説明

boolean

allMatch(Predicate<? super T> predicate)

このストリー� のすべての要� が指定された述語に一致するかどうかを返します。

boolean

anyMatch(Predicate<? super T> predicate)

このストリー� のいずれかの要� が指定された述語に一致するかどうかを返します。

static <T> Stream.Builder<T>

builder()

Streamのビルダーを返します。

<R> R

collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R,R> combiner)

このストリー� の要� に対して可変リダクション操作を実行します。

<R,A> R

collect(Collector<? super T, A, R> collector)

Collectorを使ってこのストリー� の要� に対する可変リダクション操作を実行します。

static <T> Stream<T>

concat(Stream<? extends T> a, Stream<? extends T> b)

最初のストリー� の全要� と2番目のストリー� の全要� を連結したものを要� に持つ、遅延連結ストリー� を作成します。

long

count()

このストリー� の要� の個数を返します。

Stream<T>

distinct()

このストリー� の重複を除いた要� (Object.equals(Object)による)から構成されるストリー� を返します。

default Stream<T>

dropWhile(Predicate<? super T> predicate)

このストリー� が� �序付けされている� �合、指定された述語に一致する要� の最長のプレフィクスを削除した後、このストリー� の残りの要� で構成されるストリー� を返します。

static <T> Stream<T>

empty()

空の� �次Streamを返します。

Stream<T>

filter(Predicate<? super T> predicate)

このストリー� の要� のうち、指定された述語に一致するものから構成されるストリー� を返します。

Optional<T>

findAny()

ストリー� の一部の要� を記述するOptionalを返します。ストリー� が空の� �合は空のOptionalを返します。

Optional<T>

findFirst()

このストリー� の最初の要� を記述するOptionalを返します。ストリー� が空の� �合は空のOptionalを返します。

<R> Stream<R>

flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)

このストリー� の各要� をマップされたストリー� (指定されたマッピング関数を各要� に適用することで得られる)の内容で置き換えた結果から成るストリー� を返します。

DoubleStream

flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper)

このストリー� の各要� を、その要� に指定されたマッピング関数を適用することによって生成されるマップ先ストリー� の内容で置き換えた結果から構成されるDoubleStreamを返します。

IntStream

flatMapToInt(Function<? super T, ? extends IntStream> mapper)

このストリー� の各要� をマップされたストリー� (指定されたマッピング関数を各要� に適用することで得られる)の内容で置き換えた結果から成るIntStreamを返します。

LongStream

flatMapToLong(Function<? super T, ? extends LongStream> mapper)

このストリー� の各要� をマップされたストリー� (指定されたマッピング関数を各要� に適用することで得られる)の内容で置き換えた結果から成るLongStreamを返します。

void

forEach(Consumer<? super T> action)

このストリー� の各要� に対してアクションを実行します。

void

forEachOrdered(Consumer<? super T> action)

このストリー� の各要� に対してアクションを実行します。その実行� �は、ストリー� の検出� �が定義されている� �合はその� �番になります。

default <R> Stream<R>

gather(Gatherer<? super T, ?, R> gatherer)

指定されたGathererをこのストリー� の要� に適用した結果で構成されるストリー� を返します。

static <T> Stream<T>

generate(Supplier<? extends T> s)

指定されたSupplierによって生成される要� を含む、� �序付けされていない無限� �次ストリー� を返します。

static <T> Stream<T>

iterate(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next)

指定されたnextファンクションの反復適用によって生成された� �次� �序付けされたStreamを、指定されたhasNext述語を満たす条件付き初期要� に戻します。

static <T> Stream<T>

iterate(T seed, UnaryOperator<T> f)

初期要� seedに関数fを繰り返し適用することで生成される、� �序付けされた無限� �次Streamを返します(seed、f(seed)、f(f(seed))、といった要� から成るStreamが生成される)。

Stream<T>

limit(long maxSize)

このストリー� の要� をmaxSize以内の長さに切り詰めた結果から成るストリー� を返します。

<R> Stream<R>

map(Function<? super T, ? extends R> mapper)

このストリー� の要� に指定された関数を適用した結果から構成されるストリー� を返します。

default <R> Stream<R>

mapMulti(BiConsumer<? super T, ? super Consumer<R>> mapper)

このストリー� の各要� を複数の要� (特にゼロ個以上の要� )で置き換えた結果で構成されるストリー� を返します。

default DoubleStream

mapMultiToDouble(BiConsumer<? super T, ? super DoubleConsumer> mapper)

このストリー� の各要� を複数の要� (特にゼロ個以上の要� )で置き換えた結果で構成されるDoubleStreamを返します。

default IntStream

mapMultiToInt(BiConsumer<? super T, ? super IntConsumer> mapper)

このストリー� の各要� を複数の要� (特にゼロ個以上の要� )で置き換えた結果で構成されるIntStreamを返します。

default LongStream

mapMultiToLong(BiConsumer<? super T, ? super LongConsumer> mapper)

このストリー� の各要� を複数の要� (特にゼロ個以上の要� )で置き換えた結果で構成されるLongStreamを返します。

DoubleStream

mapToDouble(ToDoubleFunction<? super T> mapper)

このストリー� の要� に指定された関数を適用した結果から構成されるDoubleStreamを返します。

IntStream

mapToInt(ToIntFunction<? super T> mapper)

このストリー� の要� に指定された関数を適用した結果から構成されるIntStreamを返します。

LongStream

mapToLong(ToLongFunction<? super T> mapper)

このストリー� の要� に指定された関数を適用した結果から構成されるLongStreamを返します。

Optional<T>

max(Comparator<? super T> comparator)

指定されたComparatorに従ってこのストリー� の最大要� を返します。

Optional<T>

min(Comparator<? super T> comparator)

指定されたComparatorに従ってこのストリー� の最小要� を返します。

boolean

noneMatch(Predicate<? super T> predicate)

指定された述語に一致する要� がこのストリー� 内に存在しないかどうかを返します。

static <T> Stream<T>

of(T t)

単一要� を含む� �次Streamを返します。

static <T> Stream<T>

of(T... values)

指定された値を要� に持つ、� �序付けされた� �次ストリー� を返します。

static <T> Stream<T>

ofNullable(T t)

単一の要� を含む� �次Streamを返します(null以外の� �合)。それ以外の� �合は空のStreamを返します。

Stream<T>

peek(Consumer<? super T> action)

このストリー� の要� から成るストリー� を返すほか、その結果のストリー� から消費される各要� に対し、指定されたアクションを実行します。

Optional<T>

reduce(BinaryOperator<T> accumulator)

結合的累積関数を使用して、このストリー� の要� に対してリダクションを実行し、リダクションされた値を記述するOptionalを返します(ある� �合)。

T

reduce(T identity, BinaryOperator<T> accumulator)

指定された単位元の値と結合的な累積関数を使ってこのストリー� の要� に対してリダクションを実行し、リデュースされた値を返します。

<U> U

reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner)

指定された単位元、累積関数、および結合的関数を使用して、このストリー� の要� に対してリダクションを実行します。

Stream<T>

skip(long n)

このストリー� の最初のn個の要� を� �棄した残りの要� で構成されるストリー� を返します。

Stream<T>

sorted()

このストリー� の要� を自然� �序に従ってソートした結果から構成されるストリー� を返します。

Stream<T>

sorted(Comparator<? super T> comparator)

このストリー� の要� で構成されるストリー� を、指定されたComparatorに従ってソートして返します。

default Stream<T>

takeWhile(Predicate<? super T> predicate)

このストリー� が� �序付けされている� �合、指定された述語に一致する、このストリー� から取得された要� の最長のプレフィクスで構成されるストリー� を返します。

Object[]

toArray()

このストリー� の要� を含む配列を返します。

<A> A[]

toArray(IntFunction<A[]> generator)

指定されたgenerator関数を使用して、このストリー� の要� を含む配列を返し、返された配列と、パーティション化された実行またはサイズ変更に必要となる可能性のある追� の配列を割り当てます。

default List<T>

toList()

このストリー� の要� をListに蓄積します。

インタフェースjava.util.stream.BaseStreamで宣言されたメソッド
close, isParallel, iterator, onClose, parallel, sequential, spliterator, unordered

メソッドの詳細
- filter
  
  Stream<T> filter(Predicate<? super T> predicate)
  
  このストリー� の要� のうち、指定された述語に一致するものから構成されるストリー� を返します。
  これは中間操作です。
  
  パラメータ:
  
  predicate - 各要� を含めるべきか判定する目的で各要� に適用する、非干渉でステートレスな述語
  
  戻り値:
  
  新しいストリー�
- map
  
  <R> Stream<R> map(Function<? super T, ? extends R> mapper)
  
  このストリー� の要� に指定された関数を適用した結果から構成されるストリー� を返します。
  これは中間操作です。
  
  型パラメータ:
  
  R - 新しいストリー� の要� タイプ
  
  パラメータ:
  
  mapper - 各要� に適用する非干渉でステートレスな関数
  
  戻り値:
  
  新しいストリー�
- mapToInt
  
  IntStream mapToInt(ToIntFunction<? super T> mapper)
  
  このストリー� の要� に指定された関数を適用した結果から構成されるIntStreamを返します。
  これは中間操作です。
  
  パラメータ:
  
  mapper - 各要� に適用する非干渉でステートレスな関数
  
  戻り値:
  
  新しいストリー�
- mapToLong
  
  LongStream mapToLong(ToLongFunction<? super T> mapper)
  
  このストリー� の要� に指定された関数を適用した結果から構成されるLongStreamを返します。
  これは中間操作です。
  
  パラメータ:
  
  mapper - 各要� に適用する非干渉でステートレスな関数
  
  戻り値:
  
  新しいストリー�
- mapToDouble
  
  DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper)
  
  このストリー� の要� に指定された関数を適用した結果から構成されるDoubleStreamを返します。
  これは中間操作です。
  
  パラメータ:
  
  mapper - 各要� に適用する非干渉でステートレスな関数
  
  戻り値:
  
  新しいストリー�
- flatMap
  <R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)
  
  このストリー� の各要� をマップされたストリー� (指定されたマッピング関数を各要� に適用することで得られる)の内容で置き換えた結果から成るストリー� を返します。各マップ先ストリー� は、その内容がこのストリー� 内に配置されるとクローズされます。 (マップ先ストリー� がnullの� �合はかわりに空のストリー� が使用されます。)
  これは中間操作です。
  
  APIのノート:
  
  flatMap()操作には、ストリー� の要� に対して1対多の変換を適用した後、結果の要� を新しいストリー� 内にフラット化する効果があります。
  例
  ordersが購入注文のストリー� であり、各購入注文には明細行のコレクションが含まれている� �合、次のようにすると、すべての注文のすべての明細行を含むストリー� が生成されます。
  orders.flatMap(order -> order.getLineItems().stream())...
  
  pathがファイルへのパスである� �合、次のようにすると、そのファイルに含まれる単語のストリー� が生成されます。
  Stream<String> lines = Files.lines(path, StandardCharsets.UTF_8); Stream<String> words = lines.flatMap(line -> Stream.of(line.split(" +")));
  flatMapに渡されたmapper関数は、単純な正規表現を使って1行を単語の配列に分割した後、その配列から単語のストリー� を作成します。
  
  型パラメータ:
  
  R - 新しいストリー� の要� タイプ
  
  パラメータ:
  
  mapper - 新しい値のストリー� を生成するために各要� に適用する、非干渉でステートレスな関数
  
  戻り値:
  
  新しいストリー�
  
  関連� �目:
  
  mapMulti
- flatMapToInt
  IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper)
  
  このストリー� の各要� をマップされたストリー� (指定されたマッピング関数を各要� に適用することで得られる)の内容で置き換えた結果から成るIntStreamを返します。各マップ先ストリー� は、その内容がこのストリー� 内に配置されるとクローズされます。 (マップ先ストリー� がnullの� �合はかわりに空のストリー� が使用されます。)
  これは中間操作です。
  
  パラメータ:
  
  mapper - 新しい値のストリー� を生成するために各要� に適用する、非干渉でステートレスな関数
  
  戻り値:
  
  新しいストリー�
  
  関連� �目:
  
  flatMap
- flatMapToLong
  LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper)
  
  このストリー� の各要� をマップされたストリー� (指定されたマッピング関数を各要� に適用することで得られる)の内容で置き換えた結果から成るLongStreamを返します。各マップ先ストリー� は、その内容がこのストリー� 内に配置されるとクローズされます。 (マップ先ストリー� がnullの� �合はかわりに空のストリー� が使用されます。)
  これは中間操作です。
  
  パラメータ:
  
  mapper - 新しい値のストリー� を生成するために各要� に適用する、非干渉でステートレスな関数
  
  戻り値:
  
  新しいストリー�
  
  関連� �目:
  
  flatMap
- flatMapToDouble
  DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper)
  
  このストリー� の各要� を、その要� に指定されたマッピング関数を適用することによって生成されるマップ先ストリー� の内容で置き換えた結果から構成されるDoubleStreamを返します。各マップ先ストリー� は、その内容がこのストリー� 内に配置されるとクローズされます。 (マップ先ストリー� がnullの� �合はかわりに空のストリー� が使用されます。)
  これは中間操作です。
  
  パラメータ:
  
  mapper - 新しい値のストリー� を生成するために各要� に適用する、非干渉でステートレスな関数
  
  戻り値:
  
  新しいストリー�
  
  関連� �目:
  
  flatMap
- mapMulti
  default <R> Stream<R> mapMulti(BiConsumer<? super T, ? super Consumer<R>> mapper)
  
  このストリー� の各要� を複数の要� (特にゼロ個以上の要� )で置き換えた結果で構成されるストリー� を返します。置換を実行するには、置換要� を受け入れるconsumer引数とともに、指定されたマッピング関数を各要� に適用します。マッピング関数は、コンシューマをゼロ回以上コールして置換要� を提供します。
  これは中間操作です。
  consumer引数がマッピング関数に対するアプリケーションのスコープ外で使用されている� �合、結果は未定義です。
  
  APIのノート:
  
  このメソッドは、ストリー� の要� に一対多変換を適用し、結果要� を新しいストリー� にフラット化するという点で、flatMapに似ています。このメソッドは、次の� �合にflatMapよりも推奨されます:
  
  各ストリー� 要� を少数の(0(ゼロ))要� で置換する� �合。このメソッドを使用すると、flatMapで必要な結果要� のグループごとに新しいStreamインスタンスを作成するオーバーヘッドが回避されます。
  
  結果要� をStreamの形式で返すよりも、結果要� の生成に必� �のアプローチを使用する方が簡単な� �合。
  
  ラ� ダ式がマッパー関数の引数として指定されている� �合、返されるストリー� の要� 型<R>を適切に推論するために、追� の型情� �が必要になることがあります。これは、ラ� ダ・パラメータの明示的な型宣言の形式、またはmapMultiコールの明示的な型引数として指定できます。
  例
  Numberオブジェクトのストリー� を指定すると、次の例ではIntegerオブジェクトのみを含むリストが生成されます:
  Stream<Number> numbers = ... ; List<Integer> integers = numbers.<Integer>mapMulti((number, consumer) -> { if (number instanceof Integer i) consumer.accept(i); }) .collect(Collectors.toList());
  
  Iterable<Object>があり、それ自体がIterableタイプである要� を再帰的に拡張する必要がある� �合は、次のようにmapMultiを使用できます:
  class C { static void expandIterable(Object e, Consumer<Object> c) { if (e instanceof Iterable<?> elements) { for (Object ie : elements) { expandIterable(ie, c); } } else if (e != null) { c.accept(e); } } public static void main(String[] args) { var nestedList = List.of(1, List.of(2, List.of(3, 4)), 5); Stream<Object> expandedStream = nestedList.stream().mapMulti(C::expandIterable); } }
  
  実装要件:
  
  デフォルト実装は、このストリー� でflatMapを呼び出し、次のように動作する関数を渡します。最初に、新しく作成された内部バッファに置換要� を蓄積するConsumerを使用してマッパー関数をコールします。マッパー関数が返されると、内部バッファからストリー� を作成します。最後に、このストリー� をflatMapに返します。
  
  型パラメータ:
  
  R - 新しいストリー� の要� タイプ
  
  パラメータ:
  
  mapper - 置換要� を生成するnon-interfering、statelessファンクション
  
  戻り値:
  
  新しいストリー�
  
  導入されたバージョン:
  
  16
  
  関連� �目:
  
  flatMap
- mapMultiToInt
  default IntStream mapMultiToInt(BiConsumer<? super T, ? super IntConsumer> mapper)
  
  このストリー� の各要� を複数の要� (特にゼロ個以上の要� )で置き換えた結果で構成されるIntStreamを返します。置換を実行するには、置換要� を受け入れるconsumer引数とともに、指定されたマッピング関数を各要� に適用します。マッピング関数は、コンシューマをゼロ回以上コールして置換要� を提供します。
  これは中間操作です。
  consumer引数がマッピング関数に対するアプリケーションのスコープ外で使用されている� �合、結果は未定義です。
  
  実装要件:
  
  デフォルト実装は、このストリー� でflatMapToIntを呼び出し、次のように動作する関数を渡します。最初に、新しく作成された内部バッファに置換要� を蓄積するIntConsumerを使用してマッパー関数をコールします。マッパー関数が戻ると、内部バッファからIntStreamが作成されます。最後に、このストリー� をflatMapToIntに返します。
  
  パラメータ:
  
  mapper - 置換要� を生成するnon-interfering、statelessファンクション
  
  戻り値:
  
  新しいストリー�
  
  導入されたバージョン:
  
  16
  
  関連� �目:
  
  mapMulti
- mapMultiToLong
  default LongStream mapMultiToLong(BiConsumer<? super T, ? super LongConsumer> mapper)
  
  このストリー� の各要� を複数の要� (特にゼロ個以上の要� )で置き換えた結果で構成されるLongStreamを返します。置換を実行するには、置換要� を受け入れるconsumer引数とともに、指定されたマッピング関数を各要� に適用します。マッピング関数は、コンシューマをゼロ回以上コールして置換要� を提供します。
  これは中間操作です。
  consumer引数がマッピング関数に対するアプリケーションのスコープ外で使用されている� �合、結果は未定義です。
  
  実装要件:
  
  デフォルト実装は、このストリー� でflatMapToLongを呼び出し、次のように動作する関数を渡します。最初に、新しく作成された内部バッファに置換要� を蓄積するLongConsumerを使用してマッパー関数をコールします。マッパー関数が戻ると、内部バッファからLongStreamが作成されます。最後に、このストリー� をflatMapToLongに返します。
  
  パラメータ:
  
  mapper - 置換要� を生成するnon-interfering、statelessファンクション
  
  戻り値:
  
  新しいストリー�
  
  導入されたバージョン:
  
  16
  
  関連� �目:
  
  mapMulti
- mapMultiToDouble
  default DoubleStream mapMultiToDouble(BiConsumer<? super T, ? super DoubleConsumer> mapper)
  
  このストリー� の各要� を複数の要� (特にゼロ個以上の要� )で置き換えた結果で構成されるDoubleStreamを返します。置換を実行するには、置換要� を受け入れるconsumer引数とともに、指定されたマッピング関数を各要� に適用します。マッピング関数は、コンシューマをゼロ回以上コールして置換要� を提供します。
  これは中間操作です。
  consumer引数がマッピング関数に対するアプリケーションのスコープ外で使用されている� �合、結果は未定義です。
  
  実装要件:
  
  デフォルト実装は、このストリー� でflatMapToDoubleを呼び出し、次のように動作する関数を渡します。最初に、新しく作成された内部バッファに置換要� を蓄積するDoubleConsumerを使用してマッパー関数をコールします。マッパー関数が戻ると、内部バッファからDoubleStreamが作成されます。最後に、このストリー� をflatMapToDoubleに返します。
  
  パラメータ:
  
  mapper - 置換要� を生成するnon-interfering、statelessファンクション
  
  戻り値:
  
  新しいストリー�
  
  導入されたバージョン:
  
  16
  
  関連� �目:
  
  mapMulti
- distinct
  
  Stream<T> distinct()
  
  このストリー� の重複を除いた要� (Object.equals(Object)による)から構成されるストリー� を返します。
  � �序付けされたストリー� の� �合、重複のない要� の選択は安定しています(重複した要� では、検出� �で最初に現れた要� が維持されます。) � �序付けされていないストリー� の� �合、安定性は一切保証されません。
  これはステートフルな中間操作です。
  
  APIのノート:
  
  並列パイプラインでdistinct()の安定性を維持するコストは比較的高くなります(操作が完全なバリアーとして動作する必要があり、バッファリングのオーバーヘッドがかなり大きくなる)が、安定性が不要なこともよくあります。状況のセマンティックスが許せば、� �序付けされていないストリー� ・ソース(generate(Supplier)など)を使用するか、BaseStream.unordered()で� �序付けの制約をなくせば、並列パイプラインでのdistinct()の実行効率が大幅に向上する可能性があります。検出� �序との整合性が必要で、かつ並列パイプラインでのdistinct()のパフォーマンスやメモリー使用量に問題がある� �合には、BaseStream.sequential()で� �次実行に切り替えるとパフォーマンスが改善される可能性があります。
  
  戻り値:
  
  新しいストリー�
- sorted
  
  Stream<T> sorted()
  
  このストリー� の要� を自然� �序に従ってソートした結果から構成されるストリー� を返します。このストリー� の要� がComparableでない� �合は、終端操作の実行時にjava.lang.ClassCastExceptionがスローされる可能性があります。
  � �序付けされたストリー� の� �合、ソートは安定しています。 � �序付けされていないストリー� の� �合、安定性は一切保証されません。
  これはステートフルな中間操作です。
  
  戻り値:
  
  新しいストリー�
- sorted
  
  Stream<T> sorted(Comparator<? super T> comparator)
  
  このストリー� の要� で構成されるストリー� を、指定されたComparatorに従ってソートして返します。
  � �序付けされたストリー� の� �合、ソートは安定しています。 � �序付けされていないストリー� の� �合、安定性は一切保証されません。
  これはステートフルな中間操作です。
  
  パラメータ:
  
  comparator - ストリー� 要� の比較に使用される、非干渉でステートレスなComparator
  
  戻り値:
  
  新しいストリー�
- peek
  Stream<T> peek(Consumer<? super T> action)
  
  このストリー� の要� から成るストリー� を返すほか、その結果のストリー� から消費される各要� に対し、指定されたアクションを実行します。
  これは中間操作です。
  並列ストリー� ・パイプラインの� �合、上流の操作によって用意された各要� に対し、任意のタイミングで任意のスレッド内でアクションが呼び出される可能性があります。アクションが共有状態を変更する� �合、必要な同期を提供する責任はアクションにあります。
  
  APIのノート:
  
  このメソッドの主な存在理由は、要� がパイプライン内の特定のポイントを通過する際にその内容を確認するようなデバッグをサポートすることにあります。
  Stream.of("one", "two", "three", "four") .filter(e -> e.length() > 3) .peek(e -> System.out.println("Filtered value: " + e)) .map(String::toUpperCase) .peek(e -> System.out.println("Mapped value: " + e)) .collect(Collectors.toList());
  
  ストリー� 実装で、一部またはすべての要� (findFirstのような短絡操作やcount()に記載されている例)の生成を最適化できる� �合、それらの要� に対してアクションは呼び出されません。
  
  パラメータ:
  
  action - ストリー� から消費される要� に対して実行すべき非干渉アクション
  
  戻り値:
  
  新しいストリー�
- limit
  
  Stream<T> limit(long maxSize)
  
  このストリー� の要� をmaxSize以内の長さに切り詰めた結果から成るストリー� を返します。
  これは、ステートフルな短絡中間操作です。
  
  APIのノート:
  
  limit()は、� �次ストリー� ・パイプラインでは一般に低コストの操作ですが、� �序付けされた並列パイプラインではコストが非常に高くなる可能性があります(特にmaxSizeの値が大きい� �合)。任意のn個の要� を返す� けでなく、検出� �での最初のn個の要� を返さなければいけない、という制約がlimit(n)に課されるからです。状況のセマンティックスが許せば、� �序付けされていないストリー� ・ソース(generate(Supplier)など)を使用するか、BaseStream.unordered()で� �序付けの制約をなくせば、並列パイプラインのlimit()が大幅に高速化される可能性があります。検出� �序との整合性が必要で、かつ並列パイプラインでのlimit()のパフォーマンスやメモリー使用量に問題がある� �合には、BaseStream.sequential()で� �次実行に切り替えるとパフォーマンスが改善される可能性があります。
  
  パラメータ:
  
  maxSize - ストリー� の要� 数の上限
  
  戻り値:
  
  新しいストリー�
  
  スロー:
  
  IllegalArgumentException - maxSizeが� の� �合
- skip
  
  Stream<T> skip(long n)
  
  このストリー� の最初のn個の要� を� �棄した残りの要� で構成されるストリー� を返します。このストリー� に含まれる要� の数がn個より少ない� �合は、空のストリー� が返されます。
  これはステートフルな中間操作です。
  
  APIのノート:
  
  skip()は、� �次ストリー� ・パイプラインでは一般に低コストの操作ですが、� �序付けされた並列パイプラインではコストが非常に高くなる可能性があります(特にnの値が大きい� �合)。任意のn個の要� をスキップする� けでなく、検出� �での最初のn個の要� をスキップしなければいけない、という制約がskip(n)に課されるからです。状況のセマンティックスが許せば、� �序付けされていないストリー� ・ソース(generate(Supplier)など)を使用するか、BaseStream.unordered()で� �序付けの制約をなくせば、並列パイプラインのskip()が大幅に高速化される可能性があります。検出� �序との整合性が必要で、かつ並列パイプラインでのskip()のパフォーマンスやメモリー使用量に問題がある� �合には、BaseStream.sequential()で� �次実行に切り替えるとパフォーマンスが改善される可能性があります。
  
  パラメータ:
  
  n - スキップする先� �要� の数
  
  戻り値:
  
  新しいストリー�
  
  スロー:
  
  IllegalArgumentException - nが� の� �合
- takeWhile
  
  default Stream<T> takeWhile(Predicate<? super T> predicate)
  
  このストリー� が� �序付けされている� �合、指定された述語に一致する、このストリー� から取得された要� の最長のプレフィクスで構成されるストリー� を返します。それ以外の� �合は、このストリー� が� �序付けられていない� �合、指定された述語に一致する、このストリー� から取得された要� のサブセットで構成されるストリー� が返されます。
  このストリー� が� �序付けされている� �合、最長のプレフィクスは、指定された述語に一致するこのストリー� の要� の連続したシーケンスです。 � �序の最初の要� は、このストリー� の最初の要� であり、� �序の最後の要� の直後の要� は、指定された述語と一致しません。
  このストリー� が� �序付けされておらず、このストリー� の一部の(すべてではない)要� が指定された述語と一致する� �合、この操作の動作は非決定的であり、一致する要� (空のセットを含む)のサブセットを自由に取得できます。
  このストリー� のすべての要� が指定された述語に一致する� �合、このストリー� が� �序付けられているかどうかにかかわらず、この操作ではすべての要� (結果は入力と同じです)が使用され、ストリー� の要� が指定された述語に一致しない� �合は(結果は空のストリー� です)は使用されません。
  これは、ステートフルな短絡中間操作です。
  
  APIのノート:
  
  takeWhile()は、通常、� �次ストリー� ・パイプラインに対する安価な操作ですが、� �序付けられたパラレル・パイプラインでは非常にコストがかかります。これは、操作が、有効なプレフィクスのみでなく、検出� �序における要� の最長のプレフィクスを返すように制約されるためです。状況のセマンティクスで許可されている� �合、� �序付けされていないストリー� ・ソース(generate(Supplier)など)を使用するか、BaseStream.unordered()で� �序付け制約を削除すると、パラレル・パイプラインでtakeWhile()が大幅に高速化される可能性があります。出現� �序の一貫性が必要で、パラレル・パイプラインでtakeWhile()を使用したパフォーマンスまたはメモリー使用率が低下している� �合、BaseStream.sequential()を使用して� �次実行に切り替えると、パフォーマンスが向上する可能性があります。
  
  実装要件:
  
  デフォルトの実装では、このストリー� のspliteratorを取得し、そのスプリッタをラップしてトラバーサルに対するこの操作のセマンティクスをサポートし、ラップされたスプリッタに関連付けられた新しいストリー� を返します。戻されたストリー� は、このストリー� (BaseStream.isParallel()による並列実行または� �次実行)の実行特性を保持しますが、ラップされたスプリッタは分割をサポートしないことを選択できます。返されたストリー� が閉じられると、返されたストリー� とこのストリー� の両方のクローズ・ハンドラが起動されます。
  
  パラメータ:
  
  predicate - 要� の最長のプレフィクスを決定するために要� に適用するnon-interfering、stateless述語。
  
  戻り値:
  
  新しいストリー�
  
  導入されたバージョン:
  
  9
- dropWhile
  
  default Stream<T> dropWhile(Predicate<? super T> predicate)
  
  このストリー� が� �序付けされている� �合、指定された述語に一致する要� の最長のプレフィクスを削除した後、このストリー� の残りの要� で構成されるストリー� を返します。それ以外の� �合は、このストリー� が� �序付けられていない� �合、指定された述語に一致する要� のサブセットを削除した後に、このストリー� の残りの要� で構成されるストリー� が返されます。
  このストリー� が� �序付けされている� �合、最長のプレフィクスは、指定された述語に一致するこのストリー� の要� の連続したシーケンスです。 � �序の最初の要� は、このストリー� の最初の要� であり、� �序の最後の要� の直後の要� は、指定された述語と一致しません。
  このストリー� が� �序付けされておらず、このストリー� の一部の(すべてではない)要� が指定された述語と一致する� �合、この操作の動作は非決定的であり、一致する要� (空のセットを含む)のサブセットを自由に削除できます。
  このストリー� のすべての要� が指定された述語と一致する� �合、このストリー� が� �序付けされているかどうかに関係なく、この操作ではすべての要� (結果は空のストリー� です)が削除されるか、またはストリー� の要� が指定された述語に一致しない� �合、要� は削除されません(結果は入力と同じです)。
  これはステートフルな中間操作です。
  
  APIのノート:
  
  dropWhile()は、通常、� �次ストリー� ・パイプラインに対する安価な操作ですが、� �序付けられたパラレル・パイプラインでは非常にコストがかかります。これは、操作が、有効なプレフィクスのみでなく、検出� �序における要� の最長のプレフィクスを返すように制約されるためです。状況のセマンティクスで許可されている� �合、� �序付けされていないストリー� ・ソース(generate(Supplier)など)を使用するか、BaseStream.unordered()で� �序付け制約を削除すると、パラレル・パイプラインでdropWhile()が大幅に高速化される可能性があります。出現� �序の一貫性が必要で、パラレル・パイプラインでdropWhile()を使用したパフォーマンスまたはメモリー使用率が低下している� �合、BaseStream.sequential()を使用して� �次実行に切り替えると、パフォーマンスが向上する可能性があります。
  
  実装要件:
  
  デフォルトの実装では、このストリー� のspliteratorを取得し、そのスプリッタをラップしてトラバーサルに対するこの操作のセマンティクスをサポートし、ラップされたスプリッタに関連付けられた新しいストリー� を返します。戻されたストリー� は、このストリー� (BaseStream.isParallel()による並列実行または� �次実行)の実行特性を保持しますが、ラップされたスプリッタは分割をサポートしないことを選択できます。返されたストリー� が閉じられると、返されたストリー� とこのストリー� の両方のクローズ・ハンドラが起動されます。
  
  パラメータ:
  
  predicate - 要� の最長のプレフィクスを決定するために要� に適用するnon-interfering、stateless述語。
  
  戻り値:
  
  新しいストリー�
  
  導入されたバージョン:
  
  9
- forEach
  
  void forEach(Consumer<? super T> action)
  
  このストリー� の各要� に対してアクションを実行します。
  これは終端操作です。
  この操作の動作は明らかに非決定論的です。並列ストリー� ・パイプラインの� �合、この操作は、ストリー� の検出� �序を考慮することを保証しません。保証すると並列性のメリットが� 牲になるからです。与えられた任意の要� に対し、ライブラリが選択した任意のタイミングで任意のスレッド内でアクションが実行される可能性があります。アクションが共有状態にアクセスする� �合、必要な同期を提供する責任はアクションにあります。
  
  パラメータ:
  
  action - 要� に対して実行する非干渉アクション
- forEachOrdered
  void forEachOrdered(Consumer<? super T> action)
  
  このストリー� の各要� に対してアクションを実行します。その実行� �は、ストリー� の検出� �が定義されている� �合はその� �番になります。
  これは終端操作です。
  この操作は、検出� �序が存在する� �合はその� �序で、要� を一度に1つずつ処理します。ある要� のアクション実行はその後続要� のアクション実行よりも前に発生しますが、どの要� についても、ライブラリが選択した任意のスレッド内でアクションが実行される可能性があります。
  
  パラメータ:
  
  action - 要� に対して実行する非干渉アクション
  
  関連� �目:
  
  forEach(Consumer)
- toArray
  
  Object[] toArray()
  
  このストリー� の要� を含む配列を返します。
  これは終端操作です。
  
  戻り値:
  
  「ランタイ� ・コンポーネント・タイプ」がObjectの配列。このストリー� の要� を含む
- toArray
  <A> A[] toArray(IntFunction<A[]> generator)
  
  指定されたgenerator関数を使用して、このストリー� の要� を含む配列を返し、返された配列と、パーティション化された実行またはサイズ変更に必要となる可能性のある追� の配列を割り当てます。
  これは終端操作です。
  
  APIのノート:
  
  ジェネレータ関数は、要求された配列のサイズを表す整数を受け取り、要求されたサイズの配列を生成します。これは、配列コンストラクタ参照で簡潔に表現できます。
  Person[] men = people.stream() .filter(p -> p.getGender() == MALE) .toArray(Person[]::new);
  
  型パラメータ:
  
  A - 結果の配列のコンポーネント型
  
  パラメータ:
  
  generator - 要求された型と指定された長さを持つ新しい配列を生成する関数
  
  戻り値:
  
  このストリー� の要� を含む配列
  
  スロー:
  
  ArrayStoreException - このストリー� の要� の実行時の型が、生成された配列の「ランタイ� ・コンポーネント・タイプ」に代入可能でない� �合
- reduce
  T reduce(T identity, BinaryOperator<T> accumulator)
  
  指定された単位元の値と結合的な累積関数を使ってこのストリー� の要� に対してリダクションを実行し、リデュースされた値を返します。これは、次の操作に相当します。
  T result = identity; for (T element : this stream) result = accumulator.apply(result, element) return result;
  た� し、� �次実行の制約が課されるわけではありません。
  identity値はアキュ� レータ関数の単位元でなければいけません。つまり、すべてのtについて、accumulator.apply(identity, t)がtに等しくなります。 アキュ� レータ関数は結合的な関数でなければいけません。
  これは終端操作です。
  
  APIのノート:
  
  合計、最小、最大、平均、文字列連結はすべて、リダクションの特殊な� �合です。数値ストリー� の合計は次のように表現できます。
  Integer sum = integers.reduce(0, (a, b) -> a+b);
  または
  Integer sum = integers.reduce(0, Integer::sum);
  
  これは、単純にループで中間合計を更新していく方法に比べて� 回りな集計方法に見えるかもしれませんが、リダクション操作の並列化が容易に行え、並列化の際に同期を追� する必要がなく、データ競合のリスクも大幅に減少します。
  
  パラメータ:
  
  identity - 蓄積関数に対する単位元の値
  
  accumulator - 2つの値を結合するための結合的、非干渉、およびステートレスな関数
  
  戻り値:
  
  リダクションの結果
- reduce
  Optional<T> reduce(BinaryOperator<T> accumulator)
  
  結合的累積関数を使用して、このストリー� の要� に対してリダクションを実行し、リダクションされた値を記述するOptionalを返します(ある� �合)。これは、次の操作に相当します。
  boolean foundAny = false; T result = null; for (T element : this stream) { if (!foundAny) { foundAny = true; result = element; } else result = accumulator.apply(result, element); } return foundAny ? Optional.of(result) : Optional.empty();
  た� し、� �次実行の制約が課されるわけではありません。
  アキュ� レータ関数は結合的な関数でなければいけません。
  これは終端操作です。
  
  パラメータ:
  
  accumulator - 2つの値を結合するための結合的、非干渉、およびステートレスな関数
  
  戻り値:
  
  リダクションの結果を記述するOptional
  
  スロー:
  
  NullPointerException - リダクションの結果がnullの� �合
  
  関連� �目:
  
  reduce(Object, BinaryOperator)
  
  min(Comparator)
  
  max(Comparator)
- reduce
  <U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner)
  
  指定された単位元、累積関数、および結合的関数を使用して、このストリー� の要� に対してリダクションを実行します。これは、次の操作に相当します。
  U result = identity; for (T element : this stream) result = accumulator.apply(result, element) return result;
  た� し、� �次実行の制約が課されるわけではありません。
  identity値はコンバイナ関数の単位元でなければいけません。つまり、すべてのuについて、combiner(identity, u)がuに等しくなります。さらに、combiner関数はaccumulator関数と互換性がある必要があります。すべてのuとtについて、次が成り立つ必要があります。
  combiner.apply(u, accumulator.apply(identity, t)) == accumulator.apply(u, t)
  
  これは終端操作です。
  
  APIのノート:
  
  この形式を使用するリダクションの多くは、map操作とreduce操作を明示的に組み合わせることで、より単純に表現することができます。 accumulator関数はマッパーとアキュ� レータを融合したものとして動作しますが、これは、以前のリデュース値がわかっていれば一部の計算を回避できる� �合など、マッピングとリダクションを個別に実行するよりも効率的になる� �合があります。
  
  型パラメータ:
  
  U - 結果のタイプ
  
  パラメータ:
  
  identity - コンバイナ関数に対する単位元の値
  
  accumulator - 追� の要� を結果に組み込むための、結合的、非干渉およびステートレスな関数
  
  combiner - 2つの値を結合するための結合的、非干渉およびステートレスな関数(アキュ� レータ関数と互換性がなければいけない)
  
  戻り値:
  
  リダクションの結果
  
  関連� �目:
  
  reduce(BinaryOperator)
  
  reduce(Object, BinaryOperator)
- gather
  default <R> Stream<R> gather(Gatherer<? super T, ?, R> gatherer)
  
  指定されたGathererをこのストリー� の要� に適用した結果で構成されるストリー� を返します。
  これは、「拡張点」である「ステートフル中間操作」です。
  Gatherersは柔軟性が高く、短絡および並列化をサポートし、ステートフル操作を多数記述できます。
  並列実行時には、複数の中間結果のインスタンス化、データ設定、およびマージが可能であるため、可変データ構� の隔離を維持できます。したがって、スレッドセーフでないデータ構� (ArrayListなど)で並列実行を行う� �合でも、並列リダクション用の同期を追� する必要はありません。
  実装は、連続した呼出しを検出し、単一の融合された操作に組み込むことができますが、必� �ではありません。これにより、次の最初の式が2番目の式のように動作します。
  var stream1 = Stream.of(...).gather(gatherer1).gather(gatherer2); var stream2 = Stream.of(...).gather(gatherer1.andThen(gatherer2));
  
  実装要件:
  
  デフォルトの実装では、このストリー� のspliteratorを取得し、そのスプリッタをラップしてトラバーサルに対するこの操作のセマンティクスをサポートし、ラップされたスプリッタに関連付けられた新しいストリー� を返します。戻されたストリー� は、このストリー� (BaseStream.isParallel()による並列実行または� �次実行)の実行特性を保持しますが、ラップされたスプリッタは分割をサポートしないことを選択できます。返されたストリー� が閉じられると、返されたストリー� とこのストリー� の両方のクローズ・ハンドラが起動されます。このインタフェースの実装では、このメソッドを独自に実装する必要があります。
  
  型パラメータ:
  
  R - 新しいストリー� の要� タイプ
  
  パラメータ:
  
  gatherer - ギャザラ
  
  戻り値:
  
  新しいストリー�
  
  導入されたバージョン:
  
  24
  
  関連� �目:
  
  Gatherers
- collect
  <R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R,R> combiner)
  
  このストリー� の要� に対して可変リダクション操作を実行します。可変リダクションとは、リデュース対象の値がArrayListのような可変の結果コンテナであり、結果を置き換えるかわりに結果の状態を更新することによって要� が組み込まれるようなリダクションのことです。これは次と同等の結果を生成します。
  R result = supplier.get(); for (T element : this stream) accumulator.accept(result, element); return result;
  
  collect操作はreduce(Object, BinaryOperator)と同様、同期を追� しなくても並列化できます。
  これは終端操作です。
  
  APIのノート:
  
  JDKには、collect()の引数(メソッド参照)での使用に適したシグネチャを持つ既存クラスが多数存在しています。たとえば次の� �合、文字列がArrayList内に蓄積されます。
  List<String> asList = stringStream.collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
  
  次の� �合、文字列のストリー� が受け取られ、それらが連結されて単一の文字列になります。
  String concat = stringStream.collect(StringBuilder::new, StringBuilder::append, StringBuilder::append) .toString();
  
  型パラメータ:
  
  R - 可変結果コンテナの型
  
  パラメータ:
  
  supplier - 新しい可変結果コンテナを作成する関数。並列実行の� �合、この関数は複数回呼び出される可能性がありますが、そのたびに新しい値を返す必要があります。
  
  accumulator - 結果コンテナに要� を折りたたむ必要があるassociative、non-interfering、statelessファンクション。
  
  combiner - 2つの部分的な結果コンテナを受け入れ、それらをマージするassociative、non-interfering、stateless関数。これは、累計関数と互換性がある必要があります。コンバイナ関数は、2番目の結果コンテナから1番目の結果コンテナに要� を折りたたむ必要があります。
  
  戻り値:
  
  リダクションの結果
- collect
  <R,A> R collect(Collector<? super T, A, R> collector)
  
  Collectorを使ってこのストリー� の要� に対する可変リダクション操作を実行します。 collect(Supplier, BiConsumer, BiConsumer)の引数として使用される関数をカプセル化したCollectorを使えば、コレクション方針の再利用やcollect操作の合成(マルチレベルのグループ化や分割など)が可能となります。
  ストリー� が並列的であり、Collectorが並行的であり、かつストリー� が� �序付けされていないかコレクタがunorderedである� �合、並行リダクションが実行されます(並行リダクションの詳細はCollectorを参照。)
  これは終端操作です。
  並列実行時には、複数の中間結果のインスタンス化、データ設定、およびマージが可能であるため、可変データ構� の隔離を維持できます。したがって、スレッドセーフでないデータ構� (ArrayListなど)で並列実行を行う� �合でも、並列リダクション用の同期を追� する必要はありません。
  
  APIのノート:
  
  次の例では、文字列をリストに蓄積します:
  List<String> asList = stringStream.collect(Collectors.toList());
  
  次の� �合、Personオブジェクトが市町村別に分類されます。
  Map<String, List<Person>> peopleByCity = personStream.collect(Collectors.groupingBy(Person::getCity));
  
  次の� �合、2つのCollectorをカスケード接続することにより、Personオブジェクトが都道府県別、市町村別に分類されます。
  Map<String, Map<String, List<Person>>> peopleByStateAndCity = personStream.collect(Collectors.groupingBy(Person::getState, Collectors.groupingBy(Person::getCity)));
  
  型パラメータ:
  
  R - 結果のタイプ
  
  A - Collectorの中間累積タイプ
  
  パラメータ:
  
  collector - リダクションを記述するCollector
  
  戻り値:
  
  リダクションの結果
  
  関連� �目:
  
  collect(Supplier, BiConsumer, BiConsumer)
  
  Collectors
- toList
  default List<T> toList()
  
  このストリー� の要� をListに蓄積します。リスト内の要� は、このストリー� 内に出現する� �序になります(存在する� �合)。返されるListは変更できません。ミューテータ・メソッドを呼び出すと、常にUnsupportedOperationExceptionがスローされます。返されるリストの実装タイプまたは直列化可能性については保証されません。
  返されるインスタンスはvalue-basedである可能性があります。呼び出し元は、返されたインスタンスのアイデンティティについて何も想定しないでく� さい。これらのインスタンスでのアイデンティティ依存の演算(参照等価(==)、アイデンティティ・ハッシュ・コードおよび同期)は信� �性が低いため、回避する必要があります。
  これは終端操作です。
  
  APIのノート:
  
  返されるオブジェクトをより細かく制御する必要がある� �合は、Collectors.toCollection(Supplier)を使用します。
  
  実装要件:
  
  このインタフェースの実装は、次のように生成されたListを返します:
  Collections.unmodifiableList(new ArrayList<>(Arrays.asList(this.toArray())))
  
  実装上のノート:
  
  Streamのほとんどのインスタンスはこのメソッドをオーバーライドし、このインタフェースの実装に比べて高度に最適化された実装を提供します。
  
  戻り値:
  
  ストリー� 要� を含むList
  
  導入されたバージョン:
  
  16
- min
  
  Optional<T> min(Comparator<? super T> comparator)
  
  指定されたComparatorに従ってこのストリー� の最小要� を返します。これはリダクションの特殊な� �合です。
  これは終端操作です。
  
  パラメータ:
  
  comparator - このストリー� の要� を比較する、非干渉でステートレスなComparator
  
  戻り値:
  
  このストリー� の最小要� を記述するOptionalまたは空のOptional (ストリー� が空の� �合)
  
  スロー:
  
  NullPointerException - 最小要� がnullの� �合
- max
  
  Optional<T> max(Comparator<? super T> comparator)
  
  指定されたComparatorに従ってこのストリー� の最大要� を返します。これはリダクションの特殊な� �合です。
  これは終端操作です。
  
  パラメータ:
  
  comparator - このストリー� の要� を比較する、非干渉でステートレスなComparator
  
  戻り値:
  
  このストリー� の最大要� を記述するOptionalまたは空のOptional (ストリー� が空の� �合)
  
  スロー:
  
  NullPointerException - 最大要� がnullの� �合
- count
  long count()
  
  このストリー� の要� の個数を返します。これはリダクションの特殊な� �合であり、次と同等になります。
  return mapToLong(e -> 1L).sum();
  
  これは終端操作です。
  
  APIのノート:
  
  実装では、ストリー� ・ソースから直接カウントを計算できる� �合、ストリー� ・パイプライン(連続的または並列的に)を実行しないことを選択できます。そのような� �合、ソース要� はトラバースされず、中間操作は評価されません。デバッグなどの無害なケースを除き、副作用のある行動パラメータが強く推奨されない� �合があります。たとえば、次のストリー� について考えてみます:
  List<String> l = Arrays.asList("A", "B", "C", "D"); long count = l.stream().peek(System.out::println).count();
  ストリー� ・ソースでカバーされる要� の数(List)が認識され、中間操作peekはストリー� (flatMapまたはfilter操作の� �合のように)に要� を注入または削除しません。したがって、カウントはListのサイズであり、パイプラインを実行する必要はなく、副作用としてリスト要� を出力します。
  
  戻り値:
  
  このストリー� の要� の個数
- anyMatch
  
  boolean anyMatch(Predicate<? super T> predicate)
  
  このストリー� のいずれかの要� が指定された述語に一致するかどうかを返します。すべての要� で述語を評価するとは限りません(結果を決定するのに必要でない� �合)。ストリー� が空の� �合、falseが返され、述語は評価されません。
  これは短絡終端操作です。
  
  APIのノート:
  
  このメソッドは、ストリー� の要� に対する述語の存在量化(あるxについてP(x))を評価します。
  
  パラメータ:
  
  predicate - ストリー� の要� に適用する非干渉でステートレスな述語
  
  戻り値:
  
  指定された述語に一致する要� がストリー� 内に存在する� �合はtrue、そうでない� �合はfalse
- allMatch
  
  boolean allMatch(Predicate<? super T> predicate)
  
  このストリー� のすべての要� が指定された述語に一致するかどうかを返します。すべての要� で述語を評価するとは限りません(結果を決定するのに必要でない� �合)。ストリー� が空の� �合、trueが返され、述語は評価されません。
  これは短絡終端操作です。
  
  APIのノート:
  
  このメソッドは、ストリー� の要� に対する述語の全称量化(すべてのxについてP(x))を評価します。ストリー� が空の� �合、量化は無意味に満たされると言い、(P(x)とは無関係に)常にtrueになります。
  
  パラメータ:
  
  predicate - ストリー� の要� に適用する非干渉でステートレスな述語
  
  戻り値:
  
  ストリー� のすべての要� が指定された述語に一致するかストリー� が空の� �合はtrue、それ以外の� �合はfalse
- noneMatch
  
  boolean noneMatch(Predicate<? super T> predicate)
  
  指定された述語に一致する要� がこのストリー� 内に存在しないかどうかを返します。すべての要� で述語を評価するとは限りません(結果を決定するのに必要でない� �合)。ストリー� が空の� �合、trueが返され、述語は評価されません。
  これは短絡終端操作です。
  
  APIのノート:
  
  このメソッドは、ストリー� の要� に対する述語の否定の全称量化(すべてのxについて~P(x))を評価します。ストリー� が空の� �合、量化は無意味に満たされると言い、P(x)とは無関係に常にtrueになります。
  
  パラメータ:
  
  predicate - ストリー� の要� に適用する非干渉でステートレスな述語
  
  戻り値:
  
  ストリー� のどの要� も指定された述語に一致しないかストリー� が空の� �合はtrue、それ以外の� �合はfalse
- findFirst
  
  Optional<T> findFirst()
  
  このストリー� の最初の要� を記述するOptionalを返します。ストリー� が空の� �合は空のOptionalを返します。ストリー� が検出� �序を持たない� �合は、任意の要� が返されます。
  これは短絡終端操作です。
  
  戻り値:
  
  このストリー� の最初の要� を記述するOptionalまたは空のOptional (ストリー� が空の� �合)
  
  スロー:
  
  NullPointerException - 選択された要� がnullの� �合
- findAny
  Optional<T> findAny()
  
  ストリー� の一部の要� を記述するOptionalを返します。ストリー� が空の� �合は空のOptionalを返します。
  これは短絡終端操作です。
  この操作の動作は明らかに非決定論的です。ストリー� の任意の要� を自由に選択できます。これは、並列処理でのパフォーマンスを最大化できるようにするためです。デメリットは、同じソースに対して呼び出すたびに、違う結果が返される可能性がある点です。 (安定した結果が必要な� �合は、かわりにfindFirst()を使用してく� さい。)
  
  戻り値:
  
  このストリー� のある要� を記述するOptionalまたは空のOptional (ストリー� が空の� �合)
  
  スロー:
  
  NullPointerException - 選択された要� がnullの� �合
  
  関連� �目:
  
  findFirst()
- builder
  
  static <T> Stream.Builder<T> builder()
  
  Streamのビルダーを返します。
  
  型パラメータ:
  
  T - 要� のタイプ
  
  戻り値:
  
  ストリー� ・ビルダー
- empty
  
  static <T> Stream<T> empty()
  
  空の� �次Streamを返します。
  
  型パラメータ:
  
  T - ストリー� 要� のタイプ
  
  戻り値:
  
  空の� �次ストリー�
- of
  
  static <T> Stream<T> of(T t)
  
  単一要� を含む� �次Streamを返します。
  
  型パラメータ:
  
  T - ストリー� 要� のタイプ
  
  パラメータ:
  
  t - 単一要�
  
  戻り値:
  
  単一要� の� �次ストリー�
- ofNullable
  
  static <T> Stream<T> ofNullable(T t)
  
  単一の要� を含む� �次Streamを返します(null以外の� �合)。それ以外の� �合は空のStreamを返します。
  
  型パラメータ:
  
  T - ストリー� 要� のタイプ
  
  パラメータ:
  
  t - 単一要�
  
  戻り値:
  
  指定された要� がnull以外の� �合は単一の要� を持つストリー� 、それ以外の� �合は空のストリー�
  
  導入されたバージョン:
  
  9
- of
  
  @SafeVarargs static <T> Stream<T> of(T... values)
  
  指定された値を要� に持つ、� �序付けされた� �次ストリー� を返します。
  
  型パラメータ:
  
  T - ストリー� 要� のタイプ
  
  パラメータ:
  
  values - 新しいストリー� の要�
  
  戻り値:
  
  新しいストリー�
- iterate
  
  static <T> Stream<T> iterate(T seed, UnaryOperator<T> f)
  
  初期要� seedに関数fを繰り返し適用することで生成される、� �序付けされた無限� �次Streamを返します(seed、f(seed)、f(f(seed))、といった要� から成るStreamが生成される)。
  Streamの最初の要� (位置0)は、指定されたseedになります。 n > 0の� �合、位置nの要� は、位置n - 1の要� に関数fを適用した結果になります。
  1つの要� happens-beforeにfを適用するアクション(後続の要� にfを適用するアクション)。どの要� に対しても、ライブラリが選択するどのスレッドでもアクションを実行できます。
  
  型パラメータ:
  
  T - ストリー� 要� のタイプ
  
  パラメータ:
  
  seed - 初期要�
  
  f - 新しい要� を生成するために前の要� に適用される関数
  
  戻り値:
  
  新しい� �次Stream
- iterate
  static <T> Stream<T> iterate(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next)
  
  指定されたnextファンクションの反復適用によって生成された� �次� �序付けされたStreamを、指定されたhasNext述語を満たす条件付き初期要� に戻します。ストリー� は、hasNext述語がfalseを返すとすぐに終了します。
  Stream.iterateは、対応するforループによって生成されるものと同じシーケンスを生成する必要があります:
  for (T index=seed; hasNext.test(index); index = next.apply(index)) { ... }
  
  hasNext述語がシード値を保持しない� �合、結果のシーケンスは空になることがあります。それ以外の� �合、最初の要� が指定のseed値になり、次の要� (存在する� �合)は、next関数をseed値に適用した結果になります。また、hasNext述語がストリー� を終了する必要があることを示すまで反復的に行われます。
  hasNext述語を要� happens-beforeに適用するアクション(その要� にnext関数を適用するアクション)。 1つの要� happens-beforeにnext関数を適用するアクション(後続の要� にhasNext述語を適用するアクション)。どの要� に対しても、ライブラリが選択するどのスレッドでもアクションを実行できます。
  
  型パラメータ:
  
  T - ストリー� 要� のタイプ
  
  パラメータ:
  
  seed - 初期要�
  
  hasNext - ストリー� を終了する必要があるタイミングを決定するために要� に適用する述語。
  
  next - 新しい要� を生成するために前の要� に適用される関数
  
  戻り値:
  
  新しい� �次Stream
  
  導入されたバージョン:
  
  9
- generate
  
  static <T> Stream<T> generate(Supplier<? extends T> s)
  
  指定されたSupplierによって生成される要� を含む、� �序付けされていない無限� �次ストリー� を返します。これは、定数ストリー� やランダ� な要� から成るストリー� などを生成するのに適しています。
  
  型パラメータ:
  
  T - ストリー� 要� のタイプ
  
  パラメータ:
  
  s - 生成される要� のSupplier
  
  戻り値:
  
  � �序付けされていない新しい無限� �次Stream
- concat
  static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
  
  最初のストリー� の全要� と2番目のストリー� の全要� を連結したものを要� に持つ、遅延連結ストリー� を作成します。結果のストリー� が� �序付けされるのは、入力ストリー� がどちらも� �序付けされている� �合であり、並列的になるのは、入力ストリー� のどちらかが並列的な� �合です。結果のストリー� のクローズ時には、両方の入力ストリー� のクローズ・ハンドラが呼び出されます。
  このメソッドは2つの入力ストリー� で動作し、各ストリー� をそのソースにバインドします。その結果、入力ストリー� ・ソースへのその後の変更は、連結ストリー� 結果に反� されないことがあります。
  
  APIのノート:
  
  最適化の機会を保持するために、このメソッドは各ストリー� をそのソースにバインドし、パラメータとして2つのストリー� のみを受け入れます。例えば、各入力ストリー� ・ソースの正確なサイズが分かっている� �合、連結ストリー� ・ソースの正確なサイズを計算することができます。バインディングなしでストリー� を連結する� �合、またはこのメソッドへのネストされた呼び出しを行わない� �合は、ストリー� のストリー� を作成し、アイデンティティ関数を使用してフラット・マッピングしてみてく� さい:
  Stream<T> concat = Stream.of(s1, s2, s3, s4).flatMap(s -> s);
  
  実装上のノート:
  
  連結を繰り返すことでストリー� を構築する際には注意が必要です。深く連結されたストリー� の要� にアクセスすると、ディープ・コール・チェーンまたはStackOverflowErrorが発生する可能性があります。
  戻されたストリー� の� �次/パラレル実行モードに対する後続の変更は、入力ストリー� に伝播されることは保証されません。
  
  型パラメータ:
  
  T - ストリー� 要� のタイプ
  
  パラメータ:
  
  a - 最初のストリー�
  
  b - 2番目のストリー�
  
  戻り値:
  
  2つの入力ストリー� を連結したもの

インタフェースStream<T>

ネストされたクラスのサマリー

メソッドのサマリー

インタフェースjava.util.stream.BaseStreamで宣言されたメソッド

メソッドの詳細

filter

map

mapToInt

mapToLong

mapToDouble

flatMap

flatMapToInt

flatMapToLong

flatMapToDouble

mapMulti

mapMultiToInt

mapMultiToLong

mapMultiToDouble

distinct

sorted

sorted

peek

limit

skip

takeWhile

dropWhile

forEach

forEachOrdered

toArray

toArray

reduce

reduce

reduce

gather

collect

collect

toList

min

max

count

anyMatch

allMatch

noneMatch

findFirst

findAny

builder

empty

of

ofNullable

of

iterate

iterate

generate

concat