Lambda表达式简单学习

一：lambda表达式简介
Lambda表达式是Java8中新添加的一个特性，说白了就是一个匿名函数。使用lambda表达式可以对一个接口进行非常简洁的实现。
Lambda表达式可以对函数式接口进行简洁的实现，但并不是所有的接口都可以使用Lambda表达式。函数式接口：只有一个抽象方法的接口。
备注1：在Java8中对接口增加了一个新特性，default。增加此关键字后，可以对接口进行实现，也可以不对接口进行实现。
备注2：@FunctionalIinterface这个注解是用来修饰函数式接口的，修饰后只能有一个抽象接口。

二：函数式接口的几种类型（以下为代码示例）
1：无返回值多个参数

@FunctionalInterface
public interface LambdaNoneReturnMutipleParameter {
    void test(int a,int b);
}

2：无返回值无参数

@FunctionalInterface
public interface LambdaNoneReturnNoneParameter {
    void test();
}

3：无返回值单个参数

@FunctionalInterface
public interface LambdaNoneReturnSingleParameter {
    void test(int a);
}

4：有返回值无参数

@FunctionalInterface
public interface LambdaSingleReturnNoneParameter {
    int test();
}

5：有返回值单个参数

@FunctionalInterface
public interface LambdaSingleReturnSingleParameter {
    int test(int a);
}

6：有返回值多个参数

@FunctionalInterface
public interface LambdaSingleReturnMutipleParmeter {
    int test(int a,int b);
}

三：Lambda表达式的基础语法（以代码的形式进行说明）
针对以上6种不同形式的参数作出不同的实现

public class Lambda {
    public static void main(String[] args) {
        //1.lambda表达式的基础语法。关注的方向：参数列表，方法体
        //():用来描述参数列表
        //{}:用来描述方法体
        //->:lambda表达式的运算符，读作goes to

        //无参无返回
        LambdaNoneReturnNoneParameter lambda1=()->{
            System.out.println("helloWord");
        };
        lambda1.test();

        //无返回值，一个参数
        LambdaNoneReturnSingleParameter lambda2=(int a)->{
            int b=10;
            System.out.println(b*a);
        };
        lambda2.test(6);

        //无返回值，多个参数
        LambdaNoneReturnMutipleParameter lambda3=(int a,int b)->{
            System.out.println(a+b);
        };
        lambda3.test(2,3);

        //有返回值，无参数
        LambdaSingleReturnNoneParameter lambda4=()->{
            System.out.println("lambda4");
            return 100;
        };
        System.out.println(lambda4.test());

        //有返回值，单个参数
        LambdaSingleReturnSingleParameter lambda5=(int a)->{
            System.out.println("lambda5");
            return 10+a;
        };
        System.out.println(lambda5.test(5));

        //有返回值，多个参数
        LambdaSingleReturnMutipleParmeter lambda6=(int a,int b)->{
            return a+b;
        };
        System.out.println(lambda6.test(4,5));
    }
}

控制台输出结果：

四：Lambda表达式的语法精简（省略之前的代码参考上方）
1参数类型：由于在接口中已经定义了参数的类型，所以在lambda表达式中参数的类型可以进行省略。备注：如果有多个参数，类型省略则全部进行省略，不得出现只省略部分的参数类型。
//无返回值，多个参数

LambdaNoneReturnMutipleParameter lambda3=(a,b)->{
    System.out.println(a+b);
};
lambda3.test(2,3);

2.参数小括号：如果参数列表中参数的数量只有一个，此时小括号可以进行省略。
//无返回值，单个参数

LambdaNoneReturnSingleParameter lambda2=a->{
    int b=10;
    System.out.println(b*a);
};
lambda2.test(6);

3.方法体的大括号：如果方法体中只有一条语句，此时的大括号可以进行省略。
//无返回值，无参数

LambdaNoneReturnNoneParameter lambda1=()-> System.out.println("helloWord");
lambda1.test();

4.对省略大括号的补充说明：如果方法体中的唯一条语句是返回语句，省略大括号时则要将return关键字一并进行省略。
//有返回值，多个参数

LambdaSingleReturnMutipleParmeter lambda6=(a, b)-> a+b;
System.out.println(lambda6.test(4,5));

五：方法的引用。
可以快速的将一个lambda表达式的实现指向一个已经实现的方法。
注意事项：
1.参数的数量和类型一定要和接口中定义的方法一致
2.返回值的类型一定要和接口中定义的方法一致

