java.lang.Object

java.util.stream.Collectors

public final class Collectors extends Object

要� をコレクションに蓄積したり、さまざまな条件に従って要� を要約するなど、有用な各種リダクション操作を実装したCollector実装。

定義済のコレクタを使って一般的な可変リダクション・タスクを実行する例を、次に示します。


 // Accumulate names into a List
 List<String> list = people.stream()
   .map(Person::getName)
   .collect(Collectors.toList());

 // Accumulate names into a TreeSet
 Set<String> set = people.stream()
   .map(Person::getName)
   .collect(Collectors.toCollection(TreeSet::new));

 // Convert elements to strings and concatenate them, separated by commas
 String joined = things.stream()
   .map(Object::toString)
   .collect(Collectors.joining(", "));

 // Compute sum of salaries of employee
 int total = employees.stream()
   .collect(Collectors.summingInt(Employee::getSalary));

 // Group employees by department
 Map<Department, List<Employee>> byDept = employees.stream()
   .collect(Collectors.groupingBy(Employee::getDepartment));

 // Compute sum of salaries by department
 Map<Department, Integer> totalByDept = employees.stream()
   .collect(Collectors.groupingBy(Employee::getDepartment,
                                  Collectors.summingInt(Employee::getSalary)));

 // Partition students into passing and failing
 Map<Boolean, List<Student>> passingFailing = students.stream()
   .collect(Collectors.partitioningBy(s -> s.getGrade() >= PASS_THRESHOLD));

導入されたバージョン:: 1.8

メソッドのサマリー

修飾子と型

メソッド

説明

static <T> Collector<T,?,Double>

averagingDouble(ToDoubleFunction<? super T> mapper)

入力要� にdouble値関数を適用した結果の算術平均を生成するCollectorを返します。

static <T> Collector<T,?,Double>

averagingInt(ToIntFunction<? super T> mapper)

入力要� にint値関数を適用した結果の算術平均を生成するCollectorを返します。

static <T> Collector<T,?,Double>

averagingLong(ToLongFunction<? super T> mapper)

入力要� にlong値関数を適用した結果の算術平均を生成するCollectorを返します。

static <T,A,R,RR> Collector<T,A,RR>

collectingAndThen(Collector<T,A,R> downstream, Function<R,RR> finisher)

追� の仕上げ変換が実行されるようにCollectorを適応させます。

static <T> Collector<T,?,Long>

counting()

T型の要� を受け入れて、入力要� の数をカウントする、Collectorを返します。

static <T,A,R> Collector<T,?,R>

filtering(Predicate<? super T> predicate, Collector<? super T, A, R> downstream)

述語を各入力要� に適用し、述語がtrueを返す� �合にのみ累積することによって、Collectorを同じ型の要� Tを受け入れる要� に適合させます。

static <T,U,A,R> Collector<T,?,R>

flatMapping(Function<? super T, ? extends Stream<? extends U>> mapper, Collector<? super U, A, R> downstream)

蓄積前に各入力要� にフラット・マッピング関数を適用することにより、U型の要� を受け入れるCollectorを、T型の要� を受け入れる1つの要� に適応させます。

static <T,K> Collector<T, ?, Map<K,List<T>>>

groupingBy(Function<? super T, ? extends K> classifier)

分類関数に従って要� をグループ化し、結果をMapに� �納して返す、T型の入力要� に対する「グループ化」操作を実装したCollectorを返します。

static <T, K, D, A, M extends Map<K,D>> Collector<T,?,M>

groupingBy(Function<? super T, ? extends K> classifier, Supplier<M> mapFactory, Collector<? super T, A, D> downstream)

分類関数に従って要� をグループ化した後、指定された下流Collectorを使って特定のキーに関連付けられた値のリダクション操作を実行する、T型の入力要� に対するカスケード「グループ化」操作を実装したCollectorを返します。

static <T,K,A,D> Collector<T,?,Map<K,D>>

groupingBy(Function<? super T, ? extends K> classifier, Collector<? super T, A, D> downstream)

分類関数に従って要� をグループ化した後、指定された下流Collectorを使って特定のキーに関連付けられた値のリダクション操作を実行する、T型の入力要� に対するカスケード「グループ化」操作を実装したCollectorを返します。

static <T,K> Collector<T, ?, ConcurrentMap<K,List<T>>>

groupingByConcurrent(Function<? super T, ? extends K> classifier)

分類関数に従って要� をグループ化する、T型の入力要� に対する「グループ化」操作を実装した並行Collectorを返します。

static <T, K, A, D, M extends ConcurrentMap<K,D>> Collector<T,?,M>

groupingByConcurrent(Function<? super T, ? extends K> classifier, Supplier<M> mapFactory, Collector<? super T, A, D> downstream)

分類関数に従って要� をグループ化した後、指定された下流Collectorを使って特定のキーに関連付けられた値のリダクション操作を実行する、T型の入力要� に対するカスケード「グループ化」操作を実装した並行Collectorを返します。

static <T,K,A,D> Collector<T, ?, ConcurrentMap<K,D>>

groupingByConcurrent(Function<? super T, ? extends K> classifier, Collector<? super T, A, D> downstream)

分類関数に従って要� をグループ化した後、指定された下流Collectorを使って特定のキーに関連付けられた値のリダクション操作を実行する、T型の入力要� に対するカスケード「グループ化」操作を実装した並行Collectorを返します。

static Collector<CharSequence, ?, String>

joining()

入力要� を検出� �に連結して1つのStringにするCollectorを返します。

static Collector<CharSequence, ?, String>

joining(CharSequence delimiter)

入力要� を検出� �に指定された区切り文字で区切りながら連結するCollectorを返します。

static Collector<CharSequence, ?, String>

joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)

入力要� を検出� �に指定された区切り文字で区切りながら連結し、指定された接� �辞と接尾辞を付� するCollectorを返します。

static <T,U,A,R> Collector<T,?,R>

mapping(Function<? super T, ? extends U> mapper, Collector<? super U, A, R> downstream)

U型の要� を受け取るCollectorがT型の要� を受け取れるように適応させるため、各入力要� にマッピング関数を適用した後で蓄積を行うようにします。

static <T> Collector<T, ?, Optional<T>>

maxBy(Comparator<? super T> comparator)

指定されたComparatorに従ってOptional<T>として記述された最大要� を生成するCollectorを返します。

static <T> Collector<T, ?, Optional<T>>

minBy(Comparator<? super T> comparator)

指定されたComparatorに従ってOptional<T>として記述された最小要� を生成するCollectorを返します。

static <T> Collector<T, ?, Map<Boolean,List<T>>>

partitioningBy(Predicate<? super T> predicate)

Predicateに従って入力要� を分割し、結果をMap<Boolean, List<T>>内に� �納するCollectorを返します。

static <T,D,A> Collector<T, ?, Map<Boolean,D>>

partitioningBy(Predicate<? super T> predicate, Collector<? super T, A, D> downstream)

Predicateに従って入力要� を分割し、別のCollectorに従って各パーティションの値をリデュースし、結果をMap<Boolean, D>内に� �納するCollectorを返します(下流のリダクションの結果がマップの値になる)。

static <T> Collector<T, ?, Optional<T>>

reducing(BinaryOperator<T> op)

指定されたBinaryOperatorの下で入力要� のリダクションを実行するCollectorを返します。

static <T> Collector<T,?,T>

reducing(T identity, BinaryOperator<T> op)

指定されたBinaryOperatorの下で指定された単位元を使って入力要� のリダクションを実行するCollectorを返します。

static <T,U> Collector<T,?,U>

reducing(U identity, Function<? super T, ? extends U> mapper, BinaryOperator op)

指定されたマッピング関数とBinaryOperatorの下で入力要� のリダクションを実行するCollectorを返します。

