Потоки Java 8: сворачивание/абстрактные потоки

Скажем, у меня есть этот поток:

list.stream()
    .map(fn1)      // part1
    .map(fn2)      // 
    .filter(fn3)   // 

    .flatMap(fn4)  // part 2 
    .map(fn5)      //
    .filter(fn6)   //
    .map(fn7)      //
    .collect(Collectors.toList())

Как я могу сделать так:

list.stream()
    .map(fnPart1)      
    .map(fnPart2)
    .collect(Collectors.toList())

Без ручного размотки частей fnX и их объединения (по причинам технического обслуживания я хочу сохранить их нетронутыми и выразить fnPartX с ними).

Ответ 1

Вы можете выразить и составить его с помощью функций:

Function<Stream<T1>, Stream<T2>> fnPart1 = 
        s -> s.map(fn1)
            .map(fn2) 
            .filter(fn3);
Function<Stream<T2>, Stream<T3>> fnPart2 = 
        s -> s.flatMap(fn4)
            .map(fn5)      
            .filter(fn6)   
            .map(fn7);

fnPart1.andThen(fnPart2).apply(list.stream()).collect(Collectors.toList());

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

Это может быть основой для более сложной конструкции композиции, такой как:

public class Composer<T>{
    private final T element;

    private Composer(T element){
        this.element = element;
    }

    public <T2> Composer<T2> andThen(Function<? super T, ? extends T2> f){
        return new Composer<>(f.apply(element));
    }

    public T get(){
        return element;
    }

    public static <T> Composer<T> of(T element){
        return new Composer<T>(element);
    }
}

Это можно использовать следующим образом:

Composer.of(list.stream())
    .andThen(fnPart1)
    .andThen(fnPart2)
    .get()
    .collect(Collectors.toList());

Ответ 2

Вы должны использовать flatMap не карту. Я не знаю, каковы ваши типы, поэтому я назвал их T1, T2 и т.д.

list.stream()
    .flatMap(fnPart1)      
    .flatMap(fnPart2)
    .collect(Collectors.toList())

Stream<T2> fnPart1(T1 t1) {
    return Stream.of(t1).map(fn1).map(fn2).filter(fn3);
}

Stream<T3> fnPart2(T2 t2) {
    return Stream.of(t2).flatMap(fn4).map(fn5).filter(fn6).map(fn7);
}

Конечно, вы можете удалить некоторые из потоков:

Stream<T2> fnPart1(T1 t1) {
    return Stream.of(fn2(fn1(t1))).filter(fn3);
}

Stream<T3> fnPart2(T2 t2) {
    return fn4(t2).map(fn5).filter(fn6).map(fn7);
}

Дальнейшее упрощение возможно, так как fnPart1 и fnPart2 имеют дело только с отдельными элементами.