🔥 Breaking News: javase/jp//docs/api/java/util/stream/Collectors.html

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メソッド具象メソッド
修飾子と型	メソッド	説明
`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,K> Collector<T,?,Map<K,List<T>>>`	`groupingBy(Function<? super T,? extends K> classifier)`	分類関数に従って要素をグループ化し、結果を`Map`に格納して返す、`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,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> Collector<T,?,ConcurrentMap<K,List<T>>>`	`groupingByConcurrent(Function<? super T,? extends K> classifier)`	分類関数に従って要素をグループ化する、`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 <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 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<U> 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)`	入力要素にint値関数を適用した結果の合計を生成する`Collector`を返します。
`static <T> Collector<T,?,Long>`	`summingLong(ToLongFunction<? super T> mapper)`	入力要素にlong値関数を適用した結果の合計を生成する`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<U> 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<U> mergeFunction, Supplier<M> mapSupplier)`	`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<U> 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<U> mergeFunction, Supplier<M> mapSupplier)`	`Map`内に要素を累積する`Collector`を返します(指定されたマッピング関数を入力要素に適用した結果が、マップのキーと値になる)。
`static <T> Collector<T,?,Set<T>>`	`toSet()`	入力要素を新しい`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を返すSupplier
 
 戻り値:
 
 すべての入力要素を検出順にCollection内に集めるCollector
 - toList
```
public static <T> Collector<T,?,List<T>> toList()
```
 入力要素を新しいListに蓄積するCollectorを返します。返されるListの型、可変性、直列化可能性、またはスレッド安全性は一切保証されません。返されるListをより細かく制御する必要がある場合は、toCollection(Supplier)を使用してください。
 
 型パラメータ:
 
 T - 入力要素の型
 
 戻り値:
 
 すべての入力要素を検出順にList内に集めるCollector
 - toSet
```
public static <T> Collector<T,?,Set<T>> toSet()
```
 入力要素を新しいSetに蓄積するCollectorを返します。返されるSetの型、可変性、直列化可能性、またはスレッド安全性は一切保証されません。返されるSetをより細かく制御する必要がある場合は、toCollection(Supplier)を使用してください。
 これは、順序付けされていないCollectorです。
 
 型パラメータ:
 
 T - 入力要素の型
 
 戻り値:
 
 すべての入力要素をSet内に集めるCollector
 - 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 - マップ後の値を受け取るコレクタ
 
 戻り値:
 
 入力要素にマッピング関数を適用し、そのマップされた結果を下流のコレクタに渡すコレクタ
 - 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> people
 = 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)
```
 入力要素にint値関数を適用した結果の合計を生成する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, 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 - キーの型
 
 A - 下流コレクタの中間蓄積の型
 
 D - 下流リダクションの結果の型
 
 M - 結果となるMapの型
 
 パラメータ:
 
 classifier - 入力要素をキーにマップする分類関数
 
 downstream - 下流リダクションを実装したCollector
 
 mapFactory - 呼出し時に、要求された型の新しい空のMapを生成する関数
 
 戻り値:
 
 カスケード・グループ化操作を実装した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になります。
 返されるMapまたは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型の結果を生成します。結果となるコレクタは、Map<K, D>を生成します。
 たとえば、市町村ごとの人の名前のセット(市町村名がソートされる)を計算するには、次のようにします。
```
 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型の結果を生成します。結果となるコレクタは、Map<K, D>を生成します。
 たとえば、市町村ごとの人の名前のセット(市町村名がソートされる)を計算するには、次のようにします。
```
 ConcurrentMap<City, Set<String>> namesByCity
 = people.stream().collect(groupingBy(Person::getCity, ConcurrentSkipListMap::new,
 mapping(Person::getLastName, toSet())));
 
