Класс 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));

С:: 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 создается предоставленным фабричным методом.

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

toList

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

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

Type Parameters:: T - тип входных элементов
Returns:: Collector, который собирает все входные элементы в List в порядке их появления

toUnmodifiableList

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

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

Type Parameters:: T - тип входных элементов
Returns:: Collector, который накапливает входные элементы в неизменяемый список (неизменяемый список) в порядке их появления
Since:: 10

toSet

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

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

Это unordered сборщик.

Type Parameters:: T - тип входных элементов
Returns:: Collector, который собирает все входные элементы в Set

toUnmodifiableSet

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

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

Это unordered сборщик.

Type Parameters:: T - тип входных элементов
Returns:: Collector, который накапливает входные элементы в неизменяемое множество (неизменяемое множество)
Since:: 10

joining

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

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

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

joining

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

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

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

joining

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

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

Parameters:: delimiter - разделитель, используемый между элементами; prefix - последовательность символов, используемая в начале объединенного результата; suffix - последовательность символов, используемая в конце объединенного результата
Returns:: 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, в Collector, принимающий элементы типа T, применяя функцию преобразования к каждому входному элементу перед накоплением.

API Note:

Коллекторы mapping() наиболее полезны при многоуровневом сокращении, например, после потока groupingBy или partitioningBy. Например, задан поток Person, для накопления набора фамилий в каждом городе:


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

Type Parameters:

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

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

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

R - тип результата коллектора

Parameters:

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

downstream - коллектор, который будет принимать преобразованные значения

Returns:

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

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, в Collector, принимающий элементы типа T, применяя плоскую функцию преобразования к каждому входному элементу перед накоплением. Функция плоского преобразования преобразует входной элемент в поток (stream), охватывающий ноль или более выходных элементов, которые затем накапливаются вниз по потоку. Каждый преобразованный поток closed после того, как его содержимое будет помещено вниз по потоку. (Если преобразованный поток null, используется пустой поток вместо него.)

API Note:

Коллекторы flatMapping() наиболее полезны при многоуровневом сокращении, например, после потока groupingBy или partitioningBy. Например, задан поток Order, для накопления набора позиций для каждого клиента:


 Map<String, Set<LineItem>> itemsByCustomerName
   = orders.stream().collect(
     groupingBy(Order::getCustomerName,
                flatMapping(order -> order.getLineItems().stream(),
                            toSet())));

Type Parameters:

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

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

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

R - тип результата коллектора

Parameters:

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

downstream - коллектор, который получит элементы потока, возвращенного отображением

Returns:

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

Since:

фильтрация

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

счет

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, который производит среднее арифметическое производного свойства

усреднениеПоДвойному

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

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

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

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

редуцирование

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, реализующий операцию редукции

См. также:

редуцирование

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, который реализует операцию редукции

См. также:

редуцирование

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:

Коллекторы 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

См. также:

группировкаПо

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, реализующий операцию группировки

См. также:

группировкаПоКлючу

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, реализующий каскадную операцию группировки по ключу

См. также:

группировкаПоКлючу

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:

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

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

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:

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

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

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)

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

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

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

API Note:

Часто либо ключ, либо значение являются входными элементами. В этом случае может быть полезна служебная функция Function.identity(). Например, следующее создает a Map, отображающую студентов на их средний балл:


 Map<Student, Double> studentToGPA
   = students.stream().collect(
     toMap(Function.identity(),
           student -> computeGPA(student)));

А следующее создает a 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:

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

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

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

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

Type Parameters:

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

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

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

Parameters:

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

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

Returns:

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

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

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:

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

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

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

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

Type Parameters:

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

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

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

Parameters:

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

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

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

Returns:

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

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)

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

Implementation Note:

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

Type Parameters:

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

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

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

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

Parameters:

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

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

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

Returns:

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

See Also:

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 Note:

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

Type Parameters:

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

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

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

Parameters:

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

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

Returns:

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

See Also:

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)

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

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

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

API Note:

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


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

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

Type Parameters:

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

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

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

Parameters:

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

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

Returns:

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

See Also:

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)

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

Type Parameters:

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

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

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

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

Parameters:

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

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

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

Returns:

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, являющийся композицией двух коллекторов по потоку данных. Каждый элемент, переданный в результирующий коллектор, обрабатывается обоими коллекторами по потоку данных, а затем их результаты объединяются с помощью указанной функции слияния в окончательный результат.

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

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

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

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

© 1993, 2025, 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://download.java.net/java/early_access/jdk24/docs/api/java.base/java/util/stream/Collectors.html