java8新特性 Lamdba表达式应用总结

语法：

（参数列表）->{方法体}
（）：参数列表
{}：方法体
->lambda运算符

package com.ckq.lambda;

public class LambdaDemo {
    public static void main(String[] args) {
        A1 a1=()->{
            System.out.println("无参数无返回值1:");
        };
        a1.test();
        A2 a2=(a)->{
            System.out.println("单个参数无返回值:"+a);
        };
        a2.test2(3);

        A3 a3=(a,b)->{
            System.out.println("多个参数无返回值："+(a+b));
        };
        a3.test3(3,4);

        A4 a4=()->{
          return 5;
        };
        System.out.println("无参有返回值："+a4.test4());

        A5 a5=(a)->{
            return a;
        };
        System.out.println("单参数有返回值："+a5.test5("疾风已有归途"));

        A6 a6=(a,b,c)->{
            return (a+b)+c;
        };
        System.out.println("多参数有返回值:"+a6.test6(500,20,"大傻蛋"));
    }
}

interface A1{
    //无参数无返回值
    void test();

}
interface A2{
    void test2(int a);
}
interface A3{
    void test3(int a,int b);
}
interface A4{
    int test4();
}
interface A5{
    String test5(String a);
}
interface A6{
    String test6(int a,int b,String c);
}

结果：

无参数无返回值1:
单个参数无返回值:3
多个参数无返回值：7
无参有返回值：5
单参数有返回值：疾风已有归途
多参数有返回值:520大傻蛋

语法精简：

1、参数类型可以省略
2、加入只有一个参数，（）可以省略
3、如果方法体只有一条语句，{}可以省略
4、如果方法体中唯一语句是return返回语句，那省略大括号的同时returen也要省略

    public static void main(String[] args) {
        A1 a1=()-> System.out.println("无参数无返回值1:");
        a1.test();

        A2 a2=a-> System.out.println("单个参数无返回值:"+a);
        a2.test2(3);

        A3 a3=(a,b)->
            System.out.println("多个参数无返回值："+(a+b));
        a3.test3(3,4);

        A4 a4=()-> 5;

        System.out.println("无参有返回值："+a4.test4());

        A5 a5=a->a;
        System.out.println("单参数有返回值："+a5.test5("疾风已有归途"));

        A6 a6=(a,b,c)->(a+b)+c;
        System.out.println("多参数有返回值:"+a6.test6(500,20,"大傻蛋"));
    }

方法引用：

如果多个Lambda表达式实现函数是一样的话，可以封装成通用方法，以便于维护，这时候可以用方法引用实现；
语法：
对象::方法
如果方法是static方法，可以直接 类名::方法
构造方法引用：
如果函数式接口的实现恰好可以通过调用一个类的构造方法来实现，那么就可以使用构造方法引用；
语法：
类名::new

public class LambdaDemo3 {
    public static void main(String[] args) {
        LambdaDemo3 l=new LambdaDemo3();

        Test t1=l::testA;
        Test t2=l::testA;
        Test t3=LambdaDemo3::testB;
        Test t4=LambdaDemo3::testB;

        System.out.println(t1.ts("YOINGEN"));
        System.out.println(t2.ts("yasuo"));
        System.out.println(t3.ts("索子哥"));
        System.out.println(t4.ts("枣子哥"));


    }

    public String testA(String a){
        return "哥哥"+a;
    }

    public static String testB(String a){
        return "静态哥哥"+a;
    }
}

interface Test{
    String ts(String a);
}


运行结果：

哥哥YOINGEN
哥哥yasuo
静态哥哥索子哥
静态哥哥枣子哥

函数式接口：

1、接口有且仅有一个抽象方法
2、可以有普通方法、静态方法
3、Lambda表达式只能适用于函数式接口
4、@Functionallnterface注解 限定接口为函数式接口，如果不是加上这个接口编译不通过
5、允许有java.lang.Object中的public方法，例如equals方法

java内置函数式接口：

java.util.function下的一系列函数式接口包括Consumer、Supplier、Function、Predicat等常用接口

补充：
1、lambda表达式实现构造方法

public class Dog {

    private int age;

    private String name;

    public Dog(int age, String name) {
        System.out.println("有参构造");
        this.age = age;
        this.name = name;
    }

    public Dog() {
        System.out.println("无参构造");
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

public class LambdaDemo4 {
    public static void main(String[] args) {
        DogService d1=Dog::new;
        System.out.println(d1.getDog());

        DogService2 d2=Dog::new;
        System.out.println(d2.getDog(2,"老哈"));
    }
}

interface DogService{
    Dog getDog();
}

interface DogService2{
    Dog getDog(int age,String name);
}



运行结果：

无参构造
Dog{age=0, name='null'}
有参构造
Dog{age=2, name='老哈'}

2、lambda表达式实现集合遍历与排序

public class LambdaDemo5 {
    public static void main(String[] args) {
        List<Dog> list=new ArrayList<>();
        list.add(new Dog(2,"小红"));
        list.add(new Dog(1,"小花"));
        list.add(new Dog(4,"小黑"));
        list.add(new Dog(5,"小黄"));
        list.add(new Dog(3,"小白"));

        System.out.println("Lambda表达式集合排序——————————————————");
        list.sort((o1,o2)->o1.getAge()-o2.getAge());
        System.out.println(list);
        list.forEach(System.out::println);
    }
}

运行结果：

有参构造
有参构造
有参构造
有参构造
有参构造
Lambda表达式集合排序——————————————————
[Dog{age=1, name='小花'}, Dog{age=2, name='小红'}, Dog{age=3, name='小白'}, Dog{age=4, name='小黑'}, Dog{age=5, name='小黄'}]
Dog{age=1, name='小花'}
Dog{age=2, name='小红'}
Dog{age=3, name='小白'}
Dog{age=4, name='小黑'}
Dog{age=5, name='小黄'}