モジュール java.base
パッケージ 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の受け入れ要素に受け入れます。
      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型の要素を受け取るCollectorT型の要素を受け取れるように適応させるため、各入力要素にマッピング関数を適用した後で蓄積を行うようにします。
      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> 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

        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を返します。これは入力エレメントを「変更不可能なリスト」に遭遇順序で累積します。 返されたコレクタはnull値を許可しません。また、null値が指定されている場合はNullPointerExceptionをスローします。
        型パラメータ:
        T - 入力要素の型
        戻り値:
        Collectorは入力エレメントをエン・カウンタ・オーダーで「変更不可能なリスト」に蓄積
        導入されたバージョン:
        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()
        入力要素を「変更不可能なセット」に蓄積する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型の要素を受け取るCollectorT型の要素を受け取れるように適応させるため、各入力要素にマッピング関数を適用した後で蓄積を行うようにします。
        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

        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フォーマットは、-253から253の範囲のすべての連続する整数を表現できます。 パイプラインに含まれる値の数が253個を超える場合、平均計算の除数が253で飽和するため、さらなる数値誤差が発生します。
        型パラメータ:
        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<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には、常にfalsetrueキーの両方のマッピングが含まれています。 返される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には、常にfalsetrueキーの両方のマッピングが含まれています。 返される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)