static <T> Collector<T, ?, DoubleSummaryStatistics>

summarizingDouble(ToDoubleFunction<? super T> mapper)

各入力要� にdouble生成マッピング関数を適用し、その結果の値のサマリー統計を返すCollectorを返します。

static <T> Collector<T, ?, IntSummaryStatistics>

summarizingInt(ToIntFunction<? super T> mapper)

各入力要� にint生成マッピング関数を適用し、その結果の値のサマリー統計を返すCollectorを返します。

static <T> Collector<T, ?, LongSummaryStatistics>

summarizingLong(ToLongFunction<? super T> mapper)

各入力要� にlong生成マッピング関数を適用し、その結果の値のサマリー統計を返すCollectorを返します。

static <T> Collector<T,?,Double>

summingDouble(ToDoubleFunction<? super T> mapper)

入力要� に適用されたdouble値関数の合計を生成するCollectorを返します。

static <T> Collector<T,?,Integer>

summingInt(ToIntFunction<? super T> mapper)

入力要� に適用される整数値関数の合計を生成するCollectorを返します。

static <T> Collector<T,?,Long>

summingLong(ToLongFunction<? super T> mapper)

入力要� に適用されたlong値関数の合計を生成するCollectorを返します。

static <T,R1,R2,R> Collector<T,?,R>

teeing(Collector<? super T, ?, R1> downstream1, Collector<? super T, ?, R2> downstream2, BiFunction<? super R1, ? super R2, R> merger)

2つのダウンストリー� ・コレクタのコンポジットであるCollectorを返します。

static <T, C extends Collection<T>> Collector<T,?,C>

toCollection(Supplier<C> collectionFactory)

入力要� を検出� �に新しいCollectionに蓄積するCollectorを返します。

static <T,K,U> Collector<T, ?, ConcurrentMap<K,U>>

toConcurrentMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper)

ConcurrentMap内に要� を累積する並行Collectorを返します(指定されたマッピング関数を入力要� に適用した結果が、マップのキーと値になる)。

static <T,K,U> Collector<T, ?, ConcurrentMap<K,U>>

toConcurrentMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator mergeFunction)

ConcurrentMap内に要� を累積する並行Collectorを返します(指定されたマッピング関数を入力要� に適用した結果が、マップのキーと値になる)。

static <T, K, U, M extends ConcurrentMap<K,U>> Collector<T,?,M>

toConcurrentMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator mergeFunction, Supplier<M> mapFactory)

ConcurrentMap内に要� を累積する並行Collectorを返します(指定されたマッピング関数を入力要� に適用した結果が、マップのキーと値になる)。

static <T> Collector<T,?,List<T>>

toList()

入力要� を新しいListに蓄積するCollectorを返します。

static <T,K,U> Collector<T,?,Map<K,U>>

toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper)

Map(そのキーと値は指定されたマッピング関数を入力要� に適用した結果である)内に要� を蓄積するCollectorを返します。

static <T,K,U> Collector<T,?,Map<K,U>>

toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator mergeFunction)

Map(そのキーと値は指定されたマッピング関数を入力要� に適用した結果である)内に要� を蓄積するCollectorを返します。

static <T, K, U, M extends Map<K,U>> Collector<T,?,M>

toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator mergeFunction, Supplier<M> mapFactory)

Map(そのキーと値は指定されたマッピング関数を入力要� に適用した結果である)内に要� を蓄積するCollectorを返します。

static <T> Collector<T,?,Set<T>>

toSet()

入力要� を新しいSetに蓄積するCollectorを返します。

static <T> Collector<T,?,List<T>>

toUnmodifiableList()

Collectorを返します。これは入力エレメントを「変更不可能なList」に遭遇� �序で累積します。

static <T,K,U> Collector<T,?,Map<K,U>>

toUnmodifiableMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper)

入力要� を「変更不可能なMap」に累計するCollectorを返します。このキーと値は、指定されたマッピング関数を入力要� に適用した結果です。

static <T,K,U> Collector<T,?,Map<K,U>>

toUnmodifiableMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator mergeFunction)

入力要� を「変更不可能なMap」に累計するCollectorを返します。このキーと値は、指定されたマッピング関数を入力要� に適用した結果です。

static <T> Collector<T,?,Set<T>>

toUnmodifiableSet()

入力要� を「変更不可能なSet」に累計するCollectorを返します。

クラスjava.lang.Objectで宣言されたメソッド
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

メソッドの詳細
- toCollection
 
 public static <T, C extends Collection<T>> Collector<T,?,C> toCollection(Supplier<C> collectionFactory)
 
 入力要� を検出� �に新しいCollectionに蓄積するCollectorを返します。 Collectionは指定されたファクトリによって作成されます。
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 C - 結果のCollectionのタイプ
 
 パラメータ:
 
 collectionFactory - 結果が挿入される新しい空のCollectionを提供するサプライヤ
 
 戻り値:
 
 すべての入力要� を検出� �にCollection内に集めるCollector
- toList
 
 public static <T> Collector<T,?,List<T>> toList()
 
 入力要� を新しいListに蓄積するCollectorを返します。返されるListの型、可変性、直列化可能性、またはスレッド安全性は一切保証されません。返されるListをより細かく制御する必要がある� �合は、toCollection(Supplier)を使用してく� さい。
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 戻り値:
 
 すべての入力要� を検出� �にList内に集めるCollector
- toUnmodifiableList
 
 public static <T> Collector<T,?,List<T>> toUnmodifiableList()
 
 Collectorを返します。これは入力エレメントを「変更不可能なList」に遭遇� �序で累積します。返されたコレクタはnull値を許可しません。また、null値が指定されている� �合はNullPointerExceptionをスローします。
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 戻り値:
 
 Collectorは入力エレメントをエン・カウンタ・オーダーで「変更不可能なList」に蓄積
 
 導入されたバージョン:
 
 10
- toSet
 
 public static <T> Collector<T,?,Set<T>> toSet()
 
 入力要� を新しいSetに蓄積するCollectorを返します。返されるSetの型、可変性、直列化可能性、またはスレッド安全性は一切保証されません。返されるSetをより細かく制御する必要がある� �合は、toCollection(Supplier)を使用してく� さい。
 これは、� �序付けされていないCollectorです。
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 戻り値:
 
 すべての入力要� をSet内に集めるCollector
- toUnmodifiableSet
 
 public static <T> Collector<T,?,Set<T>> toUnmodifiableSet()
 
 入力要� を「変更不可能なSet」に累計するCollectorを返します。返されたコレクタはnull値を許可しません。また、null値が指定されている� �合はNullPointerExceptionをスローします。入力に重複要� が含まれている� �合、重複要� の任意の要� が保持されます。
 これは、� �序付けされていないCollectorです。
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 戻り値:
 
 入力要� を「変更不可能なSet」に蓄積するCollector
 
 導入されたバージョン:
 
 10
- joining
 
 public static Collector<CharSequence, ?, String> joining()
 
 入力要� を検出� �に連結して1つのStringにするCollectorを返します。
 
 戻り値:
 
 入力要� を検出� �に連結して1つのStringにするCollector
- joining
 
 public static Collector<CharSequence, ?, String> joining(CharSequence delimiter)
 
 入力要� を検出� �に指定された区切り文字で区切りながら連結するCollectorを返します。
 
 パラメータ:
 
 delimiter - 各要� 間で使用される区切り文字
 
 戻り値:
 
 CharSequence要� を検出� �に指定された区切り文字で区切りながら連結するCollector
