JavaSE（十三）——函数式编程（Lambda表达式、方法引用、Stream流）

函数式编程

函数式编程 是 Java 8 引入的一个重要特性，它允许开发者以函数作为一等公民（first-class citizens）的方式编程，即函数可以作为参数传递给其他函数，也可以作为返回值。 这极大地提高了代码的可读性、可维护性和复用性。函数式编程的核心概念包括高阶函数、Lambda 表达式、函数式接口、流（Streams）和 Optional 类等。

函数式编程的核心是Lambda表达式，它是一种简洁的表示匿名方法的方式。Lambda表达式允许你以更简洁的方式传递代码块作为参数给方法，这是Java 8及以后版本中引入的一个重要特性，它主要用在实现只有一个抽象方法的接口（即函数式接口）时。

Lambda表达式只能替代函数式接口的匿名内部类，所以我们先了解函数式接口。

函数式接口

函数式接口是一个具有且仅有一个抽象方法的接口。 它可以包含默认方法和静态方法，但这些方法不会破坏接口作为函数式接口的性质，因为它们不是抽象方法。

函数式接口的特点：

• 单一抽象方法：只含有一个抽象方法
• Lambda表达式支持：可以使用Lambda表达式简洁地实现该接口
• @FunctionalInterface注解：推荐使用@FunctionalInterface注解来标记一个接口为函数式接口。这有助于编译器检查接口是否符合函数式接口的规范，并在接口中错误地添加了第二个抽象方法时提供编译时错误。

例如，我们常用的Comparetor接口就是函数式接口

• Comparator接口使用到@FunctionalInterface注释
• compare方法是Comparator接口唯一的抽象方法，尽管存在其他方法，但都是静态方法和默认方法，不会影响函数式接口的性质

---

Lambda表达式

Lambda表达式的使用

Lambda表达式用于替代函数式接口的匿名内部类对象，从而让程序更简洁，可读性更好。

基本格式如下：

(被重写方法的参数列表) -> {
   
     
    被重写方法的方法体代码 
}

---

【举例演示Lambda表达式】

实现函数式接口：

• 使用匿名内部类：

interface ITest1 {
   
   
    void function();
}

public class LambdaDemo1 {
   
   
    public static void main(String[] args) {
   
   
        ITest1 iTest1 = new ITest1() {
   
   
            @Override
            public void function() {
   
   
                System.out.println("被重写的接口抽象方法...");
            }
        };
    }
}

• Lambda表达式：

interface ITest1 {
   
   
    void function();
}

public class LambdaDemo1 {
   
   
    public static void main(String[] args) {
   
   
        ITest1 iTest1 = ()->{
   
   System.out.println("被重写的接口抽象方法...");};
    }
}

---

自定义一个学生类，创建一个学生类对象数组，使用comparator比较器 和 Arrays.sort()方法对其排序（要求：使用匿名内部类和Lambda表达式两种方式实现）：

//自定义学生类
class Student {
   
   
    public String name;
    public int age;
    public double score;

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

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


public class LambdaDemo1 {
   
   

    //Lambda表达式
    public static void byLambda(Student[] student) {
   
   
        Student[] students = new Student[3];
        for (int i = 0; i < students.length; i++) {
   
   
            students[i] = student[i];
        }
        System.out.println("排序前：" + Arrays.toString(students));
        Arrays.sort(students, (Student o1, Student o2)->{
   
   return o1.age - o2.age;});
        System.out.println("排序后：" + Arrays.toString(students));
    }

    //匿名内部类
    public static void byInnerclass(Student[] student) {
   
   
        Student[] students = new Student[3];
        for (int i = 0; i < students.length; i++) {
   
   
            students[i] = student[i];
        }
        System.out.println("排序前：" + Arrays.toString(students));
        Arrays.sort(students, new Comparator<Student>() {
   
   
            @Override
            public int compare(Student o1, Student o2) {
   
   
                return o1.age - o2.age;
            }
        });
        System.out.println("排序后：" + Arrays.toString(students));
    }


    public static void main(String[] args) {
   
   
        Student[] students = new Student[3];
        students[0] = new Student("张三", 19, 98.2);
        students[1] = new Student("李四", 21, 88.5);
        students[