Java8函数式编程：3.10进阶练习：map和filter实现

1. 只用reduce 和Lambda 表达式写出实现Stream 上的map 操作的代码，如果不想返回Stream，可以返回一个List。

// reduce实现map
private <T, R> Stream<R> map(Stream<T> stream, Function<T, R> fun) {
    return stream.reduce(new ArrayList<R>().stream(),  // Stream<R>是reduce参数的的U
            (u, t) -> Stream.concat(u, Stream.of(fun.apply(t))),
            (a, b) -> Stream.concat(a, b));
}
// 测试方法
// Artist(String name, String nation)
@Test
public void test23() {
    System.out.println(
        map(Stream.of(
                new Artist("a", "aaa"),
                new Artist("b", "bbb"),
                new Artist("c", "ccc")
        ), t -> t.getNation()).collect(Collectors.toList())
    ); // [aaa,bbb,ccc]
}

2. 只用reduce 和Lambda 表达式写出实现Stream 上的filter 操作的代码，如果不想返回Stream，可以返回一个List。

// reduce实现filter
private <T> Stream<T> filter(Stream<T> stream, Predicate<T> pre) {
    return stream.reduce(new ArrayList<T>().stream(),   // Stream<T>是reduce的U
            (u, t) -> {
                if (pre.test(t))
                    return Stream.concat(u, Stream.of(t));
                return u;
            },
            (a, b) -> Stream.concat(a, b)
    );
}
// 测试方法
@Test
public void test24() {
    System.out.println(
            filter(Stream.of(
                    new Artist("a", "aaa"),
                    new Artist("b", "bb"),
                    new Artist("c", "c")
            ), t -> t.getNation().length() >= 2).collect(Collectors.toList())
    );
} // [Artist("a", "aaa"), Artist("b", "bb")]

后话，函数式编程写起来是挺爽，写完了会有种看不懂的感觉... 慢慢习惯就好。关键是reduce方法的使用，下面给出我的看法：
reduce方法有3个：

//1. 
Optional<T> reduce(BinaryOperator<T> accumulator);
/*
常规的累计计算器，参数泛型和返回值泛型相同，
具体的累计计算规则源代码注释已经给出，
将stream第一个元素作为初始值，然后和第二个元素累计计算，
结果再次作为初始值，再和第三个元素累计计算，以此类推：

boolean foundAny = false;
T result = null;
for (T element : this stream) {
    if (!foundAny) {
        foundAny = true;
        result = element;
    }
    else
        result = accumulator.apply(result, element);
}
return foundAny ? Optional.of(result) : Optional.empty();
*/

//2. 
T reduce(T identity, BinaryOperator<T> accumulator);
/*
具有初始值的累计计算器，和上面的reduce类似，
只是初始值永远固定不变，均为 identity，
并且参数 identity、accumulator 的泛型相同，与返回值泛型亦相同
*/

//3.
<U> U reduce(U identity,
             BiFunction<U, ? super T, U> accumulator,
             BinaryOperator<U> combiner);
/*
累加器带有3个参数，前两个参数和上面的reduce含义相同，
需要注意的是 identity 的泛型和返回值的泛型相同，
而 accumulator 的函数接口变为了 BiFunction，并且支持两种泛型，可以和返回值泛型相同，也可不同，
上面实现 map 方法就有两中泛型参数，U 是 Stream<R>，T 就是 Artist，
最后一个参数 combiner，貌似是和并行有关，大概是并行执行后结果如何合并的方法，这里暂时用 concat 合并，后面再研究
*/