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

96
DinghuiYe
2017.11.04 00:55* 字数 136
  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]
}

  1. 只用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 合并,后面再研究
*/
学习笔记
Web note ad 1