Класс Collectors

java.lang.Object

java.util.stream.Collectors

public final class Collectors extends Object

Реализации Collector, которые реализуют различные полезные операции редукции, такие как накопление элементов в коллекции, обобщение элементов по различным критериям и т. д.

Ниже приведены примеры использования предопределенных коллекторов для выполнения общих задач мутабельной редукции:


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

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

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

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

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

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

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

Since:: 1.8

Краткое описание методов

Модификатор и тип	Метод	Описание
`static <T> Collector<T,?,Double>`	`averagingDouble(ToDoubleFunction<? super T> mapper)`	Возвращает `Collector`, который вычисляет среднее арифметическое значения функции от двойного типа, применённой к входным элементам.
`static <T> Collector<T,?,Double>`	`averagingInt(ToIntFunction<? super T> mapper)`	Возвращает `Collector`, который вычисляет среднее арифметическое значения функции от целого типа, применённой к входным элементам.
`static <T> Collector<T,?,Double>`	`averagingLong(ToLongFunction<? super T> mapper)`	Возвращает `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()`	Возвращает `Collector`, принимающий элементы типа `T`, который подсчитывает количество входных элементов.
`static <T, A, R> Collector<T,?,R>`	`filtering(Predicate<? super T> predicate, Collector<? super T,A,R> downstream)`	Адаптирует `Collector` к приёму элементов того же типа `T`, применяя предикат к каждому входному элементу и накапливая только если предикат возвращает `true`.
`static <T, U, A, R> Collector<T,?,R>`	`flatMapping(Function<? super T,? extends Stream<? extends U>> mapper, Collector<? super U,A,R> downstream)`	Адаптирует `Collector`, принимающий элементы типа `U` к приёму элементов типа `T`, применяя функцию плоского отображения к каждому входному элементу перед накоплением.
`static <T, K> Collector<T,?,Map<K,List<T>>>`	`groupingBy(Function<? super T,? extends K> classifier)`	Возвращает `Collector`, реализующий операцию «группировка по» над входными элементами типа `T`, группируя элементы согласно функции классификации и возвращая результаты в `Map`.
`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)`	Возвращает конкуретную `Collector`, реализующую операцию «группировка по» над входными элементами типа `T`, группируя элементы согласно функции классификации.
`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()`	Возвращает `Collector`, который конкатенирует входные элементы в `String` в порядке встречи.
`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)`	Адаптирует `Collector`, принимающий элементы типа `U`, к приёму элементов типа `T`, применяя функцию отображения к каждому входному элементу перед накоплением.
`static <T> Collector<T,?,Optional<T>>`	`maxBy(Comparator<? super T> comparator)`	Возвращает `Collector`, который производит максимальный элемент согласно заданной `Comparator`, описанной как `Optional<T>`.
`static <T> Collector<T,?,Optional<T>>`	`minBy(Comparator<? super T> comparator)`	Возвращает `Collector`, который производит минимальный элемент согласно заданной `Comparator`, описанной как `Optional<T>`.
`static <T> Collector<T,?,Map<Boolean,List<T>>>`	`partitioningBy(Predicate<? super T> predicate)`	Возвращает `Collector`, который разделяет входные элементы по `Predicate` и организует их в `Map<Boolean, List<T>>`.
`static <T, D, A> Collector<T,?,Map<Boolean,D>>`	`partitioningBy(Predicate<? super T> predicate, Collector<? super T,A,D> downstream)`	Возвращает `Collector`, который разделяет входные элементы по `Predicate`, уменьшает значения в каждой группе согласно другой `Collector` и организует их в `Map<Boolean, D>`, значения которого являются результатом последующего сокращения.
`static <T> Collector<T,?,Optional<T>>`	`reducing(BinaryOperator<T> op)`	Возвращает `Collector`, который выполняет сокращение входных элементов согласно указанному `BinaryOperator`.
`static <T> Collector<T,?,T>`	`reducing(T identity, BinaryOperator<T> op)`	Возвращает `Collector`, который выполняет сокращение входных элементов согласно указанному `BinaryOperator`, используя предоставленную идентичность.
`static <T, U> Collector<T,?,U>`	`reducing(U identity, Function<? super T,? extends U> mapper, BinaryOperator<U> op)`	Возвращает `Collector`, который выполняет сокращение входных элементов согласно указанной функции отображения и `BinaryOperator`.
`static <T> Collector<T,?,DoubleSummaryStatistics>`	`summarizingDouble(ToDoubleFunction<? super T> mapper)`	Возвращает `Collector`, который применяет функцию отображения, производящую `double` к каждому входному элементу и возвращает сводные статистические данные для полученных значений.
`static <T> Collector<T,?,IntSummaryStatistics>`	`summarizingInt(ToIntFunction<? super T> mapper)`	Возвращает `Collector`, который применяет функцию отображения, производящую `int` к каждому входному элементу и возвращает сводные статистические данные для полученных значений.
`static <T> Collector<T,?,LongSummaryStatistics>`	`summarizingLong(ToLongFunction<? super T> mapper)`	Возвращает `Collector`, который применяет функцию отображения, производящую `long` к каждому входному элементу и возвращает сводные статистические данные для полученных значений.
`static <T> Collector<T,?,Double>`	`summingDouble(ToDoubleFunction<? super T> mapper)`	Возвращает `Collector`, который производит сумму значения функции от двойного типа, применённой к входным элементам.
`static <T> Collector<T,?,Integer>`	`summingInt(ToIntFunction<? super T> mapper)`	Возвращает `Collector`, который производит сумму значения функции от целого типа, применённой к входным элементам.
`static <T> Collector<T,?,Long>`	`summingLong(ToLongFunction<? super T> mapper)`	Возвращает `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)`	Возвращает `Collector`, который представляет собой композицию двух последующих коллекторов.
`static <T, C extends Collection<T>> Collector<T,?,C>`	`toCollection(Supplier<C> collectionFactory)`	Возвращает `Collector`, который накапливает входные элементы в новый `Collection` в порядке встречи.
`static <T, K, U> Collector<T,?,ConcurrentMap<K,U>>`	`toConcurrentMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)`	Возвращает конкуретную `Collector`, которая накапливает элементы в `ConcurrentMap`, ключи и значения которого являются результатом применения предоставленных функций отображения к входным элементам.
`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)`	Возвращает конкуретную `Collector`, которая накапливает элементы в `ConcurrentMap`, ключи и значения которого являются результатом применения предоставленных функций отображения к входным элементам.
`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)`	Возвращает конкуретную `Collector`, которая накапливает элементы в `ConcurrentMap`, ключи и значения которого являются результатом применения предоставленных функций отображения к входным элементам.
`static <T> Collector<T,?,List<T>>`	`toList()`	Возвращает `Collector`, который накапливает входные элементы в новый `List`.
`static <T, K, U> Collector<T,?,Map<K,U>>`	`toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)`	Возвращает `Collector`, который накапливает элементы в `Map`, ключи и значения которого являются результатом применения предоставленных функций отображения к входным элементам.
`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)`	Возвращает `Collector`, который накапливает элементы в `Map`, ключи и значения которого являются результатом применения предоставленных функций отображения к входным элементам.

