📢 Alert: javase/jp//docs/api/java/util/stream/Stream.html

型パラメータ:

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)など、結果または副作用を生成する操作)から構成されます。ストリームは遅延処理されます。ソース・データに対する計算は終端操作が起動されるまで実行されず、ソース要素も必要なだけしか消費されません。
コレクションとストリームは、表面上似た点があるものの、異なる目的を持っています。コレクションは主に、要素の効率的な管理やアクセスに注力しています。これに対し、ストリームは要素の直接アクセスや操作の手段を持たず、代わりにソースやそのソースに対して集約的に実行される計算操作を宣言的に記述することに注力しています。ただし、用意されたストリーム操作が必要な機能を提供しない場合には、BaseStream.iterator()およびBaseStream.spliterator()操作を使って制御されたトラバーサルを実行することもできます。
ストリーム・パイプラインは、上の「widgets」の例のように、ストリーム・ソースに対する問合せとみなすことができます。ソースが明示的に同時変更向けに設計されたもの(ConcurrentHashMapなど)でないかぎり、ストリームのソースを照会中に変更すると、予測不可能な動作や間違った動作が発生する可能性があります。
ほとんどのストリーム操作は、上の例でmapToIntに渡されたラムダ式w -> w.getWeight()のような、ユーザー指定の動作を記述するパラメータを受け取ります。正しい動作を維持するには、これらの動作パラメータは次を満たす必要があります。
- 非干渉でなければいけない(ストリームのソースを変更しない)、および
- ほとんどの場合、ステートレスでなければいけない(その結果は、ストリーム・パイプラインの実行中に変化する可能性のあるどの状態にも依存すべきでない)。
そのようなパラメータは常に関数型インタフェース(Functionなど)のインスタンスであり、通常はラムダ式やメソッド参照になります。特に明記されていないかぎり、これらのパラメータはnull以外でなければいけません。
(中間または終端ストリーム操作を呼び出して)ストリームを操作するのは、一度だけにすべきです。このため、たとえば同じソースが2つ以上のパイプラインに対してデータを供給する「フォークされた」ストリームや、同じストリームを複数回トラバースすることなどは、禁止されます。ストリーム実装は、ストリームが再利用されているのを検出すると、IllegalStateExceptionをスローします。ただし、一部のストリーム操作からは新しいストリーム・オブジェクトではなくレシーバが返されることがあるため、場合によっては再利用を検出できない可能性があります。
ストリームはBaseStream.close()メソッドを持ち、AutoCloseableを実装していますが、ほとんどすべてのストリーム・インスタンスは、実際には使用後にクローズする必要はありません。一般に、クローズが必要になるのは、入出力チャネルをソースに持つストリーム(Files.lines(Path, Charset)から返されるものなど)だけです。大部分のストリームの背後に存在しているのは、コレクション、配列、または生成関数なので、特別なリソース管理を行う必要はありません。 (クローズが必要なストリームは、try-with-resources文のリソースとして宣言できます。)
ストリーム・パイプラインは順次、並列のいずれかで実行できます。この実行モードは、ストリームのプロパティの1つです。ストリームの作成時には、順次実行または並列実行の初期選択が行われます。 (たとえば、Collection.stream()では順次ストリームが作成され、Collection.parallelStream()では並列ストリームが作成されます。) この実行モードの選択を変更するにはBaseStream.sequential()またはBaseStream.parallel()メソッドを使用し、実行モードを照会するにはBaseStream.isParallel()メソッドを使用します。
導入されたバージョン:

1.8

関連項目:

IntStream, LongStream, DoubleStream, java.util.stream

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

ネストされたクラス
修飾子と型インタフェース説明

static interface Stream.Builder<T>
Streamの可変ビルダーです。

ネストされたクラス
修飾子と型	インタフェース	説明
`static interface`	`Stream.Builder<T>`	`Stream`の可変ビルダーです。

メソッドのサマリー

