JAVA中Lambda函数

1、Lambda函数怎么发展来的

最开始得写接口+类实现

抽象类：

如果一个class定义了方法，但没有具体执行代码，这个方法就是抽象方法，抽象方法用abstract修饰。

因为无法执行抽象方法，因此这个类也必须申明为抽象类（abstract class）。

因为抽象类本身被设计成只能用于被继承，因此，抽象类可以强迫子类实现其定义的抽象方法，否则编译会报错。因此，抽象方法实际上相当于定义了“规范”。

接口：

如果一个抽象类没有字段，所有方法全部都是抽象方法，就可以把该抽象类改写为接口：interface。

然后改进了，写一个匿名类就行了

匿名类：

匿名类是不能有名字的类，它们不能被引用，只能在创建时用new语句来声明它们。

直接 new <类或接口> <类的主体>，类的主体里面写实现方法，省得先定义一个接口，再定义一个类去实现

后来又改进了，写lambda函数就行了

2、常用的lambda接口，给定义好了，也可以自己定义接口

3、样例代码

import java.util.List;
import java.util.function.Function;
import static java.util.Arrays.asList;


public class Test1 {
    static void p(String s){
        System.out.println(s);
    }

    public static void main(String[] args) {
        //现用现写，不能复用
        String s = guan(5, (a)-> ""+2*a);
        p(s);


        //现用现写，可以复用，把变量摘出来定义一下
        Function<Integer, String> fun0 = (a)->""+3*a;
        String s0 = guan(5, fun0);
        p(s0);


        //通过实例方法调用
        Test1 obj = new Test1();
        String s2 = guan(5, obj::fun2);
        p(s2);


        //通过类方法调用
        String s3 = guan(5, Test1::fun3);
        p(s3);


        p("");
        p("");
        //summary, lambda可以当作数组元素
        List<Function <Integer, String> > list = asList((a)->""+2*a, fun0, obj::fun2, Test1::fun3);
        list.forEach(e->{
            String s5= guan(5, e);
            p(s5);
        });


        p("");
        p("");
        for(int i=0; i<list.size(); ++i){
            Function<Integer, String> fun=list.get(i);
            String s6= guan(5, fun);
            p(s6);
        }




    }

    //实例方法
    String fun2(int a){
        return ""+4*a;
    }

    //类方法
    static String fun3(int a){
        return ""+5*a;
    }

    //lambda函数的内置接口
    static String guan(int a, Function<Integer, String> fun){
        return fun.apply(a);
    }
}

开始自己写接口。。。

import java.util.List;
import static java.util.Arrays.asList;


public class Test1 {
    static void p(String s){
        System.out.println(s);
    }

    public static void main(String[] args) {
        //匿名类实现
        String s="Guan";
        guanguan0(s, new Interf0() {
            public void sayhello(String s) {
                p("Hello" + ", " + s);
            }
        });


        p("");
        p("");
        //lambda实现
        Interf inte = (ss)->p("Hello"+", "+ss);
        Interf inte1 = (ss)->p("Meinv"+", "+ss);
        Interf inte2 = (ss)->p("Cainv"+", "+ss);
        guanguan("Guanguan", inte);
        guanguan("Guanguan", inte1);
        guanguan("Guanguan", inte2);


        p("");
        p("");
        //lambda实现简洁版，可以省略用接口那一步
        Interf inte3= (ss)->p("Hello"+", "+ss);//实现接口
        inte.talktoguanguan("laowang");//用接口


        //实现接口
        Cmp cm00 = (a, b)-> {
            if (a == b) {
                return 0;
            }
            else if (a < b) {
                return -1;
            }
            else return 1;
        };
        Cmp cm01 = (a, b)-> {
            if (a == b) {
                return 0;
            }
            else if (a > b) {
                return -1;
            }
            else return 1;
        };
        List<Integer> listint = asList(3, 5, 8, 7, 6);
        sort(listint, cm00);
        sort(listint, cm01);
    }

    //定义接口
    @FunctionalInterface
    interface Interf0{
        void sayhello(String user);
    }

    //用接口
    static void guanguan0(String s, Interf0 inte){
        inte.sayhello(s);
    }

    //定义接口
    @FunctionalInterface
    interface Interf{
        void talktoguanguan(String user);
    }

    //用接口
    static void guanguan(String s, Interf inte){
        inte.talktoguanguan(s);
    }

    //定义接口
    @FunctionalInterface
    interface Cmp{
        int cmp(int a, int b);
    }

    //用接口
    static void sort(List<Integer> array, Cmp cm) {
        for (int i = 0; i < array.size(); ++i) {
            for (int j = i + 1; i < array.size(); ++j) {
                if (cm.cmp(array.get(i), array.get(j)) < 0) {
                    int temp = array.get(i);
                    array.set(i, array.get(j));
                    array.set(j,temp);
                }
            }
        }
    }
}