Функциональное программирование в Java: продвинутые техники и Stream API

Функциональное программирование в Java: продвинутый уровень

Функциональное программирование (ФП) в Java перестало быть просто модной тенденцией — это неотъемлемая часть современного языка, начиная с версии 8. Для разработчиков, освоивших базовые лямбды и Stream API, наступает этап, когда требуется понимание более глубоких концепций: монад, композиции функций, ленивых вычислений и иммутабельных структур данных. Эта статья посвящена продвинутым техникам функционального программирования в Java, которые помогут писать более чистый, предсказуемый и параллельно-безопасный код.

1. Композиция функций и каррирование

В Java функциональные интерфейсы Function, Predicate и Consumer предоставляют методы по умолчанию для композиции: andThen() и compose(). Это позволяет строить цепочки преобразований без создания промежуточных переменных.

Пример композиции:

import java.util.function.Function;

public class FunctionComposition {
    public static void main(String[] args) {
        Function<String, String> trim = String::trim;
        Function<String, String> toUpper = String::toUpperCase;
        Function<String, String> addExclamation = s -> s + "!";

        // Композиция: trim -> toUpper -> addExclamation
        Function<String, String> process = trim.andThen(toUpper).andThen(addExclamation);

        String result = process.apply("  hello world  ");
        System.out.println(result); // HELLO WORLD!
    }
}

Каррирование — это преобразование функции от нескольких аргументов в последовательность функций от одного аргумента. В Java это можно эмулировать с помощью вложенных лямбд:

import java.util.function.Function;

public class CurryingExample {
    // Обычная функция
    static int add(int a, int b) { return a + b; }

    // Каррированная версия
    static Function<Integer, Function<Integer, Integer>> curriedAdd = a -> b -> a + b;

    public static void main(String[] args) {
        // Частичное применение
        Function<Integer, Integer> add5 = curriedAdd.apply(5);
        System.out.println(add5.apply(3)); // 8
        System.out.println(add5.apply(10)); // 15
    }
}

Каррирование полезно для создания специализированных функций на основе общих шаблонов, особенно при работе с конфигурациями.

2. Продвинутая работа с Stream API

Stream API в Java — это не просто замена циклов. Понимание его продвинутых возможностей позволяет значительно повысить производительность и читаемость кода.

2.1. Параллельные стримы и разделители

Параллельные стримы используют ForkJoinPool. Однако их эффективность зависит от размера данных и природы операций. Для кастомного управления распараллеливанием можно использовать Spliterator.

import java.util.Spliterator;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

public class CustomSpliterator {
    public static void main(String[] args) {
        // Создание стрима из итератора с кастомным разделителем
        Spliterator<Integer> spliterator = new Spliterator<>() {
            int current = 0;
            @Override
            public boolean tryAdvance(java.util.function.Consumer<? super Integer> action) {
                if (current < 100) {
                    action.accept(current++);
                    return true;
                }
                return false;
            }
            @Override
            public Spliterator<Integer> trySplit() {
                // Простейшее разделение
                int mid = current + 50;
                if (mid >= 100) return null;
                Spliterator<Integer> prefix = new RangeSpliterator(current, mid);
                current = mid;
                return prefix;
            }
            @Override
            public long estimateSize() { return 100 - current; }
            @Override
            public int characteristics() { return Spliterator.ORDERED | Spliterator.SIZED; }
        };

        Stream<Integer> stream = StreamSupport.stream(spliterator, true); // параллельный
        stream.limit(10).forEach(System.out::println);
    }
}

2.2. Сборщики (Collectors) для сложных агрегаций

Стандартные Collectors.toList() — это только начало. Продвинутые сборщики позволяют создавать кастомные структуры данных.

import java.util.*;
import java.util.stream.Collectors;

public class AdvancedCollectors {
    public static void main(String[] args) {
        List<String> words = List.of("apple", "banana", "apricot", "berry", "cherry");

        // Группировка по первой букве с подсчетом
        Map<Character, Long> countByFirstChar = words.stream()
            .collect(Collectors.groupingBy(
                s -> s.charAt(0),
                Collectors.counting()
            ));
        System.out.println(countByFirstChar); // {a=2, b=2, c=1}

        // Сборка в TreeMap с кастомным значением
        TreeMap<Character, List<String>> sortedMap = words.stream()
            .collect(Collectors.groupingBy(
                s -> s.charAt(0),
                TreeMap::new,
                Collectors.mapping(
                    s -> s.toUpperCase(),
                    Collectors.toList()
                )
            ));
        System.out.println(sortedMap); // {A=[APPLE, APRICOT], B=[BANANA, BERRY], C=[CHERRY]}
    }
}

3. Монады и Optional: работа с null без исключений

Монада — это абстракция, которая позволяет применять функции к значениям, обернутым в контекст. В Java классическим примером монады является Optional. Продвинутый уровень — это использование монадических операций flatMap и map для построения безопасных цепочек.

Пример: цепочка Optional без вложенных проверок

import java.util.Optional;

public class MonadicOptional {
    static Optional<String> getUserEmail(int userId) {
        // Имитация поиска
        if (userId == 1) return Optional.of("user@example.com");
        return Optional.empty();
    }

    static Optional<String> getDomain(String email) {
        if (email.contains("@")) {
            return Optional.of(email.substring(email.indexOf("@") + 1));
        }
        return Optional.empty();
    }

    public static void main(String[] args) {
        // Продвинутое использование flatMap
        Optional<String> domain = getUserEmail(1)
            .flatMap(MonadicOptional::getDomain)
            .map(String::toLowerCase);

        domain.ifPresentOrElse(
            d -> System.out.println("Domain: " + d),
            () -> System.out.println("Domain not found")
        );

        // Комбинация с orElseThrow для четкого управления ошибками
        String result = getUserEmail(