- 只用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]
}
- 只用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 合并，后面再研究
*/
