本文是 用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 资源下载

喜欢，用实际点赞支持我吧！ 欢迎留言讨论！