すべてのメソッド staticメソッドインスタンス・メソッド抽象メソッドデフォルト・メソッド
修飾子と型	メソッド	説明
`boolean`	`allMatch(Predicate<? super T> predicate)`	このストリームのすべての要素が指定された述語に一致するかどうかを返します。
`boolean`	`anyMatch(Predicate<? super T> predicate)`	このストリームのいずれかの要素が指定された述語に一致するかどうかを返します。
`static <T> Stream.Builder<T>`	`builder()`	`Stream`のビルダーを返します。
`<R,A> R`	`collect(Collector<? super T,A,R> collector)`	`Collector`を使ってこのストリームの要素に対する可変リダクション操作を実行します。
`<R> R`	`collect(Supplier<R> supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner)`	このストリームの要素に対して可変リダクション操作を実行します。
`static <T> Stream<T>`	`concat(Stream<? extends T> a, Stream<? extends T> b)`	最初のストリームの全要素と2番目のストリームの全要素を連結したものを要素に持つ、遅延連結ストリームを作成します。
`long`	`count()`	このストリームの要素の個数を返します。
`Stream<T>`	`distinct()`	このストリームの重複を除いた要素(`Object.equals(Object)`による)から構成されるストリームを返します。
`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)`	このストリームの各要素に対してアクションを実行します。その実行順は、ストリームの検出順が定義されている場合はその順番になります。
`static <T> Stream<T>`	`generate(Supplier<T> s)`	指定された`Supplier`によって生成される要素を含む、順序付けされていない無限順次ストリームを返します。
`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)`	このストリームの要素に指定された関数を適用した結果から構成されるストリームを返します。
`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... values)`	指定された値を要素に持つ、順序付けされた順次ストリームを返します。
`static <T> Stream<T>`	`of(T t)`	単一要素を含む順次`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`に従ってソートした結果から構成されるストリームを返します。
`Object[]`	`toArray()`	このストリームの要素を含む配列を返します。
`<A> A[]`	`toArray(IntFunction<A[]> generator)`	指定された`generator`関数を使用して、このストリームの要素を含む配列を返し、返された配列と、パーティション化された実行またはサイズ変更に必要となる可能性のある追加の配列を割り当てます。

インタフェース 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 - 新しい値のストリームを生成するために各要素に適用する、非干渉でステートレスな関数
    
    戻り値:
    
    新しいストリーム
  - flatMapToInt
```
IntStream flatMapToInt(Function<? super T,? extends IntStream> mapper)
```
    このストリームの各要素をマップされたストリーム(指定されたマッピング関数を各要素に適用することで得られる)の内容で置き換えた結果から成るIntStreamを返します。各マップ先ストリームは、その内容がこのストリーム内に配置されるとクローズされます。 (マップ先ストリームがnullの場合はかわりに空のストリームが使用されます。)
    これは中間操作です。
    
    パラメータ:
    
    mapper - 新しい値のストリームを生成するために各要素に適用する、非干渉でステートレスな関数
    
    戻り値:
    
    新しいストリーム
    
    関連項目:
    
    flatMap(Function)
  - flatMapToLong
```
LongStream flatMapToLong(Function<? super T,? extends LongStream> mapper)
```
    このストリームの各要素をマップされたストリーム(指定されたマッピング関数を各要素に適用することで得られる)の内容で置き換えた結果から成るLongStreamを返します。各マップ先ストリームは、その内容がこのストリーム内に配置されるとクローズされます。 (マップ先ストリームがnullの場合はかわりに空のストリームが使用されます。)
    これは中間操作です。
    
    パラメータ:
    
    mapper - 新しい値のストリームを生成するために各要素に適用する、非干渉でステートレスな関数
    
    戻り値:
    
    新しいストリーム
    
    関連項目:
    
    flatMap(Function)
  - flatMapToDouble
```
DoubleStream flatMapToDouble(Function<? super T,? extends DoubleStream> mapper)
```
    このストリームの各要素を、その要素に指定されたマッピング関数を適用することによって生成されるマップ先ストリームの内容で置き換えた結果から構成されるDoubleStreamを返します。各マップ先ストリームは、その内容がこのストリーム内に配置されるとクローズされます。 (マップ先ストリームがnullの場合はかわりに空のストリームが使用されます。)
    これは中間操作です。
    
    パラメータ:
    
    mapper - 新しい値のストリームを生成するために各要素に適用する、非干渉でステートレスな関数
    
    戻り値:
    
    新しいストリーム
    
    関連項目:
    
    flatMap(Function)
  - 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());
    パラメータ:
    
    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が負の場合
  - forEach
```
void forEach(Consumer<? super T> action)
```
    このストリームの各要素に対してアクションを実行します。
    これは終端操作です。
    この操作の動作は明らかに非決定論的です。並列ストリーム・パイプラインの場合、この操作は、ストリームの検出順序を考慮することを保証しません。保証すると並列性のメリットが犠牲になるからです。与えられた任意の要素に対し、ライブラリが選択した任意のタイミングで任意のスレッド内でアクションが実行される可能性があります。アクションが共有状態にアクセスする場合、必要な同期を提供する責任はアクションにあります。
    
    パラメータ:
    
    action - 要素に対して実行する非干渉アクション
  - forEachOrdered
```
void forEachOrdered(Consumer<? super T> action)
```
    このストリームの各要素に対してアクションを実行します。その実行順は、ストリームの検出順が定義されている場合はその順番になります。
    これは終端操作です。
    この操作は、検出順序が存在する場合はその順序で、要素を一度に1つずつ処理します。ある要素のアクション実行はその後続要素のアクション実行よりも前に発生しますが、どの要素についても、ライブラリが選択した任意のスレッド内でアクションが実行される可能性があります。
    
    パラメータ:
    
    action - 要素に対して実行する非干渉アクション
    
    関連項目:
    
    forEach(Consumer)
  - toArray