- joining
 
 public static Collector<CharSequence, ?, String> joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)
 
 入力要� を検出� �に指定された区切り文字で区切りながら連結し、指定された接� �辞と接尾辞を付� するCollectorを返します。
 
 パラメータ:
 
 delimiter - 各要� 間で使用される区切り文字
 
 prefix - 連結結果の先� �で使用される文字シーケンス
 
 suffix - 連結結果の末尾で使用される文字シーケンス
 
 戻り値:
 
 CharSequence要� を検出� �に指定された区切り文字で区切りながら連結するCollector
- mapping
 public static <T,U,A,R> Collector<T,?,R> mapping(Function<? super T, ? extends U> mapper, Collector<? super U, A, R> downstream)
 
 U型の要� を受け取るCollectorがT型の要� を受け取れるように適応させるため、各入力要� にマッピング関数を適用した後で蓄積を行うようにします。
 
 APIのノート:
 
 mapping()コレクタがもっとも役に立つのは、複数レベルのリダクション(groupingByまたはpartitioningByの下流など)で使用する� �合です。たとえば、特定のPersonストリー� について、市町村ごとに名前のセットを蓄積するには、次のようにします。
 Map<City, Set<String>> lastNamesByCity = people.stream().collect( groupingBy(Person::getCity, mapping(Person::getLastName, toSet())));
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 U - ダウンストリー� ・コレクタによって受け入れられる要� のタイプ
 
 A - ダウンストリー� ・コレクタの中間累計タイプ
 
 R - 回収担当の結果タイプ
 
 パラメータ:
 
 mapper - 入力要� に適用される関数
 
 downstream - マップ後の値を受け取るコレクタ
 
 戻り値:
 
 入力要� にマッピング関数を適用し、そのマップされた結果を下流のコレクタに渡すコレクタ
- flatMapping
 public static <T,U,A,R> Collector<T,?,R> flatMapping(Function<? super T, ? extends Stream<? extends U>> mapper, Collector<? super U, A, R> downstream)
 
 蓄積前に各入力要� にフラット・マッピング関数を適用することにより、U型の要� を受け入れるCollectorを、T型の要� を受け入れる1つの要� に適応させます。フラット・マッピング関数は、入力要� をゼロ個以上の出力要� を含むstreamにマップし、その後ダウンストリー� を累積します。マップされた各ストリー� は、その内容がダウンストリー� に配置された後、closedになります。 (マップ先ストリー� がnullの� �合はかわりに空のストリー� が使用されます。)
 
 APIのノート:
 
 flatMapping()コレクタは、groupingByまたはpartitioningByのダウンストリー� など、マルチレベルの縮小で使用される� �合に最も役立ちます。たとえば、Orderのストリー� を指定すると、顧客ごとに明細� �目のセットを累計できます:
 Map<String, Set<LineItem>> itemsByCustomerName = orders.stream().collect( groupingBy(Order::getCustomerName, flatMapping(order -> order.getLineItems().stream(), toSet())));
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 U - ダウンストリー� ・コレクタによって受け入れられる要� のタイプ
 
 A - ダウンストリー� ・コレクタの中間累計タイプ
 
 R - 回収担当の結果タイプ
 
 パラメータ:
 
 mapper - 入力要� に適用する関数。結果のストリー� を返します
 
 downstream - マッパーによって返されたストリー� の要� を受け取るコレクタ
 
 戻り値:
 
 マッピング機能を入力要� に適用し、フラット・マップ結果をダウンストリー� ・コレクタに提供するコレクタ
 
 導入されたバージョン:
 
 9
- filtering
 public static <T,A,R> Collector<T,?,R> filtering(Predicate<? super T> predicate, Collector<? super T, A, R> downstream)
 
 述語を各入力要� に適用し、述語がtrueを返す� �合にのみ累積することによって、Collectorを同じ型の要� Tを受け入れる要� に適合させます。
 
 APIのノート:
 
 filtering()コレクタは、groupingByまたはpartitioningByのダウンストリー� など、マルチレベルの縮小で使用される� �合に最も役立ちます。たとえば、Employeeというストリー� を指定すると、給与が特定のしきい値を超えている各部門の従業員を累計できます:
 Map<Department, Set<Employee>> wellPaidEmployeesByDepartment = employees.stream().collect( groupingBy(Employee::getDepartment, filtering(e -> e.getSalary() > 2000, toSet())));
 フィルタ・コレクタは、ストリー� のfilter()操作とは異なります。この例では、一部の部門で給与がしきい値を超えている従業員がいないとします。上記のようにフィルタリング・コレクタを使用すると、その部門から空のSetにマッピングされます。かわりにストリー� filter()操作が実行された� �合、その部門に対するマッピングはまったくありません。
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 A - ダウンストリー� ・コレクタの中間累計タイプ
 
 R - 回収担当の結果タイプ
 
 パラメータ:
 
 predicate - 入力要� に適用される述語
 
 downstream - 述語と一致する値を受け入れるコレクタ
 
 戻り値:
 
 述語を入力要� に適用し、一致する要� を下流のコレクタに提供するコレクタ
 
 導入されたバージョン:
 
 9
- collectingAndThen
 public static <T,A,R,RR> Collector<T,A,RR> collectingAndThen(Collector<T,A,R> downstream, Function<R,RR> finisher)
 
 追� の仕上げ変換が実行されるようにCollectorを適応させます。たとえば次のように、常に不変リストが生成されるようにtoList()コレクタを適応させることができます。
 List<String> list = people.stream().collect( collectingAndThen(toList(), Collections::unmodifiableList));
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 A - ダウンストリー� ・コレクタの中間累計タイプ
 
 R - ダウンストリー� ・コレクタの結果タイプ
 
 RR - 結果のコレクタの結果タイプ
 
 パラメータ:
 
 downstream - コレクタ
 
 finisher - 下流コレクタの最終結果に適用される関数
 
 戻り値:
 
 下流コレクタのアクションを実行した後で追� の最終ステップを実行するコレクタ
- counting
 public static <T> Collector<T,?,Long> counting()
 
 T型の要� を受け入れて、入力要� の数をカウントする、Collectorを返します。要� が存在しない� �合、結果は0になります。
 
 実装要件:
 
 これは次と同等の結果を生成します。
 reducing(0L, e -> 1L, Long::sum)
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 戻り値:
 
 入力要� の数をカウントするCollector
- minBy
 public static <T> Collector<T, ?, Optional<T>> minBy(Comparator<? super T> comparator)
 
 指定されたComparatorに従ってOptional<T>として記述された最小要� を生成するCollectorを返します。
 
 実装要件:
 
 これは次と同等の結果を生成します。
 reducing(BinaryOperator.minBy(comparator))
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 パラメータ:
 
 comparator - 要� を比較するためのComparator
 
 戻り値:
 
 最小値を生成するCollector
- maxBy
 public static <T> Collector<T, ?, Optional<T>> maxBy(Comparator<? super T> comparator)
 
 指定されたComparatorに従ってOptional<T>として記述された最大要� を生成するCollectorを返します。
 
 実装要件:
 
 これは次と同等の結果を生成します。
 reducing(BinaryOperator.maxBy(comparator))
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 パラメータ:
 
 comparator - 要� を比較するためのComparator
 
 戻り値:
 
 最大値を生成するCollector
- summingInt
 
 public static <T> Collector<T,?,Integer> summingInt(ToIntFunction<? super T> mapper)
 
 入力要� に適用される整数値関数の合計を生成するCollectorを返します。要� が存在しない� �合、結果は0になります。
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 パラメータ:
 
 mapper - 合計の対象となるプロパティーを抽出する関数
 
 戻り値:
 
 導出されたプロパティーの合計を生成するCollector
- summingLong
 
 public static <T> Collector<T,?,Long> summingLong(ToLongFunction<? super T> mapper)
 
 入力要� に適用されたlong値関数の合計を生成するCollectorを返します。要� が存在しない� �合、結果は0になります。
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 パラメータ:
 
 mapper - 合計の対象となるプロパティーを抽出する関数
 
 戻り値:
 
 導出されたプロパティーの合計を生成するCollector
