Java 8 Lambda 表达式与方法引用的语法优化及实战应用研究

Lambda表达式：

是jkd8开始新增的一种语法形式；作用：简化匿名内部类的代码写法

注意：Lambda 表达式只能简化函数式接口的匿名内部类！！！

什么是函数式接口？

有且只有一个抽象方法的接口
注意：将来我们见到的大部分函数式接口，上面大部分都可能会有一个@FunctionalInterface的注解，又该注解的接口必定是函数式接口

Lambda表达式的省略步骤：

1.参数类型可以不写

2.如果只有一个参数，参数类型可以省略，同时（）也可以省略

3.如果Lambda表达式中的方法体只有一行代码，可以省略大括号不写，同时也要省略分号！此时，如果这行代码是return 语句，return也必须要去掉

正则表达式：

判断字符串是否匹配曾泽表达式，匹配返回true，不匹配返回false

java 复制代码

public boolean matches(String regex) 
判断字符串是否匹配曾泽表达式，匹配返回true，不匹配返回false

字符类(只匹配单个字符)

预定义字符(只匹配单个字符)

数量词

校验邮箱是否正确的方法：

java 复制代码

package org.example;

import java.util.Scanner;

public class demo1 {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        while(true){

            System.out.println("请您输入正确的邮箱");
            String str = sc.next();

            if (str.matches("\\w{2,30}@\\w{2,20}(\\.\\w{2,20}){1,2}") ){
                System.out.println("格式输入正确");
                break;
            }else{
                System.out.println("格式输入错误");

            }


        }
    }
}

验证手机号：

java 复制代码

package org.example;

import java.util.Scanner;

public class demo2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        while(true){
            System.out.println("请输入正确格式的手机号");
            String phoneNumber = sc.next();
              if(phoneNumber.matches("1[3-9]\\d{9}")){
                  System.out.println("你输入的手机号格式正确");
                  break;
              }else{
                  System.out.println("你输入的手机号格式错误");

              }
        }
    }
}

方法引用：

1.静态方法引用

使用方法：类名:: 静态方法

如果某个Lambda表达式里只是调用一个静态的方法，并且前后参数的形式一致，就可以使用静态方法引用

初始 Lambda 写法：

java 复制代码

Arrays.sort(students, (o1, o2) -> Student.compareByHeight(o1, o2));

简化后的方法引用写法：

复制代码

Arrays.sort(students, Student::compareByHeight); // 终极简化代码!

2.实例方法引用

使用方法：对象名:实例方法

使用场景：

如果某个Lambda表达式只是调用一个实例方法，并且前后参数的形式一致，就可以使用实例方法引用。

java 复制代码

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

3.特定类型的方法引用

类::方法

使用场景：

如果使用某个Lambda表达式里只是一个调用一个实例方法，并且前面参数列表中的第一个参数作为方法的主调，后面的所有参数都是作为该实例方法的入参的，则此时的就可以使用特定类型的方法引用

java 复制代码

import java.util.Arrays;
import java.util.Comparator;

public class Demo {
    public static void main(String[] args) {
        // 定义字符串数组
        String[] names = {"dada", "Angela", "baby", "lala", "didi", "牛牛", "delay", "early", "aabd"};

        // 对数组排序（按照首字母编号排序，忽略大小写）
        // 方式1：匿名内部类实现Comparator
        Arrays.sort(names, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                // o1 Angela
                // o2 andy
                return o1.compareToIgnoreCase(o2);
            }
        });

        // 方式2：Lambda表达式简化
        Arrays.sort(names, (o1, o2) -> o1.compareToIgnoreCase(o2));

        // 方式3：方法引用终极简化
        Arrays.sort(names, String::compareToIgnoreCase);

        // 输出排序后的数组
        System.out.println(Arrays.toString(names));
    }
}

3.构造器引用

使用：类名:: new

使用场景：

如果某个Lambda表达式里只是在创建对象，并且前后参数情况一致，就可以使用构造器引用

java 复制代码

import java.util.function.Function;

// 1. 函数式接口（定义"创建水果"的抽象方法）
@FunctionalInterface
interface CreateFruit {
    Fruit create(String name); // 抽象方法：输入名称，返回Fruit对象
}

// 2. 水果实体类（包含构造器）
class Fruit {
    private String name;

    // 带参构造器（用于创建水果对象）
    public Fruit(String name) {
        this.name = name;
    }

    // 获取水果名称
    public String getName() {
        return name;
    }
}

// 3. 测试类（演示构造器引用的简化）
public class ConstructorRefDemo {
    public static void main(String[] args) {
        // 方式1：匿名内部类实现CreateFruit
        CreateFruit create1 = new CreateFruit() {
            @Override
            public Fruit create(String name) {
                return new Fruit(name); // 调用Fruit的构造器
            }
        };
        Fruit apple = create1.create("苹果");
        System.out.println(apple.getName()); // 输出：苹果


        // 方式2：Lambda表达式简化
        CreateFruit create2 = name -> new Fruit(name);
        Fruit banana = create2.create("香蕉");
        System.out.println(banana.getName()); // 输出：香蕉


        // 方式3：构造器引用（终极简化）
        CreateFruit create3 = Fruit::new; // 直接引用Fruit的构造器
        Fruit orange = create3.create("橙子");
        System.out.println(orange.getName()); // 输出：橙子
    }
}

Lambda简化：

java 复制代码

        // 方式2：Lambda表达式简化
        CreateFruit create2 = name -> new Fruit(name);
        Fruit banana = create2.create("香蕉");
        System.out.println(banana.getName()); // 输出：香蕉

特定类型的方法引用：

java 复制代码

   // 方式3：构造器引用（终极简化）
        CreateFruit create3 = Fruit::new; // 直接引用Fruit的构造器
        Fruit orange = create3.create("橙子");
        System.out.println(orange.getName()); // 输出：橙子
    }
}