Класс Collectors

Реализации 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));

Методы

toCollection

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

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

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

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

C - тип результирующего Collection

Параметры:

collectionFactory - Supplier, возвращающий новый, пустой Collection соответствующего типа

Возвращает:

Collector, который собирает все входные элементы в Collection, в порядке их встречи

toList

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

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

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

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

Возвращает:

Collector, который собирает все входные элементы в List, в порядке их встречи

toSet

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

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

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

Возвращает:

Collector, который собирает все входные элементы в Set

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

Возвращает:

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

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> people
         = 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)

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

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)

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

Формат double может представлять все последовательные целые числа в диапазоне от -2⁵³ до 2⁵³. Если в потоке более 2⁵³ значений, делитель в вычислении среднего значения насыщается при значении 2⁵³, что приводит к дополнительным числовым ошибкам.

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

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

Параметры:

mapper - функция, извлекающая свойство для суммирования

Возвращает:

Collector, который производит сумму производного свойства

reducing

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

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

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

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

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

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

Параметры:

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

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

Возвращает:

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

См. также:

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

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

Это дает результат, подобный:

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)

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)

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)

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

Это приводит к результату, подобному:

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)

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)

ConcurrentMap<City, Set<String>> namesByCity
         = people.stream().collect(groupingBy(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 нет.

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

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)

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

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)

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

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

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

А следующее производит отображение Map уникального идентификатора на студентов:

Map<String, Student> studentIdToStudent
         students.stream().collect(toMap(Student::getId,
                                         Functions.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)

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)

Примечание 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)

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

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

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

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

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

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

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

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

Параметры:

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

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

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

mapSupplier - функция, которая возвращает новую пустую 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)

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

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

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

А следующее производит отображение Map уникального идентификатора на студентов:

Map<String, Student> studentIdToStudent
         students.stream().collect(toConcurrentMap(Student::getId,
                                                   Functions.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)

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

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

Map<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> mapSupplier)

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

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

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

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

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

Параметры:

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

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

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

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

Возвращает:

конкурирующий, неупорядоченный 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)