`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)`	Возвращает `Collector`, который накапливает элементы в `Map`, ключи и значения которого являются результатом применения предоставленных функций отображения к входным элементам.
`static <T> Collector<T,?,Set<T>>`	`toSet()`	Возвращает `Collector`, который накапливает входные элементы в новый `Set`.
`static <T> Collector<T,?,List<T>>`	`toUnmodifiableList()`	Возвращает `Collector`, который накапливает входные элементы в неизменяемый список List в порядке их появления.
`static <T, K, U> Collector<T,?,Map<K,U>>`	`toUnmodifiableMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)`	Возвращает `Collector`, который накапливает входные элементы в неизменяемый словарь Map, ключи и значения которого являются результатом применения предоставленных функций отображения к входным элементам.
`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`, который накапливает входные элементы в неизменяемый словарь Map, ключи и значения которого являются результатом применения предоставленных функций отображения к входным элементам.
`static <T> Collector<T,?,Set<T>>`	`toUnmodifiableSet()`	Возвращает `Collector`, который накапливает входные элементы в неизменяемый набор Set.

Методы, объявленные в классе java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Подробное описание методов

toCollection

public static <T, C extends Collection<T>> Collector<T,?,C> toCollection(Supplier<C> collectionFactory)

Возвращает Collector, который накапливает входные элементы в новую Collection в порядке их появления. Collection создаётся предоставленным фабричным методом.

Параметры типа:: T - тип входных элементов; C - тип результирующей Collection
Параметры:: collectionFactory - поставщик, предоставляющий новую пустую Collection, в которую будут вставлены результаты
Возвращаемое значение:: Collector, который собирает все входные элементы в Collection в порядке их появления

toList

public static <T> Collector<T,?,List<T>> toList()

