public static <T> Collector<T, ?, Integer> summingInt(ToIntFunction<? super T> mapper)

List<Product> products = List.of(
    new Product("Laptop", 1000),
    new Product("Phone", 500),
    new Product("Tablet", 300)
);

int totalPrice = products.stream()
    .collect(Collectors.summingInt(Product::getPrice));

// Результат: 1800 (1000 + 500 + 300)

int total = products.stream()
    .mapToInt(Product::getPrice)
    .sum();

int total = products.stream()
    .reduce(0, (sum, p) -> sum + p.getPrice(), Integer::sum);

Map<String, Integer> totalPriceByCategory = products.stream()
    .collect(Collectors.groupingBy(
        Product::getCategory,
        Collectors.summingInt(Product::getPrice)
    ));

{
  "Electronics": 1800,
  "Office": 750
}

import java.util.*;

public class Task290425 {
    public static void main(String[] args) {
        Set<Integer> set1 = new HashSet<>(Arrays.asList(1, 2, 3));
        Set<Integer> set2 = new HashSet<>(Arrays.asList(3, 2, 1));
        Set<Integer> set3 = new LinkedHashSet<>(Arrays.asList(1, 2, 3));
        
        System.out.println(set1.equals(set2));
        System.out.println(set1.equals(set3));
    }
}

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

List<String> words = List.of("Java", "Stream", "API");
String result = words.stream().collect(Collectors.joining());

// Результат: "JavaStreamAPI"

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

String result = words.stream().collect(Collectors.joining(", "));

// Результат: "Java, Stream, API"

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

String result = words.stream()
    .collect(Collectors.joining(", ", "[", "]"));

// Результат: "[Java, Stream, API]"

StringJoiner joiner = new StringJoiner(delimiter, prefix, suffix);
stream.forEach(element -> joiner.add(element.toString()));
return joiner.toString();

List<Integer> numbers = List.of(1, 2, 3);
String result = numbers.stream()
    .map(Object::toString)
    .collect(Collectors.joining("-"));

// Результат: "1-2-3"

String result = numbers.stream()
    .collect(Collectors.mapping(
        Object::toString,
        Collectors.joining("/")
    ));

.filter(Objects::nonNull)

Map<String, String> joinedByCategory = products.stream()
    .collect(Collectors.groupingBy(
        Product::getCategory,
        Collectors.mapping(
            Product::getName,
            Collectors.joining(", ")
        )
    ));

{
  "Electronics": "Laptop, Phone",
  "Office": "Pen, Paper"
}

String complex = persons.stream()
    .collect(Collectors.mapping(
        p -> p.name() + " (" + p.age() + ")",
        Collectors.joining("; ", "Persons: ", ".")
    ));

// Результат: "Persons: Alice (25); Bob (30)."

StringBuilder sb = new StringBuilder();
list.forEach(sb::append);

String.join(", ", words);

String sql = """
    SELECT %s
    FROM table
    WHERE id IN (%s)
    """.formatted(
        columns.stream().collect(joining(", ")),
        ids.stream().map(Object::toString).collect(joining(", "))
    );

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

List<Integer> numbers = List.of(1, 2, 3, 4, 5);

Map<Boolean, List<Integer>> partitioned = numbers.stream()
    .collect(Collectors.partitioningBy(n -> n % 2 == 0));

// Результат:
// {
//   false=[1, 3, 5],
//   true=[2, 4]
// }

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

Map<Boolean, Long> countByPartition = numbers.stream()
    .collect(Collectors.partitioningBy(
        n -> n % 2 == 0,
        Collectors.counting()
    ));

// Результат: {false=3, true=2}

Map<Boolean, String> joinedPartitions = numbers.stream()
    .collect(Collectors.partitioningBy(
        n -> n % 2 == 0,
        Collectors.mapping(
            Object::toString,
            Collectors.joining("-")
        )
    ));

// Результат: {false="1-3-5", true="2-4"}

Map<Boolean, Set<Integer>> toSet = numbers.stream()
    .collect(Collectors.partitioningBy(
        n -> n % 2 == 0,
        Collectors.toSet()
    ));

Map<Boolean, A> result = new HashMap<>();
result.put(true, new ArrayList<>());
result.put(false, new ArrayList<>());

stream.forEach(item -> {
    boolean key = predicate.test(item);
    result.get(key).add(item);
});

// Если есть downstream:
result.replaceAll((k, v) -> downstream.finisher().apply(v));

record Person(String name, int age) {}

List<Person> people = List.of(
    new Person("Alice", 25),
    new Person("Bob", 17),
    new Person("Charlie", 30)
);

