Spec-Zone.ru › OpenJDK 17

Класс Collectors

java.lang.Object
java.util.stream.Collectors
public final class Collectors extends Object
Реализации Collector, которые реализуют различные полезные операции сокращения, такие как накопление элементов в коллекции, обобщение элементов по различным критериям и т.д.

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


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

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

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

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

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

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

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

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

Modifier and Type Method Description
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, который производит среднее арифметическое значения функции с типом long, применённой к элементам ввода.
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, применяя предикат к каждому элементу ввода и накапливая только если предикат возвращает %%%CODE_BLOCK_24%%。
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, группируя элементы в соответствии с функцией классификации и возвращая результаты в %%%CODE_BLOCK_34%%。
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, который производит сумму значений функции с типом long, применённой к элементам ввода.
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, который накапливает элементы ввода в неизменяемый список 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, который накапливает входные элементы в неизменяемую карту, ключи и значения которой являются результатом применения предоставленных функций отображения к входным элементам.
static <T, K, U> Collector<T,?,Map<K,U>> toUnmodifiableMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper, BinaryOperator<U> mergeFunction)
Возвращает Collector, который накапливает входные элементы в неизменяемую карту, ключи и значения которой являются результатом применения предоставленных функций отображения к входным элементам.
static <T> Collector<T,?,Set<T>> toUnmodifiableSet()
Возвращает Collector, который накапливает входные элементы в неизменяемый набор.

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

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

подсчёт

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)

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

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)

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

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 , реализующий каскадную операцию группировки
См. также:
  • groupingBy(Function)
  • groupingBy(Function, Supplier, Collector)
  • groupingByConcurrent(Function, 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)