Возвращает Collector, который накапливает входные элементы в новый List. Нет гарантий по типу, изменяемости, сериализуемости или потокобезопасности возвращаемого List; если требуется больший контроль над возвращаемым List, используйте toCollection(Supplier).

Параметры типа:: T - тип входных элементов
Возвращаемое значение:: Collector, который собирает все входные элементы в List в порядке их появления

toUnmodifiableList

public static <T> Collector<T,?,List<T>> toUnmodifiableList()

Возвращает Collector, который накапливает входные элементы в неизменяемый список List в порядке их появления. Возвращаемый коллектор не допускает null-значений и будет выбрасывать NullPointerException, если встретится null-значение.

Параметры типа:: T - тип входных элементов
Возвращаемое значение:: Collector, который накапливает входные элементы в неизменяемый список List в порядке их появления
С:: 10

toSet

public static <T> Collector<T,?,Set<T>> toSet()

Возвращает Collector, который накапливает входные элементы в новый Set. Нет гарантий по типу, изменяемости, сериализуемости или потокобезопасности возвращаемого Set; если требуется больший контроль над возвращаемым Set, используйте toCollection(Supplier).

Это unordered коллектор.

Параметры типа:: T - тип входных элементов
Возвращаемое значение:: Collector, который собирает все входные элементы в Set

toUnmodifiableSet

public static <T> Collector<T,?,Set<T>> toUnmodifiableSet()

Возвращает Collector, который накапливает входные элементы в неизменяемый набор Set. Возвращаемый коллектор не допускает null-значений и будет выбрасывать NullPointerException, если встретится null-значение. Если вход содержит дубликаты, сохраняется произвольный элемент из дубликатов.

Это unordered коллектор.

Параметры типа:: T - тип входных элементов
Возвращаемое значение:: Collector, который накапливает входные элементы в неизменяемый набор Set
С:: 10

joining

public static Collector<CharSequence,?,String> joining()

Возвращает Collector, который конкатенирует входные элементы в строку в порядке их появления.

Возвращаемое значение:: Collector, который конкатенирует входные элементы в строку в порядке их появления

joining

public static Collector<CharSequence,?,String> joining(CharSequence delimiter)

Возвращает Collector, который конкатенирует входные элементы, разделенные указанным разделителем, в порядке их появления.

Параметры:: delimiter - разделитель, используемый между элементами
Возвращаемое значение:: Collector, который конкатенирует элементы CharSequence, разделенные указанным разделителем, в порядке их появления

joining

public static Collector<CharSequence,?,String> joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)

Возвращает Collector, который конкатенирует входные элементы, разделенные указанным разделителем, с указанным префиксом и суффиксом, в порядке их появления.

Параметры:: delimiter - разделитель, используемый между элементами; prefix - последовательность символов, используемая в начале объединённого результата; suffix - последовательность символов, используемая в конце объединённого результата
Возвращаемое значение:: Collector, который конкатенирует элементы CharSequence, разделенные указанным разделителем, в порядке их появления

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, на тот, который принимает элементы типа 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)

Изменяет Collector, принимающий элементы типа U, на тот, который принимает элементы типа 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 - коллектор, который получит элементы потока, возвращенного отображающей функцией

Возвращаемое значение:

коллектор, который применяет функцию отображения к входным элементам и предоставляет плоские отображенные результаты коллектору вниз по потоку

С:

filtering

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

Изменяет Collector на тот, который принимает элементы того же типа T, применяя предикат к каждому входному элементу и накапливая только если предикат возвращает true.

Примечание 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 - коллектор, который будет принимать значения, соответствующие предикату

Возвращаемое значение:

коллектор, который применяет предикат к входным элементам и предоставляет соответствующие элементы коллектору вниз по потоку

С:

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()

Возвращает Collector, принимающий элементы типа T, который подсчитывает количество входных элементов. Если элементов нет, результат — 0.

Требования к реализации:

Это даёт результат, эквивалентный:


     reducing(0L, e -> 1L, Long::sum)

Параметры типа:

T - тип входных элементов

Возвращает:

Collector, подсчитывающий входные элементы

minBy

public static <T> Collector<T,?,Optional<T>> minBy(Comparator<? super T> comparator)

Возвращает Collector, который производит минимальный элемент в соответствии с заданным Comparator, описываемым как Optional<T>.

Требования к реализации:

Это даёт результат, эквивалентный:


     reducing(BinaryOperator.minBy(comparator))

Параметры типа:

T - тип входных элементов

Параметры:

