用Java DIY 函数式方法—— map
本文是 用Java DIY 函数式方法—— forEach, find, filter 续篇， 解决如何使用java实现函数式方法-map。
注意
- 不适合对函数式一点基础都没有的读者
- DIY实现不是完美的，仅仅是用实例表达函数式方法的理解
- 这个系列文章不是分析java 8 stream中的方法源码，而是对java 8 stream特性，结合Kotlin， Rxjava之类的理解， 使用纯java的方式实现类似的函数式方法。
- 需要对java 中的泛型以及Collection有了解
- 会用到java 8 lambda表达式
- 要实际代码验证，需要 jdk 1.8
讲解的模式如下：
- 给出某个场景
- 使用 java 8
- 使用DIY 函数实现
那就进入主题吧： 用Java DIY 函数式方法——map
DIY 函数式方法map
高中数学映射 f: A -> B
函数式中 map 跟数学上映射概念相似，在解决实际问题的时候，非常有用。
作用： 映射， 将 T 映射为 R， 其中的T,R是泛型。 T -> R
/** 需求：
* 给定Integer集合[1,2,3] ,将该集合转换为集合["1A", "2A", "3A"], 然后再此基础上
* 转化为["1AB", "2AB", "3AB"]
* [1,2,3] -> ["1A", "2A", "3A"] -> ["1AB", "2AB", "3AB"]
*/
以上可以理解为 实际需求的变更，如何更好的应对变更，函数式范式，是个不错的选择！
1. java 8 stream实现
integerList.stream()
.map(new Function<Integer, String>() {
@Override
public String apply(Integer integer) {
return integer + "A";
}
})
.map(new Function<String, String>() {
@Override
public String apply(String s) {
return s + "B";
}
})
.forEach(item -> out.println(item));
说明： 上述一条链式调用，就解决了我们的需求
- 第一个map是将 Integer集合中的每个元素 ->(映射，转换) String集合， 若要写成 方程式， 可以理解为：
f(x) = x + "A";
- 第二个map将 String集合 按照 给定的
f(x)方式转化为另外一个String集合， 然后打印出集合内容！
lamdba表达式，简洁如下：
integerList.stream()
.map(integer -> integer + "A")
.map(s -> s + "B")
.forEach(out::println);
2. DIY map
在DIY 之前，需要梳理 map的 核心是什么？
集合T -> 集合R
所以，需要三个东西： 输入 T， 输出 R， 映射关系！
public static <T, R> Collection<? super R> map(
Collection<? extends T> collection,
Function<T, R> function) {
Collection<? super R> result = new ArrayList<>();//这里仅仅是演示
for(T item: collection){
R tempR = function.call(item);
result.add(tempR);
}
return result;
}
public interface Function<T, R>{
R call(T item);//T -> R
}
其中： Collection<? super R> 是map返回值类型， Collection<? extends T> 是输入参数的类型
Function<T, R> function 是映射关系， 用接口表示。
//这里仅仅是演示
Collection<? super R> result = new ArrayList<>();
一直强调 DIY的实现是有局限性的，我这里是在java集合的基础上，而且选用ArrayList作为实际的主体，要是其他数据结构类型，肯定就没法使用， 但是，不影响 讲解map实现的思路！
如上， 使用者，只需要关注 Function 接口的具体实现方法call的设计。
使用方式如下：
List<Integer> integerList = Arrays.asList(1, 2, 3);
map(integerList, new Function<Integer, String>() {
@Override
public String call(Integer item) {
return item + "A"; //自己的转换逻辑
}
}).forEach(out::println);
lambda简化：
map(integerList, item -> item + "A").forEach(out::println);
如何实现连续调用呢？ 这里，没办法像java 8 stream那样，调用像一条链子那样，那是因为java 8使用单独的类，接口实现的，是附加在stream中。 而 我们这里仅仅是方法， 稍微麻烦些，方法嵌套！
Collection<String> collection1 = map(integerList, new Function<Integer, String>() {
@Override
public String call(Integer item) {
return item + "A";
}
});
map(collection1, new Function<String, String>() {
@Override
public String call(String item) {
return item + "B";
}
}).forEach(out::println);
lambda简化，函数嵌套如下：
map(map(integerList, item -> item + "A"), item -> item + "B").forEach(out::println);
其他实例：将 a, b, c 变为大写, 并输出
map(Arrays.asList("a", "b", "c"), it -> it.toUpperCase()).forEach(item -> out.print(item + " "));
小结
理解 T -> R，就明白了map的原理了，遇到实际的情况，可以考虑用map实现，体会跟传统的不同之处！
代码上传到 csdn 资源下载
喜欢，用实际点赞支持我吧！ 欢迎留言讨论！
