Класс 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,​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, который накапливает входные элементы в неизменяемый список unmodifiable List в порядке их появления.

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

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

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

Возвращает Collector, который накапливает входные элементы в неизменяемое множество unmodifiable 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 в порядке их появления. Возвращаемый коллектор не допускает нулевые значения и выбросит NullPointerException если ему передано нулевое значение.

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

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

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

collectingAndThen

public static <T,A,​R,​RR> Collector<T,​A,​RR> collectingAndThen​(Collector<T,​A,​R> downstream,
                                                                                           Function<R,​RR> finisher)

Преобразует Collector для выполнения дополнительного завершающего преобразования. Например, можно преобразовать коллектор toList() для создания всегда неизменяемого списка с помощью:

List<String> list = people.stream().collect(
   collectingAndThen(toList(),
                     Collections::unmodifiableList));

Параметры типа:
T - тип входных элементов
A - промежуточный тип накопления последующего коллектора
R - тип результата последующего коллектора
RR - тип результата результирующего коллектора
Параметры:
downstream - коллектор
finisher - функция, применяемая к окончательному результату последующего коллектора
Возвращаемое значение:
коллектор, который выполняет действие последующего коллектора, а затем выполняет дополнительный завершающий шаг

counting

public static <T> Collector<T,?,​Long> counting()

Возвращает 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 может представлять все последовательные целые числа в диапазоне от -253 до 253. Если в конвейере более чем 253 значений, делитель в вычислении среднего значения будет насыщаться значением 253, что приведёт к дополнительным числовым ошибкам.
Параметры типа:
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(BinaryOperator), reducing(Object, Function, BinaryOperator)

reducing

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

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

Примечание к API:
Коллекторы reducing() наиболее полезны при использовании в многоуровневом сокращении, после groupingBy или partitioningBy. Для выполнения простого сокращения на потоке используйте Stream.reduce(BinaryOperator) вместо этого.

Например, для потока Person, чтобы вычислить самого высокого человека в каждом городе:

Comparator<Person> byHeight = Comparator.comparing(Person::getHeight);
 Map<City, Optional<Person>> tallestByCity
   = people.stream().collect(
     groupingBy(Person::getCity,
                reducing(BinaryOperator.maxBy(byHeight))));
Параметры типа:
T - тип элемента для ввода и вывода сокращения
Параметры:
op - BinaryOperator<T> для сокращения входных элементов
Возвращает:
Collector , который реализует операцию сокращения
См. также:
reducing(Object, BinaryOperator), reducing(Object, Function, BinaryOperator)

reducing

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

Возвращает 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
См. также:
reducing(Object, BinaryOperator), reducing(BinaryOperator)

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(Function, Collector), groupingBy(Function, Supplier, Collector), groupingByConcurrent(Function)

groupingBy

public static <T,K,​A,​D> Collector<T,​?,​Map<K,​D>> groupingBy​(Function<? super T,​? extends K> classifier,
                                                                                               Collector<? super T,​A,​D> downstream)

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

Функция классификации сопоставляет элементы с некоторым типом ключа K. Последующий сборщик работает с элементами типа T и производит результат типа D. Результирующий сборщик создает Map<K, D>.

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

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

Map<City, Set<String>> namesByCity
   = people.stream().collect(
     groupingBy(Person::getCity,
                mapping(Person::getLastName,
                        toSet())));
Примечание по реализации:
Возвращаемый Collector не является потокобезопасным. Для параллельных потоков данных функция combiner работает путем слияния ключей из одной карты в другую, что может быть дорогостоящей операцией. Если сохранение порядка, в котором элементы представлены последующему сборщику, не требуется, использование groupingByConcurrent(Function, Collector) может обеспечить лучшую параллельную производительность.
Параметры типа:
T - тип входных элементов
K - тип ключей
A - промежуточный тип накопления последующего сборщика
D - тип результата последующего сокращения
Параметры:
classifier - функция классификации, отображающая входные элементы в ключи
downstream - Collector , реализующий последующее сокращение
Возвращаемое значение:
Collector , реализующий каскадную операцию группировки
См. также:
groupingBy(Function), groupingBy(Function, Supplier, Collector), groupingByConcurrent(Function, Collector)

groupingBy

public static <T,K,​D,​A,​M extends Map<K,​D>> Collector<T,​?,​M> groupingBy​(Function<? super T,​? extends K> classifier,
                                                                                                                 Supplier<M> mapFactory,
                                                                                                                 Collector<? super T,​A,​D> downstream)

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

Функция классификации сопоставляет элементы с некоторым типом ключа K. Последующий сборщик работает с элементами типа T и производит результат типа D. Результирующий сборщик создает Map<K, D>.

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