Возвращает 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 - коллектор, реализующий операцию сокращения для обработки
mapFactory - поставщик, предоставляющий новый пустой Map для вставки результатов
Возвращаемое значение:
Collector , реализующий каскадную операцию группировки
См. также:
  • groupingBy(Function, Collector)
  • groupingBy(Function)
  • groupingByConcurrent(Function, Supplier, 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 , реализующий операцию группировки
См. также:
  • groupingBy(Function)
  • groupingByConcurrent(Function, Collector)
  • groupingByConcurrent(Function, Supplier, 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, реализующий каскадную операцию группировки по
См. также:
  • groupingBy(Function, Collector)
  • groupingByConcurrent(Function)
  • groupingByConcurrent(Function, Supplier, 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)
Возвращает конкурентный 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 - коллектор, реализующий нисходящее сокращение
mapFactory - поставщик, предоставляющий новый пустой ConcurrentMap, в который будут вставлены результаты
Возвращаемое значение:
конкурентный, неупорядоченный Collector, реализующий каскадную операцию группировки по
См. также:
  • groupingByConcurrent(Function)
  • groupingByConcurrent(Function, Collector)
  • groupingBy(Function, Supplier, Collector)

разделениеПо

public static <T> Collector<T,?,Map<Boolean,List<T>>> partitioningBy(Predicate<? super T> predicate)
Возвращает Collector, который разделяет входные элементы в соответствии с Predicate, и организует их в Map<Boolean, List<T>>. Возвращаемый Map всегда содержит сопоставления для false и true ключей. Нет никаких гарантий относительно типа, изменяемости, сериализуемости или потокобезопасности возвращаемых Map или List.
Примечание API:
Если в разбиении нет элементов, его значение в результирующем отображении будет пустым списком.
Параметры типа:
T - тип входных элементов
Параметры:
predicate - предикат, используемый для классификации входных элементов
Возвращаемое значение:
Collector реализующий операцию разделения
См. также:
  • partitioningBy(Predicate, Collector)

разделениеПо

public static <T, D, A> Collector<T,?,Map<Boolean,D>> partitioningBy(Predicate<? super T> predicate, Collector<? super T,A,D> downstream)
Возвращает Collector который разделяет входные элементы в соответствии с Predicate, выполняет сокращение значений в каждом разбиении в соответствии с другим Collector, и организует их в Map<Boolean, D> значениями которого являются результаты нисходящего сокращения.

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

Примечание API:
Если в разбиении нет элементов, его значение в результирующем отображении будет получено путем вызова поставщика функции нисходящего коллектора, а затем применения функции завершения.
Параметры типа:
T - тип входных элементов
A - промежуточный тип накопления нисходящего коллектора
D - тип результата нисходящего сокращения
Параметры:
predicate - предикат, используемый для классификации входных элементов
downstream - коллектор, реализующий нисходящее сокращение
Возвращаемое значение:
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, который накапливает входные элементы в неизменяемую карту, ключи и значения которой являются результатом применения предоставленных функций отображения к входным элементам.

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

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

Type Parameters:
T - тип входных элементов
K - тип выходного значения функции отображения ключей
U - тип выходного значения функции отображения значений
Parameters:
keyMapper - функция отображения для получения ключей, не должна быть null
valueMapper - функция отображения для получения значений, не должна быть null
Returns:
Collector, который накапливает входные элементы в неизменяемую карту, ключи и значения которой являются результатом применения предоставленных функций отображения к входным элементам
Throws:
NullPointerException - если keyMapper или valueMapper равны null
Since:
10
See Also:
  • 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, который накапливает элементы в карту, ключи и значения которой являются результатом применения предоставленных функций отображения к входным элементам.

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

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

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

 Map<String, String> phoneBook
   = people.stream().collect(
     toMap(Person::getName,
           Person::getAddress,
           (s, a) -> s + ", " + a));
Implementation Note:
Возвращаемая карта не является конкурентной. Для потоков параллельных стрим-пайплайнов функция combiner работает путем слияния ключей из одной карты в другую, что может быть дорогостоящей операцией. Если не требуется, чтобы результаты сливались в карту в порядке их появления, использование toConcurrentMap(Function, Function, BinaryOperator) может обеспечить лучшую производительность при параллельной обработке.
Type Parameters:
T - тип входных элементов
K - тип выходного значения функции отображения ключей
U - тип выходного значения функции отображения значений
Parameters:
keyMapper - функция отображения для получения ключей
valueMapper - функция отображения для получения значений
mergeFunction - функция слияния, используемая для разрешения коллизий между значениями, связанными с одним ключом, как передается в Map.merge(Object, Object, BiFunction)
Returns:
Collector которая собирает элементы в карту, ключи которой являются результатом применения функции отображения ключей к входным элементам, а значения — результатом применения функции отображения значений ко всем входным элементам, равным ключу, и объединения их с помощью функции слияния
See Also:
  • 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.

Type Parameters:
T - тип входных элементов
K - тип выходного значения функции отображения ключей
U - тип выходного значения функции отображения значений
Parameters:
keyMapper - функция отображения для получения ключей, не должна быть null
valueMapper - функция отображения для получения значений, не должна быть null
mergeFunction - функция слияния, используемая для разрешения коллизий между значениями, связанными с одним ключом, как передается в Map.merge(Object, Object, BiFunction), не должна быть null
Returns:
Collector который накапливает входные элементы в неизменяемую карту, ключи и значения которой являются результатом применения предоставленных функций отображения к входным элементам
Throws:
NullPointerException - если keyMapper, valueMapper или mergeFunction равны null
Since:
10
See Also:
  • 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, который накапливает элементы в карту, ключи и значения которой являются результатом применения предоставленных функций отображения к входным элементам.

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

Implementation Note:
Возвращаемая карта не является конкурентной. Для потоков параллельных стрим-пайплайнов функция combiner работает путем слияния ключей из одной карты в другую, что может быть дорогостоящей операцией. Если не требуется, чтобы результаты сливались в карту в порядке их появления, использование toConcurrentMap(Function, Function, BinaryOperator, Supplier) может обеспечить лучшую производительность при параллельной обработке.
Type Parameters:
T - тип входных элементов
K - тип выходного значения функции отображения ключей
U - тип выходного значения функции отображения значений
M - тип возвращаемой карты
Parameters:
keyMapper - функция отображения для получения ключей
valueMapper - функция отображения для получения значений
mergeFunction - функция слияния, используемая для разрешения коллизий между значениями, связанными с одним ключом, как передается в Map.merge(Object, Object, BiFunction)
mapFactory - поставщик, предоставляющий новую пустую карту, в которую будут вставлены результаты
Returns:
Collector которая собирает элементы в карту, ключи которой являются результатом применения функции отображения ключей к входным элементам, а значения — результатом применения функции отображения значений ко всем входным элементам, равным ключу, и объединения их с помощью функции слияния
See Also:
  • 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 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:
  • 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 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 - функция отображения для создания значений
mergeFunction - функция объединения, используемая для разрешения коллизий между значениями, связанными с одним и тем же ключом, как предоставлено в Map.merge(Object, Object, BiFunction)
Returns:
конкурирующий, неупорядоченный Collector, который собирает элементы в ConcurrentMap, где ключи являются результатом применения функции отображения ключей к входным элементам, а значения — результатом применения функции отображения значений ко всем входным элементам, равным ключу, и объединения их с помощью функции объединения
See Also:
  • 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 коллектор.

Type Parameters:
T - тип входных элементов
K - выходной тип функции отображения ключей
U - выходной тип функции отображения значений
M - тип результирующего ConcurrentMap
Parameters:
keyMapper - функция отображения для создания ключей
valueMapper - функция отображения для создания значений
mergeFunction - функция объединения, используемая для разрешения коллизий между значениями, связанными с одним и тем же ключом, как предоставлено в Map.merge(Object, Object, BiFunction)
mapFactory - поставщик, предоставляющий новый пустой ConcurrentMap для вставки результатов
Returns:
конкурирующий, неупорядоченный Collector, который собирает элементы в ConcurrentMap, где ключи являются результатом применения функции отображения ключей к входным элементам, а значения — результатом применения функции отображения значений ко всем входным элементам, равным ключу, и объединения их с помощью функции объединения
See Also:
  • 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, который применяет функцию отображения, производящую целые числа, к каждому входному элементу и возвращает статистические данные сводки для полученных значений.
Type Parameters:
T - тип входных элементов
Parameters:
mapper - функция отображения, применяемая к каждому элементу
Returns:
Collector реализующий сводку статистических данных
See Also:
  • summarizingDouble(ToDoubleFunction)
  • summarizingLong(ToLongFunction)

summarizingLong

public static <T> Collector<T,?,LongSummaryStatistics> summarizingLong(ToLongFunction<? super T> mapper)
Возвращает Collector, который применяет функцию отображения, производящую длинные целые числа, к каждому входному элементу и возвращает статистические данные сводки для полученных значений.
Type Parameters:
T - тип входных элементов
Parameters:
mapper - функция отображения, применяемая к каждому элементу
Returns:
Collector реализующий сводку статистических данных
See Also:
  • summarizingDouble(ToDoubleFunction)
  • summarizingInt(ToIntFunction)

summarizingDouble

public static <T> Collector<T,?,DoubleSummaryStatistics> summarizingDouble(ToDoubleFunction<? super T> mapper)
Возвращает Collector, который применяет функцию отображения, производящую double, к каждому входному элементу и возвращает статистические данные сводки для полученных значений.
Type Parameters:
T - тип входных элементов
Parameters:
mapper - функция отображения, применяемая к каждому элементу
Returns:
Collector реализующий сводку статистических данных
See Also:
  • summarizingLong(ToLongFunction)
  • summarizingInt(ToIntFunction)

teeing

public static <T, R1, R2, R> Collector<T,?,R> teeing(Collector<? super T,?,R1> downstream1, Collector<? super T,?,R2> downstream2, BiFunction<? super R1,? super R2,R> merger)
Возвращает Collector , являющуюся составной частью двух коллекторов-последователей. Каждый элемент, переданный результатному коллектору, обрабатывается обоими коллекторами-последователями, а затем их результаты объединяются с помощью заданной функции объединения в окончательный результат.

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

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

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

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

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

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API