Collectors (java.util.stream API仕様 b128 非公式翻訳)

Object
- Collectors

public final class Collectors
extends Object

要素をコレクションに累積する、様々な条件によって要素を要約するなど、様々な便利な簡約処理を実装したCollectorの実装。

次のコードは予め用意されたコレクタを使ってよくある可変簡約作業をする例である。

 
    // 名前をListに累積する
    List<String> list = people.stream().map(Person::getName).collect(Collectors.toList());

    // 名前をTreeSetに累積する
    Set<String> set = people.stream().map(Person::getName).collect(Collectors.toCollection(TreeSet::new));

    // 要素を文字列に変換し、カンマで区切って連結する
    String joined = things.stream()
                          .map(Object::toString)
                          .collect(Collectors.joining(", "));

    // 従業員の給与の和を求める
    int total = employees.stream()
                         .collect(Collectors.summingInt(Employee::getSalary)));

    // 部署ごとに従業員をグループ化する
    Map<Department, List<Employee>> byDept
        = employees.stream()
                   .collect(Collectors.groupingBy(Employee::getDepartment));

    // 部署ごとに給与の合計を求める
    Map<Department, Integer> totalByDept
        = employees.stream()
                   .collect(Collectors.groupingBy(Employee::getDepartment,
                                                  Collectors.summingInt(Employee::getSalary)));

    // 学生を合格者と不合格者に分ける
    Map<Boolean, List<Student>> passingFailing =
        students.stream()
                .collect(Collectors.partitioningBy(s -> s.getGrade() >= PASS_THRESHOLD));

メソッドの概要

All Methods Static Methods Concrete Methods
修飾子とタイプ	メソッドと説明
`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`型の要素を受け入れ、l入力要素数を数える`Collector`を返す。
`static <T,K> Collector<T,?,Map<K,List<T>>>`	`groupingBy(Function<? super T,? extends K> classifier)` `T`型である入力要素に対する"group by"処理を実装する`Collector`を返す。
`static <T,K,A,D> Collector<T,?,Map<K,D>>`	`groupingBy(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream)` `T`型である入力要素に対するカスケードされた"group by"処理を実装する`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)` `T`型である入力要素に対するカスケードされた"group by"処理を実装する`Collector`を返す。
`static <T,K> Collector<T,?,ConcurrentMap<K,List<T>>>`	`groupingByConcurrent(Function<? super T,? extends K> classifier)` `T`型である入力要素に対する"group by"処理を実装する並行`Collector`を返す。
`static <T,K,A,D> Collector<T,?,ConcurrentMap<K,D>>`	`groupingByConcurrent(Function<? super T,? extends K> classifier, Collector<? super T,A,D> downstream)` `T`型である入力要素に対するカスケードされた"group by"処理を実装する並行`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)` `T`型である入力要素に対するカスケードされた"group by"処理を実装する並行`Collector`を返す。
`static Collector<CharSequence,?,String>`	`joining()` 入力要素を出現順に`String`に連結する`Collector`を返す。
`static Collector<CharSequence,?,String>`	`joining(CharSequence delimiter)` 入力要素を出現順に指定された文字列で区切って`String`に連結する`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)` `Collector`の各入力要素に対して累積前に写像関数を適用して、`U`型を受けとる`Collector`を`T`型を受けとる`Collector`へと適合させる。
`static <T> Collector<T,?,Optional<T>>`	`maxBy(Comparator<? super T> comparator)` 与えられた`Comparator`に従って最大の要素を表す`Optional<T>`を生成する`Collector<T, T>`を返す。
`static <T> Collector<T,?,Optional<T>>`	`minBy(Comparator<? super T> comparator)` 与えられた`Comparator`に従って最小の要素を表す`Optional<T>`を生成する`Collector<T, T>`を返す。
`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`を返す。

クラスから継承されたメソッド 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は与えられたファクトリによって作成される。
 - toList
```
public static <T> Collector<T,?,List<T>> toList()
```
 入力要素を新しいListに出現順に累積するCollectorを返す。返されるListに対する、型・可変性・直列化可能性・スレッド安全性の保証は無い。もし返されるListについての制御権が必要であれば、toCollection(Supplier)を利用せよ。
 - toSet
```
public static <T> Collector<T,?,Set<T>> toSet()
```
 入力要素を新しいSetに出現順に累積するCollectorを返す。返されるSetに対する、型・可変性・直列化可能性・スレッド安全性の保証は無い。もし返されるListについての制御権が必要であれば、toCollection(Supplier)を利用せよ。
 これは順序を持たないCollectorである。
 - joining
```
public static Collector<CharSequence,?,String> joining()
```
 入力要素を出現順にStringに連結するCollectorを返す。
 - joining
```
public static Collector<CharSequence,?,String> joining(CharSequence delimiter)
```
 入力要素を出現順に指定された文字列で区切ってStringに連結するCollectorを返す。
 - joining