Map<City, Set<String>> namesByCity
   = people.stream().collect(
     groupingBy(Person::getCity,
                TreeMap::new,
                mapping(Person::getLastName,
                        toSet())));
Примечание по реализации:
Возвращаемый Collector не является потокобезопасным. Для параллельных потоков данных функция combiner работает путем слияния ключей из одной карты в другую, что может быть дорогостоящей операцией. Если сохранение порядка, в котором элементы предоставляются последующему сборщику, не требуется, использование groupingByConcurrent(Function, Supplier, Collector) может обеспечить лучшую параллельную производительность.
Параметры типа:
T - тип входных элементов
K - тип ключей
A - промежуточный тип накопления последующего сборщика
D - тип результата последующего сокращения
M - тип результирующего Map
Параметры:
classifier - функция классификации, отображающая входные элементы в ключи
downstream - Collector , реализующий последующее сокращение
mapFactory - поставщик, предоставляющий новый пустой Map , в который будут вставлены результаты
Возвращаемое значение:
Collector , реализующий каскадную операцию группировки
См. также:
groupingBy(Function, Collector), groupingBy(Function), groupingByConcurrent(Function, Supplier, Collector)

groupingByConcurrent

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

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

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

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

Гарантии по типу, изменяемости, сериализуемости объектов ConcurrentMap или List или потоковой безопасности объектов List отсутствуют.

Требования к реализации:
Это создает результат, похожий на:
groupingByConcurrent(classifier, toList());
Параметры типа:
T - тип входных элементов
K - тип ключей
Параметры:
classifier - функция классификации, отображающая входные элементы в ключи
Возвращаемое значение:
конкурентный, неупорядоченный Collector , реализующий операцию группировки
См. также:
groupingBy(Function), groupingByConcurrent(Function, Collector), groupingByConcurrent(Function, Supplier, Collector)

groupingByConcurrent

public static <T,K,​A,​D> Collector<T,​?,​ConcurrentMap<K,​D>> groupingByConcurrent​(Function<? super T,​? extends K> classifier,
                                                                                                                   Collector<? super T,​A,​D> downstream)

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

Это 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, реализующий каскадное группирование по ключу
См. также:
groupingBy(Function, Collector), groupingByConcurrent(Function), groupingByConcurrent(Function, Supplier, Collector)

groupingByConcurrent

public static <T,K,​A,​D,​M extends ConcurrentMap<K,​D>> Collector<T,​?,​M> groupingByConcurrent​(Function<? super T,​? extends K> classifier,
                                                                                                                                     Supplier<M> mapFactory,
                                                                                                                                     Collector<? super T,​A,​D> downstream)

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

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

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

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

ConcurrentMap<City, Set<String>> namesByCity
   = people.stream().collect(
     groupingByConcurrent(Person::getCity,
                          ConcurrentSkipListMap::new,
                          mapping(Person::getLastName,
                                  toSet())));
Параметры типа:
T - тип входных элементов
K - тип ключей
A - промежуточный тип накопления дочернего коллектора
D - тип результата дочернего сокращения
M - тип результирующего ConcurrentMap
Параметры:
classifier - функция классификации, отображающая входные элементы в ключи
downstream - Collector коллектор, реализующий дочернее сокращение
mapFactory - поставщик, предоставляющий новый пустой ConcurrentMap для вставки результатов
Возвращает:
конкурентный, неупорядоченный Collector, реализующий каскадное группирование по ключу
См. также:
groupingByConcurrent(Function), groupingByConcurrent(Function, Collector), groupingBy(Function, Supplier, Collector)

partitioningBy

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

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

Примечание API:
Если у раздела нет элементов, его значение в результирующем Map будет пустым списком.
Параметры типа:
T - тип входных элементов
Параметры:
predicate - предикат, используемый для классификации входных элементов
Возвращает:
Collector реализующий операцию разделения
См. также:
partitioningBy(Predicate, Collector)

partitioningBy

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

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

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

Примечание API:
Если у раздела нет элементов, его значение в результирующем Map будет получено путём вызова функции-поставщика дочернего коллектора, а затем применения функции-финишера.
Параметры типа:
T - тип входных элементов
A - промежуточный тип накопления дочернего коллектора
D - тип результата дочернего сокращения
Параметры:
predicate - предикат, используемый для классификации входных элементов
downstream - Collector коллектор, реализующий дочернее сокращение
Возвращает:
Collector реализующий каскадную операцию разделения
См. также:
partitioningBy(Predicate)

toMap

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

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

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

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

Примечание API:
Обычно ключ или значение являются входными элементами. В этом случае может быть полезна вспомогательная функция Function.identity(). Например, следующее производит Map отображения студентов на их средний балл:
Map<Student, Double> studentToGPA
   = students.stream().collect(
     toMap(Function.identity(),
           student -> computeGPA(student)));