comparator - Comparator для сравнения элементов

Возвращает:

Collector, который производит минимальное значение

maxBy

public static <T> Collector<T,?,Optional<T>> maxBy(Comparator<? super T> comparator)

Возвращает Collector, который производит максимальный элемент в соответствии с заданным Comparator, описываемым как Optional<T>.

Требования к реализации:

Это даёт результат, эквивалентный:


     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)

Возвращает Collector, который производит сумму длинного целочисленного значения, применённого к входным элементам. Если элементов нет, результат — 0.

Параметры типа:: T - тип входных элементов
Параметры:: mapper - функция для извлечения свойства, которое будет суммироваться
Возвращает:: Collector, который производит сумму производного свойства

summingDouble

public static <T> Collector<T,?,Double> summingDouble(ToDoubleFunction<? super T> mapper)

Возвращает Collector, который производит сумму функции с двойной точностью, применённой к входным элементам. Если элементов нет, результат — 0.

Возвращаемая сумма может изменяться в зависимости от порядка записи значений из-за накопленной погрешности округления при сложении значений с разными масштабами. Значения, отсортированные по возрастанию абсолютного значения, как правило, дают более точные результаты. Если какое-либо записанное значение является NaN или сумма в какой-то момент является NaN, то сумма будет NaN.

Параметры типа:: T - тип входных элементов
Параметры:: mapper - функция для извлечения свойства, которое будет суммироваться
Возвращает:: Collector, который производит сумму производного свойства

averagingInt

public static <T> Collector<T,?,Double> averagingInt(ToIntFunction<? super T> mapper)

Возвращает Collector, который производит среднее арифметическое целочисленной функции, применённой к входным элементам. Если элементов нет, результат — 0.

Параметры типа:: T - тип входных элементов
Параметры:: mapper - функция для извлечения свойства, которое будет усредняться
Возвращает:: Collector, который производит среднее арифметическое производного свойства

averagingLong

public static <T> Collector<T,?,Double> averagingLong(ToLongFunction<? super T> mapper)

Возвращает Collector, который производит среднее арифметическое длинного целочисленного значения, применённого к входным элементам. Если элементов нет, результат — 0.

Параметры типа:: T - тип входных элементов
Параметры:: mapper - функция для извлечения свойства, которое будет усредняться
Возвращает:: Collector, который производит среднее арифметическое производного свойства

averagingDouble

public static <T> Collector<T,?,Double> averagingDouble(ToDoubleFunction<? super T> mapper)

Возвращает Collector, который производит среднее арифметическое функции с двойной точностью, применённой к входным элементам. Если элементов нет, результат — 0.

Возвращаемое среднее может изменяться в зависимости от порядка записи значений из-за накопленной погрешности округления при сложении значений с разными масштабами. Значения, отсортированные по возрастанию абсолютного значения, как правило, дают более точные результаты. Если какое-либо записанное значение является NaN или сумма в какой-то момент является NaN, то среднее значение будет NaN.

Примечание по реализации:: Формат double может представлять все последовательные целые числа в диапазоне от -2⁵³ до 2⁵³. Если в потоке более 2⁵³ значений, делитель в вычислении среднего значения насыщается на 2⁵³, что приводит к дополнительным численным ошибкам.
Параметры типа:: T - тип входных элементов
Параметры:: mapper - функция для извлечения свойства, которое будет усредняться
Возвращает:: Collector, который производит среднее арифметическое производного свойства

reducing

public static <T> Collector<T,?,T> reducing(T identity, BinaryOperator<T> op)

Возвращает Collector, который выполняет редукцию входных элементов в соответствии с заданным BinaryOperator с использованием предоставленного идентификатора.

Примечание API:

Коллекторы reducing() наиболее полезны при использовании в многоуровневой редукции, после groupingBy или partitioningBy. Для выполнения простой редукции на потоке используйте Stream.reduce(Object, BinaryOperator)}.

Параметры типа:

T - тип элемента для входных и выходных данных редукции

Параметры:

identity - идентификационное значение для редукции (также значение, возвращаемое при отсутствии входных элементов)

op - BinaryOperator<T>, используемая для редукции входных элементов

Возвращает:

Collector, который реализует операцию редукции

См. также:

reducing

public static <T> Collector<T,?,Optional<T>> reducing(BinaryOperator<T> op)

Возвращает Collector, который выполняет редукцию входных элементов в соответствии с заданным BinaryOperator. Результат описывается как Optional<T>.

Примечание API:

Например, для потока 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

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

