Java的lambda表达式,用Java的lambda表达式的函数编程,lambda表达式深入理解,java的链式编程的实现

本例子将用java的泛型接口实现链式编程

1.自己实现一个List可以装任何类型的数据Integer、String，Long、自定义类型的

2.还可以调用map、filter、reduce方法（不使用java8的Stream）

3.可以链式编程。

创建函数式接口 

定义一个只有一个方法的函数式接口,为了方便使用->,这个函数接口是输入一个T类型的值返回一个R类型的值

public interface Function1<T,R> {
    R apply(T t);
}

再定义一个函数接口,输入两个参数,返回一个相同类型的参数

public interface Function2<Z> {
    Z apply(Z z1,Z z2);
}

定义一个List,继承ArrayList

import java.util.ArrayList;

public class MyList<T> extends ArrayList<T> {


    /**
     * 定义函数式接口,T为参数类型,R作为返回类型,因为返回值不一定是参数类型,所以为了提高扩展,在方法上定义一个R泛型,声明返回类型
     * @param function
     * @param <R>
     * @return
     */
    public <R> MyList<R> map(Function1<T,R> function){
        //循环调用的list
        MyList<R> result = new MyList<>();
        for (T t : this) {
            R map = function.apply(t);
            result.add(map);
        }
        return result;
    }

    /**
     * 传入一个任意类型,返回布尔类型,通过判断条件决定是否添加到结果中
     * @param function
     * @return
     */
    public MyList<T> filter(Function1<T,Boolean> function){
        //循环调用的list
        MyList<T> result = new MyList<>();
        for (T t : this) {
            Boolean filter = function.apply(t);
            if (filter){
                result.add(t);
            }
        }
        return result;
    }

    /**
     * 输入两个一样类型参数,返回一个总和参数
     * @param function2
     * @param
     * @return
     */
    public T reduce(Function2<T> function2){
        //循环调用的list
        boolean first=true;
        T tmp=null;
        //循环当前对象,如果是第一个就赋给总数,如果不是第一个就应用逻辑之后往上叠加,最后返回总结果
        for (T m : this) {
            if (first){
                tmp=m;
                first=false;
            }else {
                 tmp = function2.apply(tmp, m);
            }
        }
        return tmp;
    }


}

测试

public class MyLabadaTest {
    public static void main(String[] args) {

        //1.MyAdvList可以装任何类型的数据Integer、String，Long、自定义类型的

        //2.还可以调用map、filter、reduce方法（不使用java8的Stream）

        //3.可以链式变成。
        MyList<Integer> list = new MyList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);
        MyList<Integer> filter = list.filter(x -> x % 2 == 0);
        for (Integer integer : filter) {
            System.out.println(integer);
        }
        MyList<Integer> map = filter.map(x -> x * 100);
        for (Integer integer : map) {
            System.out.println(integer);
        }
        Integer reduce = map.reduce(new Function2<Integer>() {
            @Override
            public Integer apply(Integer z1, Integer z2) {
                return z1+z2;
            }
        });
//        这两种形式是相等的,输入两个参数,实际上的业务都是在mylist中处理的,对每个元素进行循环,每次都调用其中的apply方法

        Integer reduce2 = map.reduce((a,b)->a+b);
        System.out.println("reduce = " + reduce);
    }
}

IDEA运行结果展示