И следующее производит Map отображения уникального идентификатора на студентов:
Map<String, Student> studentIdToStudent
   = students.stream().collect(
     toMap(Student::getId,
           Function.identity()));
Примечание реализации:
Возвращаемый Collector не является конкурентным. Для потоков параллельных строк функция combiner работает путём слияния ключей из одного отображения в другое, что может быть дорогостоящей операцией. Если не требуется, чтобы результаты вставлялись в Map в порядке их появления, использование toConcurrentMap(Function, Function) может предложить лучшую параллельную производительность.
Параметры типа:
T - тип входных элементов
K - тип выходного значения функции отображения ключей
U - тип выходного значения функции отображения значений
Параметры:
keyMapper - функция отображения для получения ключей
valueMapper - функция отображения для получения значений
Возвращает:
Collector который собирает элементы в Map, ключи и значения которого являются результатом применения функций отображения к входным элементам
См. также:
toMap(Function, Function, BinaryOperator), toMap(Function, Function, BinaryOperator, Supplier), toConcurrentMap(Function, Function)

toUnmodifiableMap

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

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

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

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

Параметры типа:
T - тип входных элементов
K - тип выходного значения функции отображения ключей
U - тип выходного значения функции отображения значений
Параметры:
keyMapper - функция отображения для получения ключей, не должна быть null
valueMapper - функция отображения для получения значений, не должна быть null
Возвращает:
Collector который накапливает входные элементы в неизменяемое отображение Map, ключи и значения которого являются результатом применения предоставленных функций отображения к входным элементам
Исключения:
NullPointerException - если keyMapper или valueMapper равны null
С тех пор:
10
См. также:
toUnmodifiableMap(Function, Function, BinaryOperator)

toMap

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

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

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

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

Примечание API:
Существует несколько способов обработки коллизий между несколькими элементами, отображающимися на один и тот же ключ. Другие формы toMap просто используют функцию объединения, которая безусловно выбрасывает исключение, но вы можете легко написать более гибкие политики объединения. Например, если у вас есть поток Person, и вы хотите создать «телефонный справочник», отображающий имя на адрес, но возможно, что у двух человек одинаковое имя, вы можете сделать следующее, чтобы элегантно обработать эти коллизии и создать Map отображение имен на конкатенированный список адресов:
Map<String, String> phoneBook
   = people.stream().collect(
     toMap(Person::getName,
           Person::getAddress,
           (s, a) -> s + ", " + a));
Примечание реализации:
Возвращаемое Collector не является потокобезопасным. Для конвейеров параллельных потоков функция combiner работает путем слияния ключей одной карты в другую, что может быть дорогостоящей операцией. Если не требуется, чтобы результаты сливались в Map в порядке их появления, использование toConcurrentMap(Function, Function, BinaryOperator) может обеспечить лучшую производительность в параллельных потоках.
Параметры типа:
T - тип входных элементов
K - тип выходного значения функции отображения ключа
U - тип выходного значения функции отображения значения
Параметры:
keyMapper - функция отображения для создания ключей
valueMapper - функция отображения для создания значений
mergeFunction - функция объединения, используемая для разрешения коллизий между значениями, связанными с одним и тем же ключом, как передается в Map.merge(Object, Object, BiFunction)
Возвращает:
Collector, который собирает элементы в Map, где ключи являются результатом применения функции отображения ключа к входным элементам, а значения — результатом применения функции отображения значения ко всем входным элементам, равным ключу, и объединения их с помощью функции объединения
См. также:
toMap(Function, Function), toMap(Function, Function, BinaryOperator, Supplier), toConcurrentMap(Function, Function, BinaryOperator)

toUnmodifiableMap

public static <T,K,​U> Collector<T,​?,​Map<K,​U>> toUnmodifiableMap​(Function<? super T,​? extends K> keyMapper,
                                                                                              Function<? super T,​? extends U> valueMapper,
                                                                                              BinaryOperator<U> mergeFunction)

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

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

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

Параметры типа:
T - тип входных элементов
K - тип выходного значения функции отображения ключа
U - тип выходного значения функции отображения значения
Параметры:
keyMapper - функция отображения для создания ключей, не должна быть null
valueMapper - функция отображения для создания значений, не должна быть null
mergeFunction - функция объединения, используемая для разрешения коллизий между значениями, связанными с одним и тем же ключом, как передается в Map.merge(Object, Object, BiFunction), не должна быть null
Возвращает:
Collector для накопления входных элементов в неизменяемой карте, ключи и значения которой являются результатом применения указанных функций отображения к входным элементам
Исключения:
NullPointerException - если keyMapper, valueMapper или mergeFunction равны null
С момента:
10
См. также:
toUnmodifiableMap(Function, Function)

toMap