Map<Boolean, List<Person>> adults = people.stream()
    .collect(Collectors.partitioningBy(p -> p.age() >= 18));

// Результат:
// {
//   false=[Person[name=Bob, age=17]],
//   true=[Person[name=Alice, age=25], Person[name=Charlie, age=30]]
// }

Map<Boolean, IntSummaryStatistics> stats = numbers.stream()
    .collect(Collectors.partitioningBy(
        n -> n % 2 == 0,
        Collectors.summarizingInt(Integer::intValue)
    ));

// Получить среднее для четных чисел:
double avgEven = stats.get(true).getAverage();

.collect(Collectors.collectingAndThen(
    Collectors.partitioningBy(predicate),
    Collections::unmodifiableMap
));

.partitioningBy(item -> item != null && predicate.test(item))

import java.util.*;

public class Task300425 {
    public static void main(String[] args) {
        short a = 1;
        int i = 1;
        long k = 1;

        Map<Object, String> map = new HashMap<>();
        map.put(i, "Java");
        map.put(k, "Python");
        map.put(a, "C++");

        System.out.println(map.size());
    }
}

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

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

String firstItem = stream
    .collect(Collectors.collectingAndThen(
        Collectors.toList(),
        list -> list.isEmpty() ? null : list.get(0)
    );

Map<String, List<Integer>> unmodifiableGroups = numbers.stream()
    .collect(Collectors.collectingAndThen(
        Collectors.groupingBy(
            n -> n % 2 == 0 ? "even" : "odd"
        ),
        Collections::unmodifiableMap
    ));

Long countOrZero = stream
    .collect(Collectors.collectingAndThen(
        Collectors.counting(),
        c -> c > 100 ? c : 0L
    ));

R intermediateResult = downstream.collect(stream);
RR finalResult = finisher.apply(intermediateResult);
return finalResult;

Optional<String> lastElement = stream
    .collect(Collectors.collectingAndThen(
        Collectors.toList(),
        list -> list.isEmpty() 
            ? Optional.empty() 
            : Optional.of(list.get(list.size()-1))
    );

Map<String, Set<String>> caseInsensitiveGroups = words.stream()
    .collect(Collectors.collectingAndThen(
        Collectors.groupingBy(
            String::toLowerCase,
            Collectors.toSet()
        ),
        Collections::unmodifiableMap
    ));

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

List<String> words = List.of("Java", "Stream", "API");
int totalLength = words.stream()
    .collect(Collectors.reducing(
        0,                  // identity
        String::length,     // mapper
        Integer::sum        // op
    ));
// Результат: 11 (4 + 6 + 1)

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

String concatenated = words.stream()
    .collect(Collectors.reducing(
        "",         // identity
        String::concat
    ));
// Результат: "JavaStreamAPI"

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

Optional<Integer> max = Stream.of(3, 1, 4)
    .collect(Collectors.reducing(
        Integer::max
    ));
// Результат: Optional[4]

// Псевдокод реализации
U result = identity;
for (T element : stream) {
    result = op.apply(result, mapper.apply(element));
}
return result;
Для формы без identity использует Optional для обработки пустых потоков

record Product(String name, double price) {}

List<Product> products = List.of(
    new Product("Laptop", 999.99),
    new Product("Phone", 599.99)
);

// Сумма цен продуктов с названием длиннее 4 символов
double total = products.stream()
    .collect(Collectors.reducing(
        0.0,
        p -> p.name().length() > 4 ? p.price() : 0,
        Double::sum
    ));

// Максимальная цена в каждой категории
Map<String, Optional<Product>> byCategory = products.stream()
    .collect(Collectors.groupingBy(
        Product::category,
        Collectors.reducing((p1, p2) -> 
            p1.price() > p2.price() ? p1 : p2
    ));

// Пользовательская свертка для статистики
class Stats {
    int count;
    double sum;
    // + конструкторы/методы
}

Stats stats = stream.collect(Collectors.reducing(
    new Stats(0, 0.0),
    num -> new Stats(1, num),
    (s1, s2) -> new Stats(
        s1.count + s2.count,
        s1.sum + s2.sum
    )
));

// Вместо:
.collect(reducing(0, Integer::sum))

// Лучше:
.mapToInt().sum()

// Вместо:
.collect(reducing(Integer::max))

// Лучше:
.max(Comparator.naturalOrder())

// Вместо:
.collect(reducing(Collections.emptyList(), customMerge))

// Лучше:
.collect(toUnmodifiableList())