- summingDouble
 
 public static <T> Collector<T,?,Double> summingDouble(ToDoubleFunction<? super T> mapper)
 
 入力要� に適用されたdouble値関数の合計を生成するCollectorを返します。要� が存在しない� �合、結果は0になります。
 値が記録されている� �番によって、返される合計が変わる可能性がありますが、これは、異なる大きさの値同士を� 算したときの丸め誤差が累積されるからです。値を大きさの絶対値の昇� �にソートすると、結果の精度が改善される傾向があります。記録された値の中にNaNのものが存在しているか、合計がある時点でNaNに達した� �合、合計はNaNになります。
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 パラメータ:
 
 mapper - 合計の対象となるプロパティーを抽出する関数
 
 戻り値:
 
 導出されたプロパティーの合計を生成するCollector
- averagingInt
 
 public static <T> Collector<T,?,Double> averagingInt(ToIntFunction<? super T> mapper)
 
 入力要� にint値関数を適用した結果の算術平均を生成するCollectorを返します。要� が存在しない� �合、結果は0になります。
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 パラメータ:
 
 mapper - 平均化するプロパティを抽出する関数
 
 戻り値:
 
 派生プロパティの算術平均を生成するCollector
- averagingLong
 
 public static <T> Collector<T,?,Double> averagingLong(ToLongFunction<? super T> mapper)
 
 入力要� にlong値関数を適用した結果の算術平均を生成するCollectorを返します。要� が存在しない� �合、結果は0になります。
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 パラメータ:
 
 mapper - 平均化するプロパティを抽出する関数
 
 戻り値:
 
 派生プロパティの算術平均を生成するCollector
- averagingDouble
 
 public static <T> Collector<T,?,Double> averagingDouble(ToDoubleFunction<? super T> mapper)
 
 入力要� にdouble値関数を適用した結果の算術平均を生成するCollectorを返します。要� が存在しない� �合、結果は0になります。
 値が記録されている� �番によって、返される平均が変わる可能性がありますが、これは、異なる大きさの値同士を� 算したときの丸め誤差が累積されるからです。値を大きさの絶対値の昇� �にソートすると、結果の精度が改善される傾向があります。記録された値の中にNaNのものが存在しているか、合計がある時点でNaNに達した� �合、平均はNaNになります。
 
 実装上のノート:
 
 doubleフォーマットは、-2⁵³から2⁵³の範囲のすべての連続する整数を表現できます。パイプラインに含まれる値の数が2⁵³個を超える� �合、平均計算の除数が2⁵³で飽和するため、さらなる数値誤差が発生します。
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 パラメータ:
 
 mapper - 平均化するプロパティを抽出する関数
 
 戻り値:
 
 派生プロパティの算術平均を生成するCollector
- reducing
 public static <T> Collector<T,?,T> reducing(T identity, BinaryOperator<T> op)
 
 指定されたBinaryOperatorの下で指定された単位元を使って入力要� のリダクションを実行するCollectorを返します。
 
 APIのノート:
 
 reducing()コレクタがもっとも役に立つのは、複数レベルのリダクション(groupingByまたはpartitioningByの下流)で使用する� �合です。ストリー� に対して単純なリダクションを実行する� �合は、代わりにStream.reduce(Object, BinaryOperator)を使用してく� さい。
 
 型パラメータ:
 
 T - 減額の入力および出力の要� タイプ
 
 パラメータ:
 
 identity - リダクションの単位元の値(入力要� が存在しない� �合の戻り値でもある)
 
 op - 入力要� のリデュースに使用されるBinaryOperator<T>
 
 戻り値:
 
 リダクション操作を実装したCollector
 
 関連� �目:
 
 reducing(BinaryOperator)
 
 reducing(Object, Function, BinaryOperator)
- reducing
 public static <T> Collector<T, ?, Optional<T>> reducing(BinaryOperator<T> op)
 
 指定されたBinaryOperatorの下で入力要� のリダクションを実行するCollectorを返します。結果はOptional<T>として記述されます。
 
 APIのノート:
 
 reducing()コレクタがもっとも役に立つのは、複数レベルのリダクション(groupingByまたはpartitioningByの下流)で使用する� �合です。単純なリダクションをストリー� に対して実行する� �合は、代わりにStream.reduce(BinaryOperator)を使用してく� さい。
 たとえば、特定のPersonストリー� について、市町村ごとに身長のもっとも高い人を計算するには、次のようにします。
 Comparator<Person> byHeight = Comparator.comparing(Person::getHeight); Map<City, Optional<Person>> tallestByCity = people.stream().collect( groupingBy(Person::getCity, reducing(BinaryOperator.maxBy(byHeight))));
 
 型パラメータ:
 
 T - 減額の入力および出力の要� タイプ
 
 パラメータ:
 
 op - 入力要� のリデュースに使用されるBinaryOperator<T>
 
 戻り値:
 
 リダクション操作を実装したCollector
 
 関連� �目:
 
 reducing(Object, BinaryOperator)
 
 reducing(Object, Function, BinaryOperator)
- reducing
 public static <T,U> Collector<T,?,U> reducing(U identity, Function<? super T, ? extends U> mapper, BinaryOperator op)
 
 指定されたマッピング関数とBinaryOperatorの下で入力要� のリダクションを実行するCollectorを返します。これはreducing(Object, BinaryOperator)を一般化したものであり、リダクションの前の要� の変換を可能にします。
 
 APIのノート:
 
 reducing()コレクタがもっとも役に立つのは、複数レベルのリダクション(groupingByまたはpartitioningByの下流)で使用する� �合です。単純なマップ-リデュースをストリー� に対して実行する� �合は、代わりにStream.map(Function)とStream.reduce(Object, BinaryOperator)を使用してく� さい。
 たとえば、特定のPersonストリー� について、市町村ごとに住民の最長の名前を計算するには、次のようにします。
 Comparator<String> byLength = Comparator.comparing(String::length); Map<City, String> longestLastNameByCity = people.stream().collect( groupingBy(Person::getCity, reducing("", Person::getLastName, BinaryOperator.maxBy(byLength))));
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 U - マップされた値のタイプ
 
 パラメータ:
 
 identity - リダクションの単位元の値(入力要� が存在しない� �合の戻り値でもある)
 
 mapper - 各入力値に適用するマッピング関数
 
 op - マップされた値のリデュースに使用されるBinaryOperator
 
 戻り値:
 
 マップ-リデュース操作を実装したCollector
 
 関連� �目:
 
 reducing(Object, BinaryOperator)
 
 reducing(BinaryOperator)
- groupingBy
 public static <T,K> Collector<T, ?, Map<K,List<T>>> groupingBy(Function<? super T, ? extends K> classifier)
 
 分類関数に従って要� をグループ化し、結果をMapに� �納して返す、T型の入力要� に対する「グループ化」操作を実装したCollectorを返します。
 分類関数は、要� をあるキーの型Kにマップします。コレクタによって生成されるMap<K, List<T>>のキーは、入力要� に分類関数を適用した結果の値であり、対応する値は、分類関数の下で関連キーにマップされた入力要� を含むListになります。
 返されるMapまたはListオブジェクトの型、可変性、直列化可能性、またはスレッド安全性は一切保証されません。
 
 実装要件:
 
 これは次のような結果を生成します。
 groupingBy(classifier, toList());
 
 実装上のノート:
 
 返されるCollectorは並行ではありません。並列ストリー� ・パイプラインでは、combiner関数はあるマップのキーを別のマップにマージすることにより動作しますが、この操作はコストが非常に高くなる可能性があります。結果のMapコレクタで要� の出現� �序を維持する必要がない� �合、groupingByConcurrent(Function)を使用することで並列処理のパフォーマンスが改善される可能性があります。
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 K - キーのタイプ
 
 パラメータ:
 
 classifier - 入力要� をキーにマップする分類関数
 
 戻り値:
 
 グループ化操作を実装したCollector
 
 関連� �目:
 
 groupingBy(Function, Collector)
 
 groupingBy(Function, Supplier, Collector)
 
 groupingByConcurrent(Function)