public static <T,K,​U,​M extends Map<K,​U>> Collector<T,​?,​M> toMap​(Function<? super T,​? extends K> keyMapper,
                                                                                                    Function<? super T,​? extends U> valueMapper,
                                                                                                    BinaryOperator<U> mergeFunction,
                                                                                                    Supplier<M> mapFactory)

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

Если сопоставленные ключи содержат дубликаты (в соответствии с 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, где ключи — результат применения функции отображения ключа к входным элементам, а значения — результат применения функции отображения значения ко всем входным элементам, равным ключу, и объединения их с помощью функции объединения
См. также:
toMap(Function, Function), toMap(Function, Function, BinaryOperator), toConcurrentMap(Function, Function, BinaryOperator, Supplier)

toConcurrentMap

public static <T,K,​U> Collector<T,​?,​ConcurrentMap<K,​U>> toConcurrentMap​(Function<? super T,​? extends K> keyMapper,
                                                                                                      Function<? super T,​? extends U> valueMapper)

Возвращает потокобезопасный 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, где ключи являются результатом применения функции отображения ключа к входным элементам, а значения — результатом применения функции отображения значения к входным элементам
См. также:
toMap(Function, Function), toConcurrentMap(Function, Function, BinaryOperator), toConcurrentMap(Function, Function, BinaryOperator, Supplier)

toConcurrentMap

public static <T,K,​U> Collector<T,​?,​ConcurrentMap<K,​U>> toConcurrentMap​(Function<? super T,​? extends K> keyMapper,
                                                                                                      Function<? super T,​? extends U> valueMapper,
                                                                                                      BinaryOperator<U> mergeFunction)

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

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

Гарантии по типу, мутабельности или сериализуемости возвращаемого 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 - функция отображения для генерации значений
mergeFunction - функция объединения, используемая для разрешения коллизий между значениями, связанными с одним и тем же ключом, как и в Map.merge(Object, Object, BiFunction)
Возвращает:
конкурентный, неупорядоченный Collector , который собирает элементы в ConcurrentMap, где ключи являются результатом применения функции отображения ключа к входным элементам, а значения — результатом применения функции отображения значений ко всем входным элементам, равным ключу, и объединения их с помощью функции объединения
См. также:
toConcurrentMap(Function, Function), toConcurrentMap(Function, Function, BinaryOperator, Supplier), toMap(Function, Function, BinaryOperator)

toConcurrentMap

public static <T,K,​U,​M extends ConcurrentMap<K,​U>> Collector<T,​?,​M> toConcurrentMap​(Function<? super T,​? extends K> keyMapper,
                                                                                                                        Function<? super T,​? extends U> valueMapper,
                                                                                                                        BinaryOperator<U> mergeFunction,
                                                                                                                        Supplier<M> mapFactory)

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

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

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

Параметры типа:
T - тип входных элементов
K - тип выходного значения функции отображения ключа
U - тип выходного значения функции отображения значения
M - тип результирующего ConcurrentMap
Параметры:
keyMapper - функция отображения для генерации ключей
valueMapper - функция отображения для генерации значений
mergeFunction - функция объединения, используемая для разрешения коллизий между значениями, связанными с одним и тем же ключом, как и в Map.merge(Object, Object, BiFunction)
mapFactory - поставщик, предоставляющий новый пустой ConcurrentMap, в который будут вставлены результаты
Возвращает:
конкурентный, неупорядоченный Collector , который собирает элементы в ConcurrentMap, где ключи являются результатом применения функции отображения ключа к входным элементам, а значения — результатом применения функции отображения значений ко всем входным элементам, равным ключу, и объединения их с помощью функции объединения
См. также:
toConcurrentMap(Function, Function), toConcurrentMap(Function, Function, BinaryOperator), toMap(Function, Function, BinaryOperator, Supplier)

summarizingInt

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

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

Параметры типа:
T - тип входных элементов
Параметры:
mapper - функция отображения, применяемая к каждому элементу
Возвращает:
Collector реализующий сводную статистическую обработку
См. также:
summarizingDouble(ToDoubleFunction), summarizingLong(ToLongFunction)

summarizingLong

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

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

Параметры типа:
T - тип входных элементов
Параметры:
mapper - функция отображения, применяемая к каждому элементу
Возвращает:
Collector реализующий сводную статистическую обработку
См. также:
summarizingDouble(ToDoubleFunction), summarizingInt(ToIntFunction)

summarizingDouble

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

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

Параметры типа:
T - тип входных элементов
Параметры:
mapper - функция отображения, применяемая к каждому элементу
Возвращает:
Collector реализующий сводную статистическую обработку
См. также:
summarizingLong(ToLongFunction), summarizingInt(ToIntFunction)

© 1993, 2020, 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/11/docs/api/java.base/java/util/stream/Collectors.html

Spec-Zone .ru
спецификации, руководства, описания, API