Lambda表达式

　　Lambda 是一个匿名函数，可以把 Lambda表达式 理解为是一段可以传递的代码 (将代码像数据一样进行传递)。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升，Lambda表达式是 Java8 中最重要的新功能之一。可以替代只有一个抽象函数的接口实现，告别匿名内部类，代码看起来更简洁易懂。

　　 Lambda表达式的特点：

　　1、函数式编程

　　2、参数类型自动推断

　　3、代码量少，简洁

　　

 　　Lambda表达式应用场景：

　　任何有函数式接口的地方

　　函数式接口：定义的接口有且只有一个方法

 

　　表达式案例

　　()->{}

　　()->{System.out.println(1);}

　　()->System.out.println(1)

　　()->{return 100;}

　　()->100

　　()->null

　　(int x)->{return x+1;}

　　(int x)->x+1

　　(x)->x+1

　　x->x+1

　　()指的是接口里的方法，括号内为参数，参数可以指定类型也可以不指定，因为lambda表达式会做一个自动匹配

　　{}为方法的具体实现，如果实现只有一行代码，那么{}也可以省略掉

 　　如下为直接返回返回值的写法

　　()->100

　　()->null

 　　Lambda表达式案例：

/**
         * 创建线程的几种写法
         */
        Runnable rb1 = new Runnable() {

            @Override
            public void run() {
                System.out.println("rb1 run...");
            }
        };
        rb1.run();


        Runnable rb2 = () -> {
            System.out.println("rb2 run...");
        };
        rb2.run();


        Runnable rb3 = () -> System.out.println("rb3 run...");
        rb3.run();


        Callable<String> cb1 = () -> "callable test1";
        System.out.println(cb1.call());

        /**
         * 表达式示例
         */
        AnimalFactory af = () -> "rabbit";
        System.out.println(af.produce());


        AnimalFactory af1 = () -> {
            return "dog";
        };
        System.out.println(af1.produce());


        StudentDao sd = (stu) -> {
            return true;
        };

        Student student = new Student(1, "cat");
        System.out.println(sd.addStu(student));


        StudentDao sd1 = (stu) -> {
            if (stu.getAge() > 0) {
                return false;
            }

            return true;
        };
        Student student1 = new Student(2, "dog");
        System.out.println(sd1.addStu(student1));


        StudentDao sd2 = (stu) -> false;
        System.out.println(sd2.addStu(student1));

public interface AnimalFactory {

    public String produce();

}

public interface StudentDao {

    public boolean addStu(Student stu);
}

　　Function函数案例：

　　Supplier 代表一个输出 

 

　　Consumer 代表一个输入

　　BiConsumer 代表两个输入 

 

　　Function 代表一个输入，一个输出（一般输入和输出是不同类型的） 

　　UnaryOperator 代表一个输入，一个输出（输入和输出是相同类型的） 

 

　　BiFunction 代表两个输入，一个输出（一般输入和输出是不同类型的） 

　　BinaryOperator 代表两个输入，一个输出（输入和输出是相同类型的）

 

　　Function函数<>里的两个类型分别代表输入和输出类型，可通过该函数完成最简单的输入输出操作

 　   Funcation函数案例

function函数<>里的两个类型分别代表输入和输出类型，可通过该函数完成最简单的输入输出操作

Function<String, Integer> func = (str)->str.length();
System.out.println(func.apply("abcd"));


Supplier函数<>里的类型代表输出类型，可以通过该函数完成最简单的输出操作

Supplier<Integer> sp = ()->5;
System.out.println(sp.get());


Consumer<>里的类型代表输入类型，可以通过该函数完成最简单的一个参数的输入操作

Consumer<String> cs = (str)->System.out.println(str.length());;
cs.accept("abc");


BiConsumer<>里的类型代表输入类型，可以通过该函数完成最简单的两个参数的输入操作，该方法返回值为void