Возвращает Collector, выполняющий редукцию входных элементов по заданной функции отображения и BinaryOperator. Это обобщение reducing(Object, BinaryOperator), позволяющее преобразовать элементы перед редукцией.

API Note:

Коллекторы reducing() наиболее полезны при использовании в многоуровневой редукции, после groupingBy или partitioningBy. Для выполнения простого map-reduce над потоком используйте 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, реализующий операцию map-reduce

См. также:

groupingBy

public static <T, K> Collector<T,?,Map<K,List<T>>> groupingBy(Function<? super T,? extends K> classifier)

Возвращает Collector, реализующий операцию "группировка по" над входными элементами типа T, группируя элементы по функции классификации и возвращая результаты в Map.

Функция классификации отображает элементы в некоторый тип ключа K. Коллектор производит Map<K, List<T>>, ключи которого являются результатами применения функции классификации к входным элементам, а соответствующие значения — List, содержащие входные элементы, которые отображаются на соответствующий ключ по функции классификации.

Тип, изменяемость, сериализуемость или потокобезопасность объектов Map или List не гарантируются.

Требования к реализации:

Это производит результат, аналогичный:


     groupingBy(classifier, toList());

Примечание о реализации:

Возвращаемый Collector не является конкурентным. Для параллельных потоковых конвейеров функция combiner работает путём слияния ключей из одной карты в другую, что может быть дорогостоящей операцией. Если сохранение порядка, в котором элементы появляются в результирующем Map коллекторе, не требуется, использование groupingByConcurrent(Function) может обеспечить лучшую параллельную производительность.

Параметры типа:

T - тип входных элементов

K - тип ключей

Параметры:

classifier - функция классификатора, отображающая входные элементы в ключи

Возвращает:

Collector, реализующий операцию группировки

См. также:

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

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)

Например, чтобы вычислить множество фамилий людей в каждом городе, где имена городов отсортированы:


 Map<City, Set<String>> namesByCity
   = people.stream().collect(
     groupingBy(Person::getCity,
                TreeMap::new,
                mapping(Person::getLastName,
                        toSet())));

Примечание о реализации:

Возвращаемый Collector не является конкурентным. Для параллельных потоковых конвейеров функция combiner работает путём слияния ключей из одной карты в другую, что может быть дорогостоящей операцией. Если сохранение порядка, в котором элементы представлены последующему коллектору, не требуется, использование groupingByConcurrent(Function, Supplier, Collector) может обеспечить лучшую параллельную производительность.

Параметры типа:

T - тип входных элементов

K - тип ключей

D - тип результата последующей редукции

A - промежуточный тип накопления последующего коллектора

M - тип результирующего Map

Параметры:

classifier - функция классификатора, отображающая входные элементы в ключи

mapFactory - поставщик, предоставляющий новую пустую Map, в которую будут вставлены результаты

downstream - Collector, реализующий последующую редукцию

Возвращает:

Collector, реализующий каскадную операцию группировки

См. также:

группировкаПоКонкурентности

public static <T, K> Collector<T,?,ConcurrentMap<K,List<T>>> groupingByConcurrent(Function<? super T,? extends K> classifier)

Возвращает конкурентную Collector, реализующую операцию "группировка по" над входными элементами типа T, группируя элементы в соответствии с функцией классификации.

Это коллектор concurrent и unordered.

Функция классификации сопоставляет элементы с некоторым типом ключа K. Коллектор производит ConcurrentMap<K, List<T>>, ключи которого являются результатом применения функции классификации к входным элементам, а соответствующие значения — это List, содержащие входные элементы, которые отображаются на соответствующий ключ в соответствии с функцией классификации.

Нет гарантий относительно типа, изменяемости или сериализуемости объектов ConcurrentMap или List, возвращаемых, или по поводу потокобезопасности объектов List, возвращаемых.

Требования к реализации:

Это производит результат, похожий на:


     groupingByConcurrent(classifier, toList());

Параметры типа:

T - тип входных элементов

K - тип ключей

Параметры:

classifier - функция классификатора, сопоставляющая входные элементы с ключами

Возвращает:

конкурентную, неупорядоченную Collector, реализующую операцию группировки

См. также:

группировкаПоКонкурентности

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.

Это коллектор concurrent и unordered.

Функция классификации сопоставляет элементы с некоторым типом ключа 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, реализующую каскадную операцию группировки

См. также:

группировкаПоКонкурентности

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)

Это коллектор concurrent и unordered.

