Lambda表达式

一、Lambda表达式

Lambda表达式的作用是什么？
简化函数式接口的匿名内部类。
什么样的接口是函数式接口？
只有一个抽象方法的接口就是函数式接口。

示例代码：目标：认识Lambda是如何简化匿名内部类的。

public class LambdaTest {
    public static void main(String[] args) {
        
        Animal a1 = new Animal() {
            @Override
            public void run() {
                System.out.println("老虎跑的贼快~~~~");
            }
        };
        a1.run();

        Swimming s1 = new Swimming() {
            @Override
            public void swim() {
                System.out.println("学生游泳贼溜~~~~");
            }
        };
        s1.swim();

        // Lambda可以简化函数式接口的匿名内部类
        // 可以上下文推断出真实的代码形式！
        Swimming s2 = () -> {
                System.out.println("老师游泳贼溜~~~~");
        };
        s2.swim();
    }
}

//接口
@FunctionalInterface
interface Swimming{// 函数式接口中有且仅有一个抽象方法
    void swim();
}

//抽象类
abstract class Animal{
    public abstract void run();
}

Lambda表达式的省略写法(进一步简化Lambda表达式的写法)：
参数类型可以省略不写。
如果只有一个参数，参数类型可以省略，同时()也可以省略。
如果Lambda表达式中的方法体代码只有一行代码，可以省略大括号不写，同时要省略分号！此时，如果这行代码是return语句，也必须去掉return不写。

示例代码：

public class LambdaTest2 {
    public static void main(String[] args) {
        // 目标：掌握Lambda表达式简化常见函数式接口的匿名内部类
        double[] scores = {99.5, 90, 59.5, 78, 98, 55};
        // 需求：为每个分数加分10分。
        Arrays.setAll(scores, new IntToDoubleFunction() {
            @Override
            public double applyAsDouble(int index) {
                return scores[index] + 10;
            }
        });

        Arrays.setAll(scores, index -> scores[index] + 10 );

        System.out.println(Arrays.toString(scores));

        Student[] students = new Student[4]; // students = [null, null, null, null]
        //                                                   0     1     2     3
        students[0] = new Student("周芷若", 21, '女', 169.3);
        students[1] = new Student("殷素素", 38, '女', 172.2);
        students[2] = new Student("小昭", 19, '女', 168.5);
        students[3] = new Student("张无忌", 23, '男', 183.5);

        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return Double.compare(o1.getHeight(), o2.getHeight());
            }
        });

        Arrays.sort(students, (o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight()));

        System.out.println(Arrays.toString(students));
    }
}

public class Student implements Comparable<Student>{

    private String name;
    private int age;
    private char gender;
    private double height;

    public Student() {
    }

    public Student(String name, int age, char gender, double height) {
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.height = height;
    }

    // 指定大小规则
    // 比较者：this
    // 被比较者：o
    @Override
    public int compareTo(Student o) {
        /**
         * 官方规定：
         * 如果您认为左边大于右边，请返回正整数。
         * 如果您认为左边小于右边，请返回负整数。
         * 如果您认为左边等于右边，请返回0。
         * 只要这么干，默认就是升序排序
         */
        //return this.age - o.age; // 升序。
        return o.age - this.age; // 降序。
    }


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


}