BiConsumer<String, Integer> bc = (str,num)->System.out.println(str.length()+num);
bc.accept("kkk", 2);

 /**
         * 函数式接口传参与实现
         */
        Function<String, Integer> func = (str) -> str.length();
        System.out.println(func.apply("abcd"));

        Function<String, Integer> func1 = str->str.length();
        System.out.println(func1.apply("qwert")+"啊哈哈");


        Supplier<Integer> sp = () -> 5;
        System.out.println(sp.get());


        Consumer<String> cs = (str) -> System.out.println(str.length());
        cs.accept("abc");


        BiConsumer<String, Integer> bc = (str, num) -> System.out.println(str.length() + num);
        bc.accept("kkk", 2);


        TestInterface ti = () -> get();
        System.out.println(ti.get());

        TestInterface ti1 = () -> 500;
        System.out.println(ti1.get());

        BiFunction<String, String, Integer> bf = (a, b) -> a.length() + b.length();
        System.out.println(bf.apply("abc", "uh"));

public interface TestInterface {

    int get();
}　　

　　Lambda方法调用：

 

 　   新建类名：LambdaDemo

　　静态方法引用：

/**
         * 静态方法引用
         */
        Supplier<String> s1 = LambdaDemo::strHandler;
        System.out.println(s1.get());


        Supplier<String> s2 = Fun::get;
        System.out.println(s2.get());

        System.out.println("123");
        System.out.println(get());

        Consumer<String> consumer1 = Fun::printStr;
        consumer1.accept("sjias");

        Consumer<String> consumer2 = (str)->Fun.printStr(str);
        consumer2.accept("kkkkkk");

        Function<String,String> f1 = Fun::toUpperCase;
        System.out.println(f1.apply("nba"));

        BiFunction<String,String,Integer> bf1 = Fun::getLength;
        System.out.println(bf1.apply("yu", "uy"));

        Consumer<Integer> con1 = (size)->Fun.getSize(size);
        con1.accept(999);

        Fun.getSize();

　　 实例方法引用：

/**
         * 实例方法
         */
        Supplier<String> sp1 = new LambdaDemo()::put;
        System.out.println(sp1.get());

        Supplier<String> sp2 = ()->new LambdaDemo().put();
        System.out.println(sp2.get());

        Supplier<String> sp3 = ()->{return new LambdaDemo().put();};
        System.out.println(sp3.get());

        Supplier<String> sp4 = new Fun()::print;
        System.out.println(sp4.get());

        LambdaDemo ld = new LambdaDemo();
        Function<String,String> up1 = (str)->ld.toUpper(str);
        System.out.println(up1.apply("qwer"));

        Function<String,String> up2 = ld::toUpper;
        System.out.println(up2.apply("poi"));

static int get() {
        return 1;
    }

    static String strHandler() {
        return "ok";
    }

    public String put(){
        return "put...";
    }

    public String toUpper(String str){
        return str.toUpperCase();
    }

class Fun {

    public static String get() {
        return "fuck";
    }

    public static void printStr(String str){
        System.out.println(str.substring(0,3));
    }

    public static String toUpperCase(String str){
        return str.toUpperCase();
    }

    public static Integer getLength(String a,String b){
        return a.length()+b.length();
    }

    public String print(){
        System.out.println("Fun print...");
        return "ok";
    }

    public static void getSize(int size){
        System.out.println(size);
    }

    public static void getSize(){
        System.out.println(666);
    }

}

　　 对象方法引用：

class haha{

    haha(int age){
        System.out.println("age==" + age);
    }

    public Integer fun(String str){
        return str.length();
    }

    public void print(){
        System.out.println("haha haha");
    }

}

class hehe{

    public Integer fun(String str){
        return str.length();
    }

    public void print(){
        System.out.println("hehe hehe");
    }

    public void show(String str){
        System.out.println(str);
    }
}

/**
         * 对象方法引用lambda表达式
         */
        Consumer<haha> ha = haha::print;
        ha.accept(new haha(12));

        Function<String,Integer> f1 = new hehe()::fun;
        System.out.println(f1.apply("bubu"));

        BiFunction<hehe,String,Integer> f2 = hehe::fun;
        System.out.println(f2.apply(new hehe(), "tmac-kkk"));

        Consumer<hehe> he = hehe::print;
        he.accept(new hehe());

        BiConsumer<hehe,String> bc = hehe::show;
        bc.accept(new hehe(),"abc");

　　 构造方法引用：

        /**
         * 构造函数引用lambda表达式
         */
        Supplier<List> list = ArrayList::new;
        List l1 = list.get();
        l1.add(1);
        l1.add(2);
        System.out.println(l1.size());

        Function<Integer,haha> f3 = haha::new;
        f3.apply(34).print();