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

import java.util.*;

public class Task010525 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));
        Iterator<String> it = list.iterator();
        list.add("D");
        
        System.out.println(it.next());
    }
}

Collector<String, StringBuilder, String> joinStrings = Collector.of(
    StringBuilder::new,            // supplier
    (sb, str) -> {                // accumulator
        if (!sb.isEmpty()) sb.append(", ");
        sb.append(str);
    },
    (sb1, sb2) -> {               // combiner (для параллельных стримов)
        if (sb1.length() > 0 && sb2.length() > 0) {
            sb1.append(", ");
        }
        return sb1.append(sb2);
    },
    StringBuilder::toString       // finisher
);

String result = Stream.of("Java", "Kotlin", "Scala")
    .collect(joinStrings);

// Результат: "Java, Kotlin, Scala"

List<String> unmodifiableList = stream.collect(Collectors.toUnmodifiableList());
Set<String> unmodifiableSet = stream.collect(Collectors.toUnmodifiableSet());
Map<String, Integer> unmodifiableMap = stream.collect(
    Collectors.toUnmodifiableMap(
        keyMapper,
        valueMapper,
        mergeFunction // для обработки дубликатов
    )
);

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

Collector<String, List<String>, List<String>> toImmutableList = Collector.of(
    ArrayList::new,               // supplier
    List::add,                    // accumulator
    (left, right) -> {            // combiner
        left.addAll(right);
        return left;
    },
    Collections::unmodifiableList // finisher
);

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

.filter(Objects::nonNull)
.collect(toUnmodifiableList())