public class Lambda1 {
    public static void main(String[] args) {
        LambdaSingleReturnSingleParameter lambda1=a -> change(2);
        //使用方法引用的效果和上方代码的效果一样
        //方法引用语法：方法的隶属者 :: 方法名
        //引用了change方法的实现
        LambdaSingleReturnSingleParameter lambda2=Lambda1::change;
        System.out.println(lambda1.test(2));
        System.out.println(lambda2.test(2));
    }

    public static int change(int a){
        return a*2;
    }
}

控制台输出结果：

六：构造方法的方法引用（以下使用用代码进行展示）
设置一个标准类：

public class Person {
    public String name;
    public int age;

    public Person() {
        System.out.println("Person类的无参构造方法执行了");
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("Person类的有参构造方法执行了");
    }
}

方法执行：

public class Lambda2 {
    public static void main(String[] args) {
        PersonCreater creater=()->new Person();
        //无参构造方法的引用：
        PersonCreater creater1=Person::new;
        Person a=creater1.getPerson();
        //有参构造的方法引用：
        PersonCreater2 creater2=Person::new;
        Person b=creater2.getPerson("ccc",18);
    }
}

//无参数构造方法
interface PersonCreater{
    Person getPerson();
}
//有参数构造方法
interface PersonCreater2{
    Person getPerson(String name,int age);
}

控制台输出结果：

七：Lambda表达式案列
案列要求：已知一个ArrayList有若干个Person对象，将这若干个对象按照年龄进行降序排序。

public class ExerciseOne {
    //集合排序，使用ArrayList
    public static void main(String[] args) {
        ArrayList<Person> list=new ArrayList<>();
        list.add(new Person("zhangsan",18));
        list.add(new Person("lisi",17));
        list.add(new Person("wangwu",28));
        list.add(new Person("zhaoliu",58));
        
        //使用Lambda表达式将对象进行排序
        list.sort((o1, o2) -> o1.age-o2.age);
        System.out.println(list);
    }
}

使用Lambda表达式来实现Compaertor接口，并实例化对象。

public class ExerciseTwo {
    public static void main(String[] args) {
        //此处使用Lambda表达式实现Comperator接口
        TreeSet<Person> set=new TreeSet<>((o1,o2)-> {
            if (o1.age>=o2.age){
                return 1;
            }else {
                return -1;
            }
        });
        set.add(new Person("zhangsan",18));
        set.add(new Person("lisi",17));
        set.add(new Person("wangwu",28));
        set.add(new Person("zhaoliu",58));
        System.out.println(set);
    }
}

使用Lambda表达式进行循环遍历

public class ExerciseThree {
    public static void main(String[] args) {
        ArrayList<Integer> list=new ArrayList<>();
        Collections.addAll(list,1,2,3,4,5,6,7,8,9,10);
        //将集合中的没一个元素带入到方法accpet中
        list.forEach(System.out::println);
        //输出集合中的偶数
        list.forEach(integer -> {
            if (integer % 2 == 0){
                System.out.println(integer);
            }
        });
    }
}

使用lambda表达式删除年龄大于20的人物

public class ExerciseFour {
    public static void main(String[] args) {
        ArrayList<Person> list=new ArrayList<>();
        list.add(new Person("zhangsan",18));
        list.add(new Person("lisi",17));
        list.add(new Person("wangwu",28));
        list.add(new Person("zhaoliu",58));

       /* ListIterator<Person> it=list.listIterator();
        while (it.hasNext()){
            Person ele=it.next();
            if (ele.age > 20){
                it.remove();
            }
        }
        System.out.println(list);*/

        //使用lambda表达式删除年龄大于20的人物
        list.removeIf(els->els.age>20);
        System.out.println(list);
    }
}

使用Lambda表达式开启线程的实例化

public class ExerciseFive {
    public static void main(String[] args) {
        Thread t=new Thread(()-> {
            for (int i = 0; i <10; i++) {
                System.out.println(i);
            }
        });
        t.start();
        System.out.println(t.getName());
    }
}

八：常用的函数式接口
//Predicate : 参数T 返回值boolean
//Consumer : 参数T 无返回值
//Funcation<T,R> : 参数T 返回值R
//Supplier : 参数无 返回值T
//UnaryOperator : 参数T 返回值T
//BinaryOperator : 参数T,T 返回值T
//BiFunction<T,U,R> : 参数T,U 返回值R
//BiPredicate<T,U> : 参数T,U 返回值boolean
//BiConsumer<T,U> : 参数T,U 返回值无
//常用的函数式接口：Predicate，Consumer，Funcation，Supplier