Например, для вычисления набора фамилий людей в каждом городе, где имена городов отсортированы:


 ConcurrentMap<City, Set<String>> namesByCity
   = people.stream().collect(
     groupingByConcurrent(Person::getCity,
                          ConcurrentSkipListMap::new,
                          mapping(Person::getLastName,
                                  toSet())));

Параметры типа:

T - тип входных элементов

K - тип ключей

A - промежуточный тип накопления последующего коллектора

D - тип результата последующего сокращения

M - тип результирующего ConcurrentMap

Параметры:

classifier - функция классификатора, сопоставляющая входные элементы с ключами

mapFactory - поставщик, предоставляющий новый пустой ConcurrentMap, в который будут вставлены результаты

downstream - Collector, реализующий последующее сокращение

Возвращает:

конкурентную, неупорядоченную Collector, реализующую каскадную операцию группировки

См. также:

разбиениеПо

public static <T> Collector<T,?,Map<Boolean,List<T>>> partitioningBy(Predicate<? super T> predicate)

Возвращает Collector, который разбивает входные элементы в соответствии с Predicate и организует их в Map<Boolean, List<T>>. Возвращаемая Map всегда содержит отображения для ключей false и true. Нет гарантий относительно типа, изменяемости, сериализуемости или потокобезопасности возвращаемых Map или List.

Примечание API:

Если разбиение не содержит элементов, его значение в результирующей карте будет пустым списком.

Параметры типа:

T - тип входных элементов

Параметры:

predicate - предикат, используемый для классификации входных элементов

Возвращает:

Collector, реализующий операцию разбиения

См. также:

разбиениеПо

public static <T, D, A> Collector<T,?,Map<Boolean,D>> partitioningBy(Predicate<? super T> predicate, Collector<? super T,A,D> downstream)

Возвращает Collector, который разбивает входные элементы в соответствии с Predicate, сокращает значения в каждом разбиении в соответствии с другим Collector и организует их в Map<Boolean, D>, значениями которого являются результат последующего сокращения.

Возвращаемая Map всегда содержит отображения для ключей false и true. Нет гарантий относительно типа, изменяемости, сериализуемости или потокобезопасности возвращаемого Map.

Примечание API:

Если разбиение не содержит элементов, его значение в результирующей карте будет получено путем вызова функции поставщика последующего коллектора, а затем применения функции завершителя.

Параметры типа:

T - тип входных элементов

D - тип результата последующего сокращения

A - промежуточный тип накопления последующего коллектора

Параметры:

predicate - предикат, используемый для классификации входных элементов

downstream - Collector, реализующий последующее сокращение

Возвращает:

Collector, реализующий каскадную операцию разбиения

См. также:

toMap

public static <T, K, U> Collector<T,?,Map<K,U>> toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper)

Возвращает Collector, который накапливает элементы в Map, ключи и значения которого являются результатом применения предоставленных функций отображения к входным элементам.

Если отображенные ключи содержат дубликаты (согласно Object.equals(Object)), при выполнении операции со сбором данных генерируется исключение IllegalStateException. Если отображенные ключи могут иметь дубликаты, используйте toMap(Function, Function, BinaryOperator) вместо этого.

Нет никаких гарантий по типу, мутабельности, сериализуемости или потокобезопасности возвращаемого Map.

API Note:

Часто либо ключ, либо значение являются входными элементами. В этом случае может быть полезен вспомогательный метод 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()));

Implementation Note:

Возвращаемый Collector не является потокобезопасным. Для параллельных потоков данных, функция combiner работает путем объединения ключей одной карты в другую, что может быть дорогостоящей операцией. Если не требуется, чтобы результаты вставлялись в Map в порядке их появления, использование toConcurrentMap(Function, Function) может обеспечить лучшую параллельную производительность.

Type Parameters:

T - тип входных элементов

K - тип выходного значения функции отображения ключей

U - тип выходного значения функции отображения значений

Parameters:

keyMapper - функция отображения для создания ключей

valueMapper - функция отображения для создания значений

Returns:

Collector, который собирает элементы в Map, ключи и значения которого являются результатом применения функций отображения к входным элементам

See Also:

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, будет выброшено исключение NullPointerException.

Type Parameters:

T - тип входных элементов

K - тип выходного значения функции отображения ключей

U - тип выходного значения функции отображения значений

Parameters:

keyMapper - функция отображения для создания ключей, не должна быть null

valueMapper - функция отображения для создания значений, не должна быть null

Returns:

Collector, который накапливает входные элементы в неизменяемую карту, ключи и значения которой являются результатом применения предоставленных функций отображения к входным элементам