```
 型パラメータ:
 
 T - 入力要素の型
 
 K - キーの型
 
 A - 下流コレクタの中間蓄積の型
 
 D - 下流リダクションの結果の型
 
 M - 結果となるConcurrentMapの型
 
 パラメータ:
 
 classifier - 入力要素をキーにマップする分類関数
 
 downstream - 下流リダクションを実装したCollector
 
 mapFactory - 呼出し時に、要求された型の新しい空のConcurrentMapを生成する関数
 
 戻り値:
 
 カスケード・グループ化操作を実装した、順序付けされていない並行な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の型、可変性、直列化可能性、またはスレッド安全性は一切保証されません。
 
 型パラメータ:
 
 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の型、可変性、直列化可能性、またはスレッド安全性は一切保証されません。
 
 型パラメータ:
 
 T - 入力要素の型
 
 A - 下流コレクタの中間蓄積の型
 
 D - 下流リダクションの結果の型
 
 パラメータ:
 
 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)を使用してください。
 APIのノート:
 キーと値のどちらかが入力要素になることは、めずらしくありません。その場合は、ユーティリティー・メソッドFunction.identity()が役立つ可能性があります。たとえば次の場合、生徒を各自の成績評定平均値にマッピングするMapが生成されます。
 Map<Student, Double> studentToGPA students.stream().collect(toMap(Functions.identity(), student -> computeGPA(student)));
 また次の場合、一意の識別子を生徒にマッピングするMapが生成されます。
 Map<String, Student> studentIdToStudent students.stream().collect(toMap(Student::getId, Functions.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)
 - 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)で判定)、等しい各要素に値マッピング関数が適用され、それらの結果が指定されたマージ関数を使ってマージされます。
 APIのノート:
 同じキーにマップされた複数要素間の衝突を処理する方法は、複数あります。他の形式のtoMapではただ無条件にスローを行うマージ関数が使用されますが、より柔軟なマージポリシーを簡単に記述できます。たとえば、あるPersonストリームがあるとして、名前と住所を対応づける電話帳を生成したいが、同じ名前の人が複数存在する可能性がある場合、次のようにすれば、そうした衝突を適切に処理し、名前を連結された住所リストにマッピングする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)
 - 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> mapSupplier)
```
 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)に渡される)
 
 mapSupplier - 結果の挿入先となる新しい空の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)を使用してください。
 APIのノート:
 キーと値のどちらかが入力要素になることは、めずらしくありません。その場合は、ユーティリティー・メソッドFunction.identity()が役立つ可能性があります。たとえば次の場合、生徒を各自の成績評定平均値にマッピングするMapが生成されます。
 Map<Student, Double> studentToGPA students.stream().collect(toMap(Functions.identity(), student -> computeGPA(student)));
 また次の場合、一意の識別子を生徒にマッピングするMapが生成されます。
 Map<String, Student> studentIdToStudent students.stream().collect(toConcurrentMap(Student::getId, Functions.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)で判定)、等しい各要素に値マッピング関数が適用され、それらの結果が指定されたマージ関数を使ってマージされます。
 APIのノート:
 同じキーにマップされた複数要素間の衝突を処理する方法は、複数あります。他の形式のtoConcurrentMapではただ無条件にスローを行うマージ関数が使用されますが、より柔軟なマージ・ポリシーを簡単に記述できます。たとえば、あるPersonストリームがあるとして、名前と住所を対応づける電話帳を生成したいが、同じ名前の人が複数存在する可能性がある場合、次のようにすれば、そうした衝突を適切に処理し、名前を連結された住所リストにマッピングするMapを生成することができます。
 Map<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> mapSupplier)
```
 ConcurrentMap内に要素を累積する並行Collectorを返します(指定されたマッピング関数を入力要素に適用した結果が、マップのキーと値になる)。
 マップ先のキーが重複している場合(Object.equals(Object)で判定)、等しい各要素に値マッピング関数が適用され、それらの結果が指定されたマージ関数を使ってマージされます。 ConcurrentMapは、指定されたサプライヤ関数によって作成されます。
 これは、順序付けされていない並行なCollectorです。
 
 型パラメータ:
 
 T - 入力要素の型
 
 K - キー・マッピング関数の出力の型
 
 U - 値マッピング関数の出力の型
 
 M - 結果となるConcurrentMapの型
 
 パラメータ:
 
 keyMapper - キーを生成するマッピング関数
 
 valueMapper - 値を生成するマッピング関数
 
 mergeFunction - 同じキーに関連付けられた値同士の衝突の解決に使用されるマージ関数(Map.merge(Object, Object, BiFunction)に渡される)
 
 mapSupplier - 結果の挿入先となる新しい空のMapを返す関数
 
 戻り値:
 
 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)

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

クラスCollectors

メソッドのサマリー

クラス java.lang.Objectから継承されたメソッド

メソッドの詳細

toCollection

toList

toSet

joining

joining

joining

mapping

collectingAndThen

counting

minBy

maxBy

summingInt

summingLong

summingDouble

averagingInt

averagingLong

averagingDouble

reducing

reducing

reducing

groupingBy

groupingBy

groupingBy

groupingByConcurrent

groupingByConcurrent

groupingByConcurrent

partitioningBy

partitioningBy

toMap

toMap

toMap

toConcurrentMap

toConcurrentMap

toConcurrentMap

summarizingInt

summarizingLong

summarizingDouble