```
Object[] toArray()
```
    このストリームの要素を含む配列を返します。
    これは終端操作です。
    
    戻り値:
    
    このストリームの要素を含む配列
  - 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)
  - 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 - 追加の要素を結果に組み込むための、結合的、非干渉およびステートレスな関数
    
    combiner - 2つの値を結合するための結合的、非干渉およびステートレスな関数(アキュムレータ関数と互換性がなければいけない)
    
    戻り値:
    
    リダクションの結果
  - collect
```
<R,A> R collect(Collector<? super T,A,R> collector)
```
    Collectorを使ってこのストリームの要素に対する可変リダクション操作を実行します。 collect(Supplier, BiConsumer, BiConsumer)の引数として使用される関数をカプセル化したCollectorを使えば、コレクション方針の再利用やcollect操作の合成(マルチレベルのグループ化や分割など)が可能となります。
    ストリームが並列的であり、Collectorが並行的であり、かつストリームが順序付けされていないかコレクタがunorderedである場合、並行リダクションが実行されます(並行リダクションの詳細はCollectorを参照。)
    これは終端操作です。
    並列実行時には、複数の中間結果のインスタンス化、データ設定、およびマージが可能であるため、可変データ構造の隔離を維持できます。したがって、スレッドセーフでないデータ構造(ArrayListなど)で並列実行を行う場合でも、並列リダクション用の同期を追加する必要はありません。
    APIのノート:
    次の場合、文字列がArrayList内に蓄積されます。
    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
  - 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();
 
```
    これは終端操作です。
    戻り値:
    
    このストリームの要素の個数
  - 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 - 単一要素
    
    戻り値:
    
    単一要素の順次ストリーム
  - 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を適用した結果になります。
    
    型パラメータ:
    
    T - ストリーム要素の型
    
    パラメータ:
    
    seed - 初期要素
    
    f - 新しい要素を生成するために1つ前の要素に適用される関数
    
    戻り値:
    
    新しい順次Stream
  - generate
```
static <T> Stream<T> generate(Supplier<T> s)
```
    指定されたSupplierによって生成される要素を含む、順序付けされていない無限順次ストリームを返します。これは、定数ストリームやランダムな要素から成るストリームなどを生成するのに適しています。
    
    型パラメータ:
    
    T - ストリーム要素の型
    
    パラメータ:
    
    s - 生成される要素のSupplier
    
    戻り値:
    
    順序付けされていない新しい無限順次Stream
  - concat
```
static <T> Stream<T> concat(Stream<? extends T> a,
                            Stream<? extends T> b)
```
    最初のストリームの全要素と2番目のストリームの全要素を連結したものを要素に持つ、遅延連結ストリームを作成します。結果のストリームが順序付けされるのは、入力ストリームがどちらも順序付けされている場合であり、並列的になるのは、入力ストリームのどちらかが並列的な場合です。結果のストリームのクローズ時には、両方の入力ストリームのクローズ・ハンドラが呼び出されます。
    
    実装上のノート:
    
    連結を繰り返すことでストリームを構築する際には注意が必要です。連結レベルが深いストリームの要素にアクセスした場合、深い呼出しチェーンが発生する可能性があるほか、StackOverflowExceptionが発行される可能性さえあります。
    
    型パラメータ:
    
    T - ストリーム要素の型
    
    パラメータ:
    
    a - 最初のストリーム
    
    b - 2番目のストリーム
    
    戻り値:
    
    2つの入力ストリームを連結したもの

バグまたは機能を送信
詳細なAPIリファレンスおよび開発者ドキュメントについては、Java SEのドキュメントを参照してください。そのドキュメントには、概念的な概要、用語の定義、回避方法、有効なコード例などの、開発者を対象にしたより詳細な説明が含まれています。
Copyright © 1993, 2025, Oracle and/or its affiliates. All rights reserved. Use is subject to license terms. Documentation Redistribution Policyも参照してください。

インタフェースStream<T>

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

メソッドのサマリー

インタフェース java.util.stream.BaseStreamから継承されたメソッド

メソッドの詳細

filter

map

mapToInt

mapToLong

mapToDouble

flatMap

flatMapToInt

flatMapToLong

flatMapToDouble

distinct

sorted

sorted

peek

limit

skip

forEach

forEachOrdered

toArray

toArray

reduce

reduce

reduce

collect

collect

min

max

count

anyMatch

allMatch

noneMatch

findFirst

findAny

builder

empty

of

of

iterate

generate

concat