```
public static Collector<CharSequence,?,String> joining(CharSequence delimiter,
 CharSequence prefix,
 CharSequence suffix)
```
 入力要素を出現順に指定された文字列で区切って連結し、指定された接頭辞および接尾辞を付与するCollectorを返す。
 - mapping
```
public static <T,U,A,R> Collector<T,?,R> mapping(Function<? super T,? extends U> mapper,
 Collector<? super U,A,R> downstream)
```
 Collectorの各入力要素に対して累積前に写像関数を適用して、U型を受けとるCollectorをT型を受けとるCollectorへと適合させる。
 - 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));
```
 - counting
```
public static <T> Collector<T,?,Long> counting()
```
 T型の要素を受け入れ、l入力要素数を数えるCollectorを返す。要素が無ければ結果は0となる。
 - minBy
```
public static <T> Collector<T,?,Optional<T>> minBy(Comparator<? super T> comparator)
```
 与えられたComparatorに従って最小の要素を表すOptional<T>を生成するCollector<T, T>を返す。
 - maxBy
```
public static <T> Collector<T,?,Optional<T>> maxBy(Comparator<? super T> comparator)
```
 与えられたComparatorに従って最大の要素を表すOptional<T>を生成するCollector<T, T>を返す。
 - summingInt
```
public static <T> Collector<T,?,Integer> summingInt(ToIntFunction<? super T> mapper)
```
 int値を返す関数を入力要素に適用した結果の和を返すCollectorを返す。要素が無ければ結果は0となる。
 - summingLong
```
public static <T> Collector<T,?,Long> summingLong(ToLongFunction<? super T> mapper)
```
 long値を返す関数を入力要素に適用した結果の和を返すCollectorを返す。要素が無ければ結果は0となる。
 - summingDouble
```
public static <T> Collector<T,?,Double> summingDouble(ToDoubleFunction<? super T> mapper)
```
 double値を返す関数を入力要素に適用した結果の和を返すCollectorを返す。要素が無ければ結果は0となる。
 返される和は、桁が異なる値の加算に由来する丸め誤差の累積のため、値が登録される順番によって変化する場合がある。絶対値が小さい順に整列するとより正確な値を出す傾向がある。登録されるいずれかの要素がNaNであるか、いずれかの時点での和がNaNである場合、和はNaNとなる。
 - averagingInt
```
public static <T> Collector<T,?,Double> averagingInt(ToIntFunction<? super T> mapper)
```
 int値を返す関数を入力要素に適用した結果の算術平均を返すCollectorを返す。要素が無ければ結果は0となる。
 - averagingLong
```
public static <T> Collector<T,?,Double> averagingLong(ToLongFunction<? super T> mapper)
```
 long値を返す関数を入力要素に適用した結果の算術平均を返すCollectorを返す。要素が無ければ結果は0となる。
 - averagingDouble
```
public static <T> Collector<T,?,Double> averagingDouble(ToDoubleFunction<? super T> mapper)
```
 double値を返す関数を入力要素に適用した結果の算術平均を返すCollectorを返す。要素が無ければ結果は0となる。
 返される平均値は、桁が異なる値の加算に由来する丸め誤差の累積のため、値が登録される順番によって変化する場合がある。絶対値が小さい順に整列するとより正確な値を出す傾向がある。登録されるいずれかの要素がNaNであるか、いずれかの時点での和がNaNである場合、平均値はNaNとなる。
 - reducing
```
public static <T> Collector<T,?,T> reducing(T identity,
 BinaryOperator<T> op)
```
 与えられた単位元を使い、指定されたBinaryOperatorに基いて入力要素の簡約を実行するCollectorを返す。
 - reducing
```
public static <T> Collector<T,?,Optional<T>> reducing(BinaryOperator<T> op)
```
 指定されたBinaryOperatorに基づいて入力要素の簡約を実行するCollectorを返す。結果はOptional<T>によって表される。
 - reducing
```
public static <T,U> Collector<T,?,U> reducing(U identity,
 Function<? super T,? extends U> mapper,
 BinaryOperator op)
