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
の受け入れ要素に受け入れます。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<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)
入力要素に適用された整数値関数の合計を生成する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<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> 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<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> mapFactory)
Map
(そのキーと値は指定されたマッピング関数を入力要素に適用した結果である)内に要素を蓄積するCollector
を返します。static <T> Collector<T,?,Set<T>>
toSet()
入力要素を新しいSet
に蓄積するCollector
を返します。static <T> Collector<T,?,List<T>>
toUnmodifiableList()
Collector
を返します。これは入力要素を「変更不可能なリスト」に遭遇順序で累積します。static <T, K, U> Collector<T,?,Map<K,U>>
toUnmodifiableMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)
入力要素を「変更不可能なマップ」に蓄積するCollector
を返します。そのキーと値は、提供されたマッピング関数を入力要素に適用した結果です。static <T, K, U> Collector<T,?,Map<K,U>>
toUnmodifiableMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction)
入力要素を「変更不可能なマップ」に蓄積するCollector
を返します。そのキーと値は、提供されたマッピング関数を入力要素に適用した結果です。static <T> Collector<T,?,Set<T>>
toUnmodifiableSet()
入力要素を「変更不可能なセット」に蓄積するCollector
を返します。
-
メソッドの詳細
-
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
入力要素を新しいList
に蓄積するCollector
を返します。 返されるList
の型、可変性、直列化可能性、またはスレッド安全性は一切保証されません。返されるList
をより細かく制御する必要がある場合は、toCollection(Supplier)
を使用してください。- 型パラメータ:
T
- 入力要素の型- 戻り値:
- すべての入力要素を検出順に
List
内に集めるCollector
-
toUnmodifiableList
Collector
を返します。これは入力要素を「変更不可能なリスト」に遭遇順序で累積します。 返されたコレクタはnull値を許可しません。また、null値が指定されている場合はNullPointerException
をスローします。- 型パラメータ:
T
- 入力要素の型- 戻り値:
Collector
は入力要素をエンカウンタ・オーダーで「変更不可能なリスト」に蓄積- 導入されたバージョン:
- 10
-
toSet
入力要素を新しいSet
に蓄積するCollector
を返します。 返されるSet
の型、可変性、直列化可能性、またはスレッド安全性は一切保証されません。返されるSet
をより細かく制御する必要がある場合は、toCollection(Supplier)
を使用してください。これは、
順序付けされていない
Collectorです。- 型パラメータ:
T
- 入力要素の型- 戻り値:
- すべての入力要素を
Set
内に集めるCollector
-
toUnmodifiableSet
入力要素を「変更不可能なセット」に蓄積するCollector
を返します。 返されたコレクタはnull値を許可しません。また、null値が指定されている場合はNullPointerException
をスローします。 入力に重複要素が含まれている場合、重複要素の任意の要素が保持されます。これは、
順序付けされていない
Collectorです。- 型パラメータ:
T
- 入力要素の型- 戻り値:
- 入力要素を「変更不可能なセット」に蓄積する
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
の受け入れ要素に受け入れます。 フラット・マッピング関数は、入力要素を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
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
フォーマットは、-253から253の範囲のすべての連続する整数を表現できます。 パイプラインに含まれる値の数が253個を超える場合、平均計算の除数が253で飽和するため、さらなる数値誤差が発生します。- 型パラメータ:
T
- 入力要素の型- パラメータ:
mapper
- 平均化するプロパティを抽出する関数- 戻り値:
- 派生プロパティの算術平均を生成する
Collector
-
削減
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)
-
削減
public static <T, U> Collector<T,?,U> reducing(U identity, Function<? super T,? extends U> mapper, BinaryOperator<U> 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<U>
- 戻り値:
- マップ-リデュース操作を実装した
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
になります。返される
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
- 入力要素をキーにマップする分類関数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
には、常にfalse
とtrue
キーの両方のマッピングが含まれています。 返されるMap
またはList
の型、変更可能性、直列化可能性、またはスレッド安全性に関する保証はありません。- APIの注:
- パーティションに要素がない場合、結果Mapの値は空のListになります。
- 型パラメータ:
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
- 入力要素の型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)
を使用してください。返される
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)入力要素を「変更不可能なマップ」に蓄積するCollector
を返します。そのキーと値は、提供されたマッピング関数を入力要素に適用した結果です。マップされたキーに重複のある(
Object.equals(Object)
によると)が含まれている場合、コレクション操作が実行されるとIllegalStateException
がスローされます。 マップされたキーに重複がある場合は、toUnmodifiableMap(Function, Function, BinaryOperator)
を使用して値のマージを処理します。返されたコレクタは、nullのキーと値を許可しません。 いずれかのマッピング関数がnullを返すと、
NullPointerException
がスローされます。- 型パラメータ:
T
- 入力要素の型K
- キー・マッピング関数の出力の型U
- 値マッピング関数の出力の型- パラメータ:
keyMapper
- キーを生成するマッピング関数、非nullでなければならないvalueMapper
- 値を生成するためのマッピング関数、非nullでなくてはならない- 戻り値:
- 入力要素を「変更不可能なマップ」に蓄積する
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<U> 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<U> mergeFunction)入力要素を「変更不可能なマップ」に蓄積するCollector
を返します。そのキーと値は、提供されたマッピング関数を入力要素に適用した結果です。マップされたキーに重複する(
Object.equals(Object)
によると)が含まれている場合は、値マッピング関数が各等価要素に適用され、結果は指定されたマージ関数を使用してマージされます。返されたコレクタは、nullのキーと値を許可しません。 いずれかのマッピング関数がnullを返すと、
NullPointerException
がスローされます。- 型パラメータ:
T
- 入力要素の型K
- キー・マッピング関数の出力の型U
- 値マッピング関数の出力の型- パラメータ:
keyMapper
- キーを生成するマッピング関数、非nullでなければならないvalueMapper
- 値を生成するためのマッピング関数、非nullでなくてはならないmergeFunction
-Map.merge(Object, Object, BiFunction)
に供給される同じキーに関連付けられた値間の衝突を解決するために使用されるマージ関数、非nullでなくてはなりません- 戻り値:
- 入力要素を「変更不可能なマップ」に蓄積する
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<U> 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<U> 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<U> 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
-