- groupingBy
 public static <T,K,A,D> Collector<T,?,Map<K,D>> groupingBy(Function<? super T, ? extends K> classifier, Collector<? super T, A, D> downstream)
 
 分類関数に従って要� をグループ化した後、指定された下流Collectorを使って特定のキーに関連付けられた値のリダクション操作を実行する、T型の入力要� に対するカスケード「グループ化」操作を実装したCollectorを返します。
 分類関数は、要� をあるキーの型Kにマップします。下流コレクタは、T型の要� に作用してD型の結果を生成します。結果となるコレクタは、Map<K, D>を生成します。
 返されるMapの型、可変性、直列化可能性、またはスレッド安全性は一切保証されません。
 たとえば、市町村ごとの人の名前のセットを計算するには、次のようにします。
 Map<City, Set<String>> namesByCity = people.stream().collect( groupingBy(Person::getCity, mapping(Person::getLastName, toSet())));
 
 実装上のノート:
 
 返されるCollectorは並行ではありません。並列ストリー� ・パイプラインでは、combiner関数はあるマップのキーを別のマップにマージすることにより動作しますが、この操作はコストが非常に高くなる可能性があります。下流コレクタに要� が提供される� �序を維持する必要がない� �合、groupingByConcurrent(Function, Collector)を使用することで並列処理のパフォーマンスが改善される可能性があります。
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 K - キーのタイプ
 
 A - ダウンストリー� ・コレクタの中間累計タイプ
 
 D - ダウンストリー� 削減の結果タイプ
 
 パラメータ:
 
 classifier - 入力要� をキーにマップする分類関数
 
 downstream - 下流リダクションを実装したCollector
 
 戻り値:
 
 カスケード・グループ化操作を実装したCollector
 
 関連� �目:
 
 groupingBy(Function)
 
 groupingBy(Function, Supplier, Collector)
 
 groupingByConcurrent(Function, Collector)
- groupingBy
 public static <T, K, D, A, M extends Map<K,D>> Collector<T,?,M> groupingBy(Function<? super T, ? extends K> classifier, Supplier<M> mapFactory, Collector<? super T, A, D> downstream)
 
 分類関数に従って要� をグループ化した後、指定された下流Collectorを使って特定のキーに関連付けられた値のリダクション操作を実行する、T型の入力要� に対するカスケード「グループ化」操作を実装したCollectorを返します。このCollectorで生成されるMapは、指定されたファクトリ関数によって作成されます。
 分類関数は、要� をあるキーの型Kにマップします。下流コレクタは、T型の要� に作用してD型の結果を生成します。結果となるコレクタは、Map<K, D>を生成します。
 たとえば、市町村ごとの人の名前のセット(市町村名がソートされる)を計算するには、次のようにします。
 Map<City, Set<String>> namesByCity = people.stream().collect( groupingBy(Person::getCity, TreeMap::new, mapping(Person::getLastName, toSet())));
 
 実装上のノート:
 
 返されるCollectorは並行ではありません。並列ストリー� ・パイプラインでは、combiner関数はあるマップのキーを別のマップにマージすることにより動作しますが、この操作はコストが非常に高くなる可能性があります。下流コレクタに要� が提供される� �序を維持する必要がない� �合、groupingByConcurrent(Function, Supplier, Collector)を使用することで並列処理のパフォーマンスが改善される可能性があります。
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 K - キーのタイプ
 
 D - ダウンストリー� 削減の結果タイプ
 
 A - ダウンストリー� ・コレクタの中間累計タイプ
 
 M - 結果のMapのタイプ
 
 パラメータ:
 
 classifier - 入力要� をキーにマップする分類関数
 
 mapFactory - 結果が挿入される新しい空のMapを提供するサプライヤ
 
 downstream - 下流リダクションを実装したCollector
 
 戻り値:
 
 カスケード・グループ化操作を実装したCollector
 
 関連� �目:
 
 groupingBy(Function, Collector)
 
 groupingBy(Function)
 
 groupingByConcurrent(Function, Supplier, Collector)
- groupingByConcurrent
 public static <T,K> Collector<T, ?, ConcurrentMap<K,List<T>>> groupingByConcurrent(Function<? super T, ? extends K> classifier)
 
 分類関数に従って要� をグループ化する、T型の入力要� に対する「グループ化」操作を実装した並行Collectorを返します。
 これは、� �序付けされていない並行なCollectorです。
 分類関数は、要� をあるキーの型Kにマップします。コレクタによって生成されるConcurrentMap<K, List<T>>のキーは、入力要� に分類関数を適用した結果の値であり、対応する値は、分類関数の下で関連キーにマップされた入力要� を含むListになります。
 返されたConcurrentMapオブジェクトまたはListオブジェクトのタイプ、変更可能性または直列化可能性、または返されたListオブジェクトのスレッド・セーフティに対する保証はありません。
 
 実装要件:
 
 これは次のような結果を生成します。
 groupingByConcurrent(classifier, toList());
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 K - キーのタイプ
 
 パラメータ:
 
 classifier - 入力要� をキーにマップする分類関数
 
 戻り値:
 
 グループ化操作を実装した、� �序付けされていない並行なCollector
 
 関連� �目:
 
 groupingBy(Function)
 
 groupingByConcurrent(Function, Collector)
 
 groupingByConcurrent(Function, Supplier, Collector)
- groupingByConcurrent
 public static <T,K,A,D> Collector<T, ?, ConcurrentMap<K,D>> groupingByConcurrent(Function<? super T, ? extends K> classifier, Collector<? super T, A, D> downstream)
 
 分類関数に従って要� をグループ化した後、指定された下流Collectorを使って特定のキーに関連付けられた値のリダクション操作を実行する、T型の入力要� に対するカスケード「グループ化」操作を実装した並行Collectorを返します。
 これは、� �序付けされていない並行なCollectorです。
 分類関数は、要� をあるキーの型Kにマップします。下流コレクタは、T型の要� に作用してD型の結果を生成します。結果のコレクタはConcurrentMap<K, D>を生成します。
 戻されるConcurrentMapのタイプ、変更可能性または直列化可能性は保証されません。
 たとえば、市町村ごとの人の名前のセット(市町村名がソートされる)を計算するには、次のようにします。
 ConcurrentMap<City, Set<String>> namesByCity = people.stream().collect( groupingByConcurrent(Person::getCity, mapping(Person::getLastName, toSet())));
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 K - キーのタイプ
 
 A - ダウンストリー� ・コレクタの中間累計タイプ
 
 D - ダウンストリー� 削減の結果タイプ
 
 パラメータ:
 
 classifier - 入力要� をキーにマップする分類関数
 
 downstream - 下流リダクションを実装したCollector
 
 戻り値:
 
 カスケード・グループ化操作を実装した、� �序付けされていない並行なCollector
 
 関連� �目:
 
 groupingBy(Function, Collector)
 
 groupingByConcurrent(Function)
 
 groupingByConcurrent(Function, Supplier, Collector)