```
 指定された写像関数とBinaryOperatorに基いて入力要素の簡約を実行するCollectorを返す。これはreducing(Object, BinaryOperator)の一般化であり、簡約の前に要素の変換を許す。
 - groupingBy
```
public static <T,K> Collector<T,?,Map<K,List<T>>> groupingBy(Function<? super T,? extends K> classifier)
```
 T型である入力要素に対する"group by"処理を実装するCollectorを返す。つまり要素を分類関数に従ってグループ化して結果をMapで返すCollectorを返す。
 分類関数は要素をK型の何らかのキーに写像する。このコレクタは、入力要素に分類関数を適用した結果の値をキーとして持ち、そのキーに分類関数が写像するような入力要素を含むListを対応する値として持つようなMap<K, List<T>>を生成する。
 返されるMapやListオブジェクトに対する、型・可変性・直列化可能性・スレッド安全性の保証は無い。
 - 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)
```
 T型である入力要素に対するカスケードされた"group by"処理を実装するCollectorを返す。つまり要素を分類関数に従ってグループ化した後に下流のCollectorを使って与えられたキーに対応する値の簡約処理を実行するCollectorを返す。
 分類関数は要素をK型の何らかのキーに写像する。下流のコレクタはT型の要素を処理し、D型の結果を返す。結果のコレクタはMap<K, D>を生成する。
 返されるMapオブジェクトに対する、型・可変性・直列化可能性・スレッド安全性の保証は無い。
 例えば、各市における名字の集合を計算するには次のようにする。
```
 
 Map<City, Set<String>> namesByCity
 = people.stream().collect(groupingBy(Person::getCity,
 mapping(Person::getLastName, toSet())));
```
 - 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)
```
 T型である入力要素に対するカスケードされた"group by"処理を実装するCollectorを返す。つまり要素を分類関数に従ってグループ化した後に下流のCollectorを使って与えられたキーに対応する値の簡約処理を実行する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())));
```
 - groupingByConcurrent
```
public static <T,K> Collector<T,?,ConcurrentMap<K,List<T>>> groupingByConcurrent(Function<? super T,? extends K> classifier)
```
 T型である入力要素に対する"group by"処理を実装する並行Collectorを返す。つまり要素を分類関数に従ってグループ化するCollectorを返す。
 これは並行で順序を持たないCollectorである。
 分類関数は要素をK型の何らかのキーに写像する。このコレクタは、入力要素に分類関数を適用した結果の値をキーとして持ち、そのキーに分類関数が写像するような入力要素を含むListを対応する値として持つようなConcurrentMap<K, List<T>>を生成する。
 返されるMapやListオブジェクトに対する、型・可変性・直列化可能性の保証は無く、返されるListオブジェクトに対するスレッド安全性の保障はない。
 - 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)
```
 T型である入力要素に対するカスケードされた"group by"処理を実装する並行Collectorを返す。つまり要素を分類関数に従ってグループ化した後に下流のCollectorを使って与えられたキーに対応する値の簡約処理を実行するCollectorを返す。
 これは並行で順序を持たないCollectorである。
 分類関数は要素をK型の何らかのキーに写像する。下流のコレクタはT型の要素を処理し、D型の結果を返す。結果のコレクタはMap<K, D>を生成する。
 例えば、各市における名字の整列済み集合を計算するには次のようにする。
```
 
 ConcurrentMap<City, Set<String>> namesByCity
 = people.stream().collect(groupingByConcurrent(Person::getCity,
 mapping(Person::getLastName, toSet())));
```
 - 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)
```
 T型である入力要素に対するカスケードされた"group by"処理を実装する並行Collectorを返す。つまり要素を分類関数に従ってグループ化した後に下流のCollectorを使って与えられたキーに対応する値の簡約処理を実行する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())));
```
 - partitioningBy
```
public static <T> Collector<T,?,Map<Boolean,List<T>>> partitioningBy(Predicate<? super T> predicate)
```
 入力要素をPredicateに従って分割してMap<Boolean, List<T>>に編成するCollectorを返す。返されるMapオブジェクトに対する、型・可変性・直列化可能性・スレッド安全性の保証は無い。
 - 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オブジェクトに対する、型・可変性・直列化可能性・スレッド安全性の保証は無い。
 - 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)を使用せよ。
 - 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)に従って)重複を含む場合は、等価な各要素に対して値に写像する関数が適用され、用意された併合関数により結果が併合される。
 - 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は与えられた供給関数によって作成される。
 - 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)を使用せよ。
 - 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)に従って)重複を含む場合は、等価な各要素に対して値に写像する関数が適用され、用意された併合関数により結果が併合される。
 - 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である。
 - summarizingInt
```
public static <T> Collector<T,?,IntSummaryStatistics> summarizingInt(ToIntFunction<? super T> mapper)
```
 各入力要素にintを返す関数を適用し、結果の値に対する要約統計量を返すCollectorを返す。
 - summarizingLong
```
public static <T> Collector<T,?,LongSummaryStatistics> summarizingLong(ToLongFunction<? super T> mapper)
```
 各入力要素にlongを返す関数を適用し、結果の値に対する要約統計量を返すCollectorを返す。
 - summarizingDouble
```
public static <T> Collector<T,?,DoubleSummaryStatistics> summarizingDouble(ToDoubleFunction<? super T> mapper)
```
 各入力要素にdoubleを返す関数を適用し、結果の値に対する要約統計量を返すCollectorを返す。

クラス Collectors

メソッドの概要

クラスから継承されたメソッド 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