Java8新特性(一)-lambda表达式

本次笔记的学习资料源自B站 尚硅谷UP主发布的教学视频，在此感谢尚硅谷无私的公开了很多高质量的教学视频

本次笔记视频地址:

https://www.bilibili.com/video/BV14W411u7Ly?p=1

场景描述

有一个集合，里边存的多个对象Student对象，要求根据不同的需求从集合中过滤出符合条件的对象。
Student对象类代码：

public class Student {

    public Student() {
    }

    public Student(Integer age, String name, Double fraction) {
        this.age = age;
        this.name = name;
        this.fraction = fraction;
    }

    private Integer age;
    private String name;
    private Double fraction;

    public Integer getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    public Double getFraction() {
        return fraction;
    }

    public void setFraction(Double fraction) {
        this.fraction = fraction;
    }

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

集合代码：

private static List<Student> students = Arrays.asList(
            new Student(18,"tom",78.0),
            new Student(20,"jerry",65.9),
            new Student(15,"rose",58.5),
            new Student(13,"jack",42.8),
            new Student(25,"jams",84.5));

需求1：
获取年龄大于18岁的学生
于是写了一个方法

public static void test1(){
        for (Student student : students){
            if(student.getAge() >= 18){
                System.out.println(student);
            }
        }
    }

然后在main方法里调用这个方法：

public static void main(String[] args) {
     test1();
}

需求2：
获取分数大于70分的学生

public static void test2(){
        for (Student student : students){
            if(student.getFraction() > 70){
                System.out.println(student);
            }
        }
    }

public static void main(String[] args) {
     test2();
}

按照这种思路，需求增加，方法就要增加，而方法里不同的代码只有一行，代码重复率高。

优化方式一

把判断逻辑抽象出来，形成一个接口，让不同的实现类去实现具体的判断逻辑。
创建接口

public interface Check<T> {
    boolean test(T t);
}

重新定义业务方法

public static void test3(Check<Student> check){
        for (Student student : students){
            if(check.test(student)){
                System.out.println(student);
            }
        }
    }

创建需求1的实现类

public class CheckStudentByAge implements Check<Student>{
    @Override
    public boolean test(Student student) {
        return student.getAge() >=18;
    }
}

调用业务方法

public static void main(String[] args) {
test3(new CheckStudentByAge());
}

创建需求2的实现类

public class CheckStudentByFraction implements Check<Student>{
    @Override
    public boolean test(Student student) {
        return student.getFraction()>=70;
    }
}

调用业务方法

public static void main(String[] args) {
test3(new CheckStudentByFraction());
}

由此可见，这种方式，只需要一个业务方法即可，增加需求就要增加一个业务类，实现具体的业务方法即可。

优化方式二

匿名内部类

public static void main(String[] args) {
test3(new Check<Student>() {
            @Override
            public boolean test(Student student) {
                return student.getAge() < 18;
            }
        });
}

我们调用test3方法时，不需要再新增具体的实现类，通过匿名内部类的方式实现具体的业务逻辑。减少了代码文件。

优化方式三

lambda表达式
这种方式可以看成是匿名内部类的简写，提取出了匿名内部类中最有用的部分代码。

public static void main(String[] args) {
test3(x -> x.getAge()>18);
test3(x -> x.getFraction() < 60);
}