- groupingByConcurrent
 public static <T, K, A, D, M extends ConcurrentMap<K,D>> Collector<T,?,M> groupingByConcurrent(Function<? super T, ? extends K> classifier, Supplier<M> mapFactory, Collector<? super T, A, D> downstream)
 
 分類関数に従って要� をグループ化した後、指定された下流Collectorを使って特定のキーに関連付けられた値のリダクション操作を実行する、T型の入力要� に対するカスケード「グループ化」操作を実装した並行Collectorを返します。このCollectorで生成されるConcurrentMapは、指定されたファクトリ関数によって作成されます。
 これは、� �序付けされていない並行なCollectorです。
 分類関数は、要� をあるキーの型Kにマップします。下流コレクタは、T型の要� に作用してD型の結果を生成します。結果のコレクタはConcurrentMap<K, D>を生成します。
 たとえば、市町村ごとの人の名前のセット(市町村名がソートされる)を計算するには、次のようにします。
 ConcurrentMap<City, Set<String>> namesByCity = people.stream().collect( groupingByConcurrent(Person::getCity, ConcurrentSkipListMap::new, mapping(Person::getLastName, toSet())));
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 K - キーのタイプ
 
 A - ダウンストリー� ・コレクタの中間累計タイプ
 
 D - ダウンストリー� 削減の結果タイプ
 
 M - 結果のConcurrentMapのタイプ
 
 パラメータ:
 
 classifier - 入力要� をキーにマップする分類関数
 
 mapFactory - 結果が挿入される新しい空のConcurrentMapを提供するサプライヤ
 
 downstream - 下流リダクションを実装したCollector
 
 戻り値:
 
 カスケード・グループ化操作を実装した、� �序付けされていない並行なCollector
 
 関連� �目:
 
 groupingByConcurrent(Function)
 
 groupingByConcurrent(Function, Collector)
 
 groupingBy(Function, Supplier, Collector)
- partitioningBy
 public static <T> Collector<T, ?, Map<Boolean,List<T>>> partitioningBy(Predicate<? super T> predicate)
 
 Predicateに従って入力要� を分割し、結果をMap<Boolean, List<T>>内に� �納するCollectorを返します。返されるMapには、常にfalseキーとtrueキーの両方のマッピングが含まれます。返されたMapまたはListのタイプ、変更可能性、直列化可能性またはスレッド・セーフティに対する保証はありません。
 
 APIのノート:
 
 パーティションに要� がない� �合、結果マップ内のその値は空のリストになります。
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 パラメータ:
 
 predicate - 入力要� の分類に使用される述語
 
 戻り値:
 
 分割操作を実装したCollector
 
 関連� �目:
 
 partitioningBy(Predicate, Collector)
- partitioningBy
 public static <T,D,A> Collector<T, ?, Map<Boolean,D>> partitioningBy(Predicate<? super T> predicate, Collector<? super T, A, D> downstream)
 
 Predicateに従って入力要� を分割し、別のCollectorに従って各パーティションの値をリデュースし、結果をMap<Boolean, D>内に� �納するCollectorを返します(下流のリダクションの結果がマップの値になる)。
 返されるMapには、常にfalseキーとtrueキーの両方のマッピングが含まれます。返されるMapの型、可変性、直列化可能性、またはスレッド安全性は一切保証されません。
 
 APIのノート:
 
 パーティションに要� がない� �合、結果Map内のその値は、ダウンストリー� ・コレクタのサプライヤ関数をコールし、終了関数を適用することで取得されます。
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 D - ダウンストリー� 削減の結果タイプ
 
 A - ダウンストリー� ・コレクタの中間累計タイプ
 
 パラメータ:
 
 predicate - 入力要� の分類に使用される述語
 
 downstream - 下流リダクションを実装したCollector
 
 戻り値:
 
 カスケード分割操作を実装したCollector
 
 関連� �目:
 
 partitioningBy(Predicate)
- toMap
 public static <T,K,U> Collector<T,?,Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper)
 
 Map(そのキーと値は指定されたマッピング関数を入力要� に適用した結果である)内に要� を蓄積するCollectorを返します。
 マップされたキーに重複(Object.equals(Object)によると)が含まれている� �合、収集操作の実行時にIllegalStateExceptionがスローされます。マップされたキーに重複がある� �合は、代わりにtoMap(Function, Function, BinaryOperator)を使用してく� さい。
 返されるMapの型、可変性、直列化可能性、またはスレッド安全性は一切保証されません。
 
 APIのノート:
 
 キーと値のどちらかが入力要� になることは、めずらしくありません。その� �合は、ユーティリティー・メソッドFunction.identity()が役立つ可能性があります。たとえば次の� �合、生徒を各自の成績評定平均値にマッピングするMapが生成されます。
 Map<Student, Double> studentToGPA = students.stream().collect( toMap(Function.identity(), student -> computeGPA(student)));
 また次の� �合、一意の識別子を生徒にマッピングするMapが生成されます。
 Map<String, Student> studentIdToStudent = students.stream().collect( toMap(Student::getId, Function.identity()));
 
 実装上のノート:
 
 返されるCollectorは並行ではありません。並列ストリー� ・パイプラインでは、combiner関数はあるマップのキーを別のマップにマージすることにより動作しますが、この操作はコストが非常に高くなる可能性があります。結果を検出� �でMapに挿入する必要がない� �合は、toConcurrentMap(Function, Function)を使用することで並列処理のパフォーマンスが改善される可能性があります。
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 K - キー・マッピング関数の出力タイプ
 
 U - 値マッピング関数の出力タイプ
 
 パラメータ:
 
 keyMapper - キーを生成するマッピング関数
 
 valueMapper - 値を生成するマッピング関数
 
 戻り値:
 
 Map内に要� を集めるCollector(マップのキーと値は、入力要� にマッピング関数を適用した結果となる)
 
 関連� �目:
 
 toMap(Function, Function, BinaryOperator)
 
 toMap(Function, Function, BinaryOperator, Supplier)
 
 toConcurrentMap(Function, Function)
- toUnmodifiableMap
 public static <T,K,U> Collector<T,?,Map<K,U>> toUnmodifiableMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper)
 
 入力要� を「変更不可能なMap」に累計するCollectorを返します。このキーと値は、指定されたマッピング関数を入力要� に適用した結果です。
 マップされたキーに重複(Object.equals(Object)によると)が含まれている� �合、収集操作の実行時にIllegalStateExceptionがスローされます。マップされたキーに重複がある� �合は、toUnmodifiableMap(Function, Function, BinaryOperator)を使用して値のマージを処理します。
 返されたコレクタは、nullのキーと値を許可しません。いずれかのマッピング関数がnullを返すと、NullPointerExceptionがスローされます。
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 K - キー・マッピング関数の出力タイプ
 
 U - 値マッピング関数の出力タイプ
 
 パラメータ:
 
 keyMapper - キーを生成するマッピング関数.nullでない
 
 valueMapper - 値を生成するためのマッピング関数.nullでなくてはならない
 
 戻り値:
 
 入力要� を「変更不可能なMap」に蓄積するCollector。そのキーと値は、指定されたマッピング関数を入力要� に適用した結果です
 
 スロー:
 
 NullPointerException - keyMapperまたはvalueMapperがnullの� �合
 
 導入されたバージョン:
 
 10
 
 関連� �目:
 
 toUnmodifiableMap(Function, Function, BinaryOperator)