Throws:

NullPointerException - если keyMapper или valueMapper равны null

Since:

See Also:

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)

Если отображенные ключи содержат дубликаты (согласно Object.equals(Object)), функция отображения значений применяется к каждому равному элементу, а результаты объединяются с использованием предоставленной функции объединения.

Нет никаких гарантий по типу, мутабельности, сериализуемости или потокобезопасности возвращаемого Map.

API Note:

Существует несколько способов обработки коллизий между несколькими элементами, отображающимися на один и тот же ключ. Другие формы toMap просто используют функцию слияния, которая безусловно выбрасывает исключение, но вы можете легко написать более гибкие политики слияния. Например, если у вас есть поток Person, и вы хотите создать "телефонный справочник", отображающий имя на адрес, но возможно, что у двух человек одинаковые имена, вы можете сделать следующее, чтобы корректно обрабатывать эти коллизии и создать Map, отображающий имена на список адресов:


 Map<String, String> phoneBook
   = people.stream().collect(
     toMap(Person::getName,
           Person::getAddress,
           (s, a) -> s + ", " + a));

Implementation Note:

Возвращаемый Collector не является потокобезопасным. Для параллельных потоков данных, функция combiner работает путем слияния ключей одной карты в другую, что может быть дорогостоящей операцией. Если не требуется, чтобы результаты сливались в Map в порядке их появления, использование toConcurrentMap(Function, Function, BinaryOperator) может обеспечить лучшую параллельную производительность.

Type Parameters:

T - тип входных элементов

K - тип выходного значения функции отображения ключей

U - тип выходного значения функции отображения значений

Parameters:

keyMapper - функция отображения для создания ключей

valueMapper - функция отображения для создания значений

mergeFunction - функция слияния, используемая для разрешения коллизий между значениями, связанными с одним ключом, как в Map.merge(Object, Object, BiFunction)

Returns:

Collector, который собирает элементы в Map, ключи которого являются результатом применения функции отображения ключей к входным элементам, а значения — результатом применения функции отображения значений ко всем входным элементам, равным ключу, и объединения их с помощью функции слияния

See Also:

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)

Type Parameters:

T - тип входных элементов

K - тип выходного значения функции отображения ключей

U - тип выходного значения функции отображения значений

Parameters:

keyMapper - функция отображения для создания ключей, не должна быть null

valueMapper - функция отображения для создания значений, не должна быть null

mergeFunction - функция слияния, используемая для разрешения коллизий между значениями, связанными с одним ключом, как в Map.merge(Object, Object, BiFunction), не должна быть null

Returns:

Throws:

NullPointerException - если keyMapper, valueMapper или mergeFunction равны null

Since:

See Also:

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)

Если отображённые ключи содержат дубликаты (в соответствии с 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, в которую будут вставлены результаты

Возвращаемое значение:

Collector, который собирает элементы в 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)

Возвращает конкурентный Collector, который накапливает элементы в ConcurrentMap, ключи и значения которого являются результатом применения предоставленных функций отображения к входным элементам.

Если отображённые ключи содержат дубликаты (в соответствии с 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()));

Это concurrent и unordered коллектор.

Параметры типа:

T - тип входных элементов

K - тип выходного значения функции отображения ключа

U - тип выходного значения функции отображения значения

Параметры:

keyMapper - функция отображения для создания ключей

valueMapper - функция отображения для создания значений

Возвращаемое значение:

конкурентный, неупорядоченный Collector, который собирает элементы в ConcurrentMap, ключи которого являются результатом применения функции отображения ключа к входным элементам, а значения — результатом применения функции отображения значения к входным элементам

См. также:

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 не гарантируются.

Примечание API:

Существует несколько способов обработки коллизий между несколькими элементами, отображаемыми на один и тот же ключ. Другие формы toConcurrentMap просто используют функцию слияния, которая безусловно выбрасывает исключение, но вы легко можете написать более гибкие политики слияния. Например, если у вас есть поток Person, и вы хотите создать «телефонный справочник», отображающий имя на адрес, но возможно, что у двух человек одинаковое имя, вы можете сделать следующее, чтобы справиться с этими коллизиями и создать ConcurrentMap, отображающий имена на конкатенированный список адресов:


 ConcurrentMap<String, String> phoneBook
   = people.stream().collect(
     toConcurrentMap(Person::getName,
                     Person::getAddress,
                     (s, a) -> s + ", " + a));

Это concurrent и unordered коллектор.