- toMap
 public static <T,K,U> Collector<T,?,Map<K,U>> toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator mergeFunction)
 
 Map(そのキーと値は指定されたマッピング関数を入力要� に適用した結果である)内に要� を蓄積するCollectorを返します。
 マップされたキーに重複(Object.equals(Object)によると)が含まれている� �合、値マッピング関数が各等価要� に適用され、指定されたマージ関数を使用して結果がマージされます。
 返されるMapの型、可変性、直列化可能性、またはスレッド安全性は一切保証されません。
 
 APIのノート:
 
 同じキーにマップされた複数要� 間の衝突を処理する方法は、複数あります。他の形式のtoMapではた� 無条件にスローを行うマージ関数が使用されますが、より柔軟なマージポリシーを簡単に記述できます。たとえば、Personのストリー� があり、アドレスへの"電話帳"マッピング名を生成するが、2人のユーザーが同じ名前を持つ可能性がある� �合は、次のようにしてこれらの衝突を適切に処理し、アドレスの連結リストにMapマッピング名を生成できます:
 Map<String, String> phoneBook = people.stream().collect( toMap(Person::getName, Person::getAddress, (s, a) -> s + ", " + a));
 
 実装上のノート:
 
 返されるCollectorは並行ではありません。並列ストリー� ・パイプラインでは、combiner関数はあるマップのキーを別のマップにマージすることにより動作しますが、この操作はコストが非常に高くなる可能性があります。結果を検出� �でMapにマージする必要がない� �合は、toConcurrentMap(Function, Function, BinaryOperator)を使用することで並列処理のパフォーマンスが改善される可能性があります。
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 K - キー・マッピング関数の出力タイプ
 
 U - 値マッピング関数の出力タイプ
 
 パラメータ:
 
 keyMapper - キーを生成するマッピング関数
 
 valueMapper - 値を生成するマッピング関数
 
 mergeFunction - 同じキーに関連付けられた値同士の衝突の解決に使用されるマージ関数(Map.merge(Object, Object, BiFunction)に渡される)
 
 戻り値:
 
 Map内に要� を集めるCollector(マップのキーは、入力要� にキー・マッピング関数を適用した結果であり、マップの値は、そのキーに等しいすべての入力要� に値マッピング関数を適用し、それらをマージ関数で結合した結果となる)
 
 関連� �目:
 
 toMap(Function, Function)
 
 toMap(Function, Function, BinaryOperator, Supplier)
 
 toConcurrentMap(Function, Function, BinaryOperator)
- toUnmodifiableMap
 public static <T,K,U> Collector<T,?,Map<K,U>> toUnmodifiableMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator mergeFunction)
 
 入力要� を「変更不可能なMap」に累計するCollectorを返します。このキーと値は、指定されたマッピング関数を入力要� に適用した結果です。
 マップされたキーに重複(Object.equals(Object)によると)が含まれている� �合、値マッピング関数が各等価要� に適用され、指定されたマージ関数を使用して結果がマージされます。
 返されたコレクタは、nullのキーと値を許可しません。いずれかのマッピング関数がnullを返すと、NullPointerExceptionがスローされます。
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 K - キー・マッピング関数の出力タイプ
 
 U - 値マッピング関数の出力タイプ
 
 パラメータ:
 
 keyMapper - キーを生成するマッピング関数.nullでない
 
 valueMapper - 値を生成するためのマッピング関数.nullでなくてはならない
 
 mergeFunction - Map.merge(Object, Object, BiFunction)に指定されているように、同じキーに関連付けられた値間の衝突を解決するために使用されるマージ関数は、null以外である必要があります
 
 戻り値:
 
 入力要� を「変更不可能なMap」に蓄積するCollector。そのキーと値は、指定されたマッピング関数を入力要� に適用した結果です
 
 スロー:
 
 NullPointerException - keyMapper、valueMapper、またはmergeFunctionがnullの� �合
 
 導入されたバージョン:
 
 10
 
 関連� �目:
 
 toUnmodifiableMap(Function, Function)
- toMap
 public static <T, K, U, M extends Map<K,U>> Collector<T,?,M> toMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator mergeFunction, Supplier<M> mapFactory)
 
 Map(そのキーと値は指定されたマッピング関数を入力要� に適用した結果である)内に要� を蓄積するCollectorを返します。
 マップされたキーに重複(Object.equals(Object)によると)が含まれている� �合、値マッピング関数が各等価要� に適用され、指定されたマージ関数を使用して結果がマージされます。 Mapは、指定されたサプライヤ関数によって作成されます。
 
 実装上のノート:
 
 返されるCollectorは並行ではありません。並列ストリー� ・パイプラインでは、combiner関数はあるマップのキーを別のマップにマージすることにより動作しますが、この操作はコストが非常に高くなる可能性があります。結果を検出� �でMapにマージする必要がない� �合は、toConcurrentMap(Function, Function, BinaryOperator, Supplier)を使用することで並列処理のパフォーマンスが改善される可能性があります。
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 K - キー・マッピング関数の出力タイプ
 
 U - 値マッピング関数の出力タイプ
 
 M - 結果のMapのタイプ
 
 パラメータ:
 
 keyMapper - キーを生成するマッピング関数
 
 valueMapper - 値を生成するマッピング関数
 
 mergeFunction - 同じキーに関連付けられた値同士の衝突の解決に使用されるマージ関数(Map.merge(Object, Object, BiFunction)に渡される)
 
 mapFactory - 結果が挿入される新しい空のMapを提供するサプライヤ
 
 戻り値:
 
 Map内に要� を集めるCollector(マップのキーは、入力要� にキー・マッピング関数を適用した結果であり、マップの値は、そのキーに等しいすべての入力要� に値マッピング関数を適用し、それらをマージ関数で結合した結果となる)
 
 関連� �目:
 
 toMap(Function, Function)
 
 toMap(Function, Function, BinaryOperator)
 
 toConcurrentMap(Function, Function, BinaryOperator, Supplier)
- toConcurrentMap
 public static <T,K,U> Collector<T, ?, ConcurrentMap<K,U>> toConcurrentMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper)
 
 ConcurrentMap内に要� を累積する並行Collectorを返します(指定されたマッピング関数を入力要� に適用した結果が、マップのキーと値になる)。
 マップされたキーに重複(Object.equals(Object)によると)が含まれている� �合、収集操作の実行時にIllegalStateExceptionがスローされます。マップ先のキーが重複する可能性がある� �合は、代わりにtoConcurrentMap(Function, Function, BinaryOperator)を使用してく� さい。
 戻されるConcurrentMapのタイプ、変更可能性または直列化可能性は保証されません。
 
 APIのノート:
 
 キーと値のどちらかが入力要� になることは、めずらしくありません。その� �合は、ユーティリティー・メソッドFunction.identity()が役立つ可能性があります。たとえば、次の例では、学生を等級ポイント平均にマップするConcurrentMapが生成されます:
 ConcurrentMap<Student, Double> studentToGPA = students.stream().collect( toConcurrentMap(Function.identity(), student -> computeGPA(student)));
 次に、学生に一意の識別子をマッピングするConcurrentMapを生成します。
 ConcurrentMap<String, Student> studentIdToStudent = students.stream().collect( toConcurrentMap(Student::getId, Function.identity()));
 
 これは、� �序付けされていない並行なCollectorです。
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 K - キー・マッピング関数の出力タイプ
 
 U - 値マッピング関数の出力タイプ
 
 パラメータ:
 
 keyMapper - キーを生成するマッピング関数
 
 valueMapper - 値を生成するマッピング関数
 
 戻り値:
 
 ConcurrentMap内に要� を集める、� �序付けされていない並行なCollector(マップのキーは、入力要� にキー・マッピング関数を適用した結果であり、マップの値は、入力要� に値マッピング関数を適用した結果となる)
 
 関連� �目:
 
 toMap(Function, Function)
 
 toConcurrentMap(Function, Function, BinaryOperator)
 
 toConcurrentMap(Function, Function, BinaryOperator, Supplier)