Параметры типа:

T - тип входных элементов

K - тип выходного значения функции отображения ключа

U - тип выходного значения функции отображения значения

Параметры:

keyMapper - функция отображения для создания ключей

valueMapper - функция отображения для создания значений

Возвращаемое значение:

См. также:

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)

Возвращает конкурирующее Collector, которое накапливает элементы в ConcurrentMap, ключи и значения которого являются результатом применения предоставленных функций отображения к входным элементам.

Если отображённые ключи содержат дубликаты (в соответствии с Object.equals(Object)), функция отображения значений применяется к каждому совпадающему элементу, а результаты объединяются с помощью предоставленной функции слияния. ConcurrentMap создаётся с помощью предоставленной функции поставщика.

Это коллектор concurrent и unordered.

Type Parameters:

T - тип входных элементов

K - выходной тип функции отображения ключей

U - выходной тип функции отображения значений

M - тип результирующего ConcurrentMap

Parameters:

keyMapper - функция отображения для создания ключей

valueMapper - функция отображения для создания значений

mergeFunction - функция слияния, используемая для разрешения коллизий между значениями, связанными с одним ключом, как предоставлено в Map.merge(Object, Object, BiFunction)

mapFactory - поставщик, предоставляющий новую пустую ConcurrentMap, в которую будут вставлены результаты

Returns:

конкурирующее, неупорядоченное Collector, которое собирает элементы в ConcurrentMap, ключи которого являются результатом применения функции отображения ключей к входным элементам, а значения — результатом применения функции отображения значений ко всем входным элементам, равным ключу, и объединения их с помощью функции слияния

See Also:

summarizingInt

public static <T> Collector<T,?,IntSummaryStatistics> summarizingInt(ToIntFunction<? super T> mapper)

Возвращает Collector, которая применяет функцию отображения, производящую целочисленные значения, к каждому входному элементу и возвращает статистические данные о полученных значениях.

Type Parameters:

T - тип входных элементов

Parameters:

mapper - функция отображения, применяемая к каждому элементу

Returns:

Collector, реализующая сводную статистику

See Also:

summarizingLong

public static <T> Collector<T,?,LongSummaryStatistics> summarizingLong(ToLongFunction<? super T> mapper)

Возвращает Collector, которая применяет функцию отображения, производящую значения типа long, к каждому входному элементу и возвращает статистические данные о полученных значениях.

Type Parameters:

T - тип входных элементов

Parameters:

mapper - функция отображения, применяемая к каждому элементу

Returns:

Collector, реализующая сводную статистику

See Also:

summarizingDouble

public static <T> Collector<T,?,DoubleSummaryStatistics> summarizingDouble(ToDoubleFunction<? super T> mapper)

Возвращает Collector, которая применяет функцию отображения, производящую значения типа double, к каждому входному элементу и возвращает статистические данные о полученных значениях.

Type Parameters:

T - тип входных элементов

Parameters:

mapper - функция отображения, применяемая к каждому элементу

Returns:

Collector, реализующая сводную статистику

See Also:

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)

Возвращает Collector, которая является композицией двух коллекторов по обработке данных. Каждый элемент, переданный в результирующий коллектор, обрабатывается обоими коллекторами, а затем их результаты объединяются с помощью указанной функции слияния в окончательный результат.

Результирующий коллектор выполняет следующие действия:

поставщик: создаёт контейнер результата, содержащий контейнеры результатов, полученные при вызове поставщика каждого коллектора
аккумулятор: вызывает аккумулятор каждого коллектора с его контейнером результата и входным элементом
комбинатор: вызывает комбинатор каждого коллектора с двумя контейнерами результатов
завершающий обработчик: вызывает завершающий обработчик каждого коллектора с его контейнером результата, а затем вызывает предоставленный объединитель и возвращает его результат.

Получающийся коллектор является Collector.Characteristics.UNORDERED, если оба коллектора по обработке данных являются неупорядоченными, и Collector.Characteristics.CONCURRENT, если оба коллектора по обработке данных являются конкурирующими.

Type Parameters:: T - тип входных элементов; R1 - тип результата первого коллектора; R2 - тип результата второго коллектора; R - тип окончательного результата
Parameters:: downstream1 - первый коллектор по обработке данных; downstream2 - второй коллектор по обработке данных; merger - функция, которая объединяет два результата в один
Returns:: Collector, который агрегирует результаты двух предоставленных коллекторов.
Since:: 12

© 1993, 2023, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.
https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/stream/Collectors.html