- toConcurrentMap
 public static <T,K,U> Collector<T, ?, ConcurrentMap<K,U>> toConcurrentMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator mergeFunction)
 
 ConcurrentMap内に要� を累積する並行Collectorを返します(指定されたマッピング関数を入力要� に適用した結果が、マップのキーと値になる)。
 マップされたキーに重複(Object.equals(Object)によると)が含まれている� �合、値マッピング関数が各等価要� に適用され、指定されたマージ関数を使用して結果がマージされます。
 戻されるConcurrentMapのタイプ、変更可能性または直列化可能性は保証されません。
 
 APIのノート:
 
 同じキーにマップされた複数要� 間の衝突を処理する方法は、複数あります。他の形式のtoConcurrentMapではた� 無条件にスローを行うマージ関数が使用されますが、より柔軟なマージ・ポリシーを簡単に記述できます。たとえば、Personのストリー� があり、アドレスへの"電話帳"マッピング名を生成するが、2人のユーザーが同じ名前を持つ可能性がある� �合は、次のようにしてこれらの衝突を適切に処理し、アドレスの連結リストにConcurrentMapマッピング名を生成できます:
 ConcurrentMap<String, String> phoneBook = people.stream().collect( toConcurrentMap(Person::getName, Person::getAddress, (s, a) -> s + ", " + a));
 
 これは、� �序付けされていない並行なCollectorです。
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 K - キー・マッピング関数の出力タイプ
 
 U - 値マッピング関数の出力タイプ
 
 パラメータ:
 
 keyMapper - キーを生成するマッピング関数
 
 valueMapper - 値を生成するマッピング関数
 
 mergeFunction - 同じキーに関連付けられた値同士の衝突の解決に使用されるマージ関数(Map.merge(Object, Object, BiFunction)に渡される)
 
 戻り値:
 
 ConcurrentMap内に要� を集める、� �序付けされていない並行なCollector(マップのキーは、入力要� にキー・マッピング関数を適用した結果であり、マップの値は、そのキーに等しいすべての入力要� に値マッピング関数を適用し、それらをマージ関数で結合した結果となる)
 
 関連� �目:
 
 toConcurrentMap(Function, Function)
 
 toConcurrentMap(Function, Function, BinaryOperator, Supplier)
 
 toMap(Function, Function, BinaryOperator)
- toConcurrentMap
 public static <T, K, U, M extends ConcurrentMap<K,U>> Collector<T,?,M> toConcurrentMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper, BinaryOperator mergeFunction, Supplier<M> mapFactory)
 
 ConcurrentMap内に要� を累積する並行Collectorを返します(指定されたマッピング関数を入力要� に適用した結果が、マップのキーと値になる)。
 マップされたキーに重複(Object.equals(Object)によると)が含まれている� �合、値マッピング関数が各等価要� に適用され、指定されたマージ関数を使用して結果がマージされます。 ConcurrentMapは、指定されたサプライヤ関数によって作成されます。
 これは、� �序付けされていない並行なCollectorです。
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 K - キー・マッピング関数の出力タイプ
 
 U - 値マッピング関数の出力タイプ
 
 M - 結果のConcurrentMapのタイプ
 
 パラメータ:
 
 keyMapper - キーを生成するマッピング関数
 
 valueMapper - 値を生成するマッピング関数
 
 mergeFunction - 同じキーに関連付けられた値同士の衝突の解決に使用されるマージ関数(Map.merge(Object, Object, BiFunction)に渡される)
 
 mapFactory - 結果が挿入される新しい空のConcurrentMapを提供するサプライヤ
 
 戻り値:
 
 ConcurrentMap内に要� を集める、� �序付けされていない並行なCollector(マップのキーは、入力要� にキー・マッピング関数を適用した結果であり、マップの値は、そのキーに等しいすべての入力要� に値マッピング関数を適用し、それらをマージ関数で結合した結果となる)
 
 関連� �目:
 
 toConcurrentMap(Function, Function)
 
 toConcurrentMap(Function, Function, BinaryOperator)
 
 toMap(Function, Function, BinaryOperator, Supplier)
- summarizingInt
 public static <T> Collector<T, ?, IntSummaryStatistics> summarizingInt(ToIntFunction<? super T> mapper)
 
 各入力要� にint生成マッピング関数を適用し、その結果の値のサマリー統計を返すCollectorを返します。
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 パラメータ:
 
 mapper - 各要� に適用するマッピング関数
 
 戻り値:
 
 サマリー統計リダクションを実装したCollector
 
 関連� �目:
 
 summarizingDouble(ToDoubleFunction)
 
 summarizingLong(ToLongFunction)
- summarizingLong
 public static <T> Collector<T, ?, LongSummaryStatistics> summarizingLong(ToLongFunction<? super T> mapper)
 
 各入力要� にlong生成マッピング関数を適用し、その結果の値のサマリー統計を返すCollectorを返します。
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 パラメータ:
 
 mapper - 各要� に適用するマッピング関数
 
 戻り値:
 
 サマリー統計リダクションを実装したCollector
 
 関連� �目:
 
 summarizingDouble(ToDoubleFunction)
 
 summarizingInt(ToIntFunction)
- summarizingDouble
 public static <T> Collector<T, ?, DoubleSummaryStatistics> summarizingDouble(ToDoubleFunction<? super T> mapper)
 
 各入力要� にdouble生成マッピング関数を適用し、その結果の値のサマリー統計を返すCollectorを返します。
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 パラメータ:
 
 mapper - 各要� に適用するマッピング関数
 
 戻り値:
 
 サマリー統計リダクションを実装したCollector
 
 関連� �目:
 
 summarizingLong(ToLongFunction)
 
 summarizingInt(ToIntFunction)
- teeing
 public static <T,R1,R2,R> Collector<T,?,R> teeing(Collector<? super T, ?, R1> downstream1, Collector<? super T, ?, R2> downstream2, BiFunction<? super R1, ? super R2, R> merger)
 
 2つのダウンストリー� ・コレクタのコンポジットであるCollectorを返します。結果のコレクタに渡された各要� は、両方のダウンストリー� ・コレクタで処理され、結果は、指定されたマージ関数を使用して最終結果にマージされます。
 生成されるコレクタ機能では、次の操作を実行します:
 
 supplier: 、各回収担当サプライヤをコールして取得した結果コンテナを含む結果コンテナを作成
 accumulator: 各コレクタは、結果コンテナおよび入力要� を使用して蓄積されます
 組合せ: 2つの結果コンテナを持つ各コレクタ・バイラをコール
 finisher: 各コレクタは、結果コンテナとともに終了し、提供された合併をコールしてその結果を返します。
 
 結果のコレクタは、両方のダウンストリー� ・コレクタが� �序付けされていない� �合はCollector.Characteristics.UNORDERED、両方のダウンストリー� ・コレクタが同時接続している� �合はCollector.Characteristics.CONCURRENTです。
 
 型パラメータ:
 
 T - 入力要� のタイプ
 
 R1 - 最初のコレクタの結果タイプ
 
 R2 - 2番目のコレクタの結果タイプ
 
 R - 最終結果タイプ
 
 パラメータ:
 
 downstream1 - 第1ダウンストリー� 回収担当
 
 downstream2 - 第2ダウンストリー� 回収担当
 
 merger - 2つの結果を1つの結果にマージする関数
 
 戻り値:
 
 提供された2つのコレクタの結果を集計するCollector。
 
 導入されたバージョン:
 
 12

クラスCollectors

メソッドのサマリー

クラスjava.lang.Objectで宣言されたメソッド

メソッドの詳細

toCollection

toList

toUnmodifiableList

toSet

toUnmodifiableSet

joining

joining

joining

mapping

flatMapping

filtering

collectingAndThen

counting

minBy

maxBy

summingInt

summingLong

summingDouble

averagingInt

averagingLong

averagingDouble

reducing

reducing

reducing

groupingBy

groupingBy

groupingBy

groupingByConcurrent

groupingByConcurrent

groupingByConcurrent

partitioningBy

partitioningBy

toMap

toUnmodifiableMap

toMap

toUnmodifiableMap

toMap

toConcurrentMap

toConcurrentMap

toConcurrentMap

summarizingInt

summarizingLong

summarizingDouble

teeing