【 Java基础】试试通俗易懂的Lambda表达式？

分手后的思念是犯贱 2024-03-26 12:41 140阅读 0赞

### 前言 ###

`Lambda`表达式是`JDK8`的一个新特性，可以取代大部分的匿名内部类，写出更优雅的`Java`代码，尤其在集合的遍历和其他集合操作中，可以`极大地优化代码结构`。

`JDK`也提供了大量的`内置函数式接口`供我们使用，使得`Lambda`表达式的运用更加`方便、高效`。

### 一、什么是Lambda表达式 ###

`Lambda`表达式,也称为`闭包`：`java8`的新特性，lambda运行将函数作为一个方法的参数，也就是`将函数作为参数传递到方法中`。使用lambda表达式可以让代码更加简洁。

`Lambda`表达式常用于简化接口实现，关于接口实现，可以有很多种方式。例如：

> 1.  创建接口的实现类;
> 2.  使用匿名内部类;

但是`lambda`表达式，比这两种方式都简单。代码示例如下：

interface TestInterface{
        public void testFun();
    }
    
    public class TestClass {
        public static void main(String[] args) { 
            //使用lambda表达式实现接口
            TestClass test = () -> {
                System.out.println("test");
            };
            test.testFun();
        }
    }

### 二、使用前提 ###

上文中提到，`lambda表达式`可以在`⼀定程度上简化`接口的实现。但是，`并不是所有的接口`都可以使用`lambda`表达式来简化接口的实现的。

先说结论，`lambda表达式，只能实现函数式接口`。`lambda`表达式毕竟只是⼀个`匿名方法`。

### 三、函数式接口 ###

#### 3.1 概念 ####

`函数式接口`在 Java 中是指： **有且仅有一个抽象方法的接口** 。

`函数式接口`，即`适用于函数式编程场景的接口`。而 Java 中的函数式编程体现就是`Lambda`，所以函数式接口就是可以适用于`Lambda`使用的接口。只有确保接口中有且仅有一个抽象方法，`Java`中的 `Lambda`才能顺利地进行推导。

> **备注：**
> 
> `语法糖` 是指使用更加方便，但是原理不变的代码语法。
> 
> **例如：**
> 
> 在遍历集合时使用的`for-each`语法，其实底层的实现原理仍然是`迭代器`，这便是`语法糖`。从应用层面来讲， Java 中的 `Lambda` 可以被当做是匿名内部类的`语法糖`，但是二者在原理上是不同的。

#### 3.2 格式 ####

只要确保接口中`有且仅有一个抽象方法`即可，伪代码如下：

修饰符 interface 接口名称 {
        public abstract 返回值类型 方法名称（可选参数信息）;
        // 其它非抽象方法内容
    }

由于接口当中抽象方法的`public abstract`是可以省略的，所以定义一个函数式接口很简单：

public interface TestFunctionalInterface {
        void testMethod();
    }

#### 3.3 @FunctionalInterface ####

与 `@Override` 注解的作用类似， `Java 8` 中专门为函数式接口引入了一个新的注解：`@FunctionalInterface`。该注解可用于一个接口的定义上：

@FunctionalInterface
    public interface TestFunctionalInterface {
        void testMethod();
    }

一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。需要注意的是，即使不使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，使用起来都一样。

#### 3.4 自定义函数式接口 ####

对于刚刚定义好的 `MyFunctionalInterface` 函数式接口，典型使用场景就是作为方法的参数：

public class TestFunctionalClass {
        // 使用自定义的函数式接口作为方法参数
        private static void doSomeThing(TestFunctionalInterface testInterFace){
            testInterFace.testMethod();
        }
        
        public static void main(String[] args) {
            // 调用函数式接口的方法
            doSomeThing(() -> System.out.println("Hello world!"));
        }
        
    }

### 四、语法格式 ###

#### 4.1 基础语法 ####

`lambda`表达式，其实本质来讲，就是⼀个`匿名函数`。因此在写`lambda`表达式的时候，不需要关心方法名是什么。

实际上，我们在写`lambda`表达式的时候，也不需要关心返回值类型，只需要关注两部分内容即可：`参数列表和方法体`

> (参数1,参数2,…) -> \{
> 
> 方法体
> 
> \};

`各部分详述`：

> `参数部分`：方法的参数列表，要求和实现的接口中的方法参数部分⼀致，包括参数的数量和类型。
> 
> `方法体部分` ： 方法的实现部分，如果接口中定义的方法有返回值，则在实现的时候，注意返回值的返回。
> 
> `->`: 分隔参数部分和方法体部分。

`总结来说`：语法形式为 () -> \{\}，其中 () 用来描述参数列表，\{\} 用来描述方法体，-> 为 lambda运算符 ，读作(goes to)。

#### 4.2 重要特征 ####

*  \*\*可选类型声明：\*\*不需要声明参数类型，编译器可以统一识别参数值。
 *  \*\*可选的参数圆括号：\*\*一个参数无需定义圆括号，但多个参数需要定义圆括号。
 *  \*\*可选的大括号：\*\*如果主体包含了一个语句，就不需要使用大括号。
 *  \*\*可选的返回关键字：\*\*如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定表达式返回了一个数值。

> 代码示例：

public class Demo01 {
        /**多参数无返回*/
        @FunctionalInterface
        public interface NoReturnMultiParam {
            void method(int a, int b);
        }
    
        /**无参无返回值*/
        @FunctionalInterface
        public interface NoReturnNoParam {
            void method();
        }
    
        /**一个参数无返回*/
        @FunctionalInterface
        public interface NoReturnOneParam {
            void method(int a);
        }
    
        /**多个参数有返回值*/
        @FunctionalInterface
        public interface ReturnMultiParam {
            int method(int a, int b);
        }
    
        /*** 无参有返回*/
        @FunctionalInterface
        public interface ReturnNoParam {
            int method();
        }
    
        /**一个参数有返回值*/
        @FunctionalInterface
        public interface ReturnOneParam {
            int method(int a);
        }
        
        public static void main(String[] args) {
    
            //无参无返回
            NoReturnNoParam noReturnNoParam = () -> {
                System.out.println("NoReturnNoParam");
            };
            noReturnNoParam.method();
    
            //一个参数无返回
            NoReturnOneParam noReturnOneParam = (int a) -> {
                System.out.println("NoReturnOneParam param:" + a);
            };
            noReturnOneParam.method(6);
    
            //多个参数无返回
            NoReturnMultiParam noReturnMultiParam = (int a, int b) -> {
                System.out.println("NoReturnMultiParam param:" + "{" + a +"," + + b +"}");
            };
            noReturnMultiParam.method(6, 8);
    
            //无参有返回值
            ReturnNoParam returnNoParam = () -> {
                System.out.print("ReturnNoParam");
                return 1;
            };
    
            int res = returnNoParam.method();
            System.out.println("return:" + res);
    
            //一个参数有返回值
            ReturnOneParam returnOneParam = (int a) -> {
                System.out.println("ReturnOneParam param:" + a);
                return 1;
            };
    
            int res2 = returnOneParam.method(6);
            System.out.println("return:" + res2);
    
            //多个参数有返回值
            ReturnMultiParam returnMultiParam = (int a, int b) -> {
                System.out.println("ReturnMultiParam param:" + "{" + a + "," + b +"}");
                return 1;
            };
    
            int res3 = returnMultiParam.method(6, 8);
            System.out.println("return:" + res3);
        }
        
    }

控制台输出：

NoReturnNoParam
    NoReturnOneParam param:6
    NoReturnMultiParam param:{6,8}
    ReturnNoParamreturn:1
    ReturnOneParam param:6
    return:1
    ReturnMultiParam param:{6,8}
    return:1

### 五、语法简化 ###

#### 5.1 **参数部分的精简** ####

5.1.1 `参数的类型`

由于在接口的方法中，已经定义了每⼀个参数的类型是什么。而且在使用lambda表达式实现接口的时候，必须要保证参数的数量和类 型需要和接口中的方法保持⼀致。因此，此时lambda表达式中的参数的类型可以省略不写。

**注意事项：**

如果需要省略参数的类型，要保证：要省略， 每⼀个参数的类型都必须省略不写。绝对不能出现，有的参数类型省略了，有的参数类型没有省略。

// 有参+返回值
    Test test = (name,age)  -> {
        System.out.println(name+age+"了！");
        return age + 1;
    };
    
    int age = test.test("小刘学编程",18);
    System.out.println(age);

5.1.2 `参数的小括号`

如果方法的参数列表中的参数数量 有且只有⼀个，此时，参数列表的小括号是可以省略不写的。

**注意事项：**

*  只有当参数的数量是⼀个的时候， 多了、少了都不能省略。
 *  省略掉小括号的同时， 必须要省略参数的类型

//一个参数
    Test test = name -> {
        System.out.println(name+"test");
    };
    test.test("小刘学编程");

#### 5.2 **方法体部分的精简** ####

当⼀个方法体中的逻辑，有且只有⼀句的情况下，⼤括号可以省略

Test test = name -> System.out.println(name+"test");
    test.test("小新");

#### 5.3 **return部分的精简** ####

如果⼀个方法中唯⼀的⼀条语句是⼀个返回语句， 此时在省略掉大括号的同时， 也必须省略掉return。

Test test = (a,b) -> a+b;

### 六、常用示例 ###

`lambda`表达式是为了简化接口的实现的，在lambda表达式中，不应该出现比较复杂的逻辑。如果在lambda表达式中需要处理的逻辑比较复杂，会对程序的可读性造成非常大的影响，⼀般情况会单独的写⼀个方法。在lambda表达式中直接引用这个方法即可。

**函数引用**：引用⼀个已经存在的方法，使其替代`lambda表达式`完成接口的实现

#### 6.1 静态方法的引用 ####

**语法**：类::静态方法

**注意事项：**

*  在引用的方法后面，不要添加小括号。
 *  引用的这个方法，参数（数量、类型）和返回值，必须要跟接口中定义的⼀致

class Subtraction{
        public static int subtract(int a,int b ){
            // 稍微复杂的逻辑：计算a和b的差值的绝对值
            if (a > b) {
                return a - b;
            }
            return b - a;
        }
    }
    
    interface TestInterface{
        int test(int a,int b);
    }
    
    public class TestClass {
        public static void main(String[] args) {
            //实现多个参数，一个返回值的接口
            //对一个静态方法的引用，语法：类::静态方法
            TestInterface test = Subtraction::subtract;
            System.out.println(test.test(1,2));
        }
    }

#### 6.2 非静态方法的引用 ####

**语法**：方法归属者::方法名 静态方法的归属者为类名，普通方法归属者为对象

**注意事项**:

*  在引用的方法后⾯，不要添加小括号。
 *  引用的这个方法， 参数（数量、类型） 和 返回值， 必须要跟接口中定义的⼀致。

public class Test06 {
        public static void main(String[] args) {
            //对非静态方法的引用，需要使用对象来完成
            Test2 test2 = new Calculator()::calculate;
            System.out.println(test2.calculate(2, 3));
        }
        private static class Calculator{
            public int calculate(int a, int b) {
                return a > b ? a - b : b - a;
             }
        }
    }
    interface Test2{
        int calculate(int a,int b);
    }

#### 6.3 构造方法的引用 ####

**使用场景**

如果某⼀个函数式接口中定义的方法，仅仅是为了得到⼀个类的对象。此时我们就可以使用构造方法的引用，简化这个方法的实现。

**语法**：类名::new

**注意事项**：可以通过接口中的方法的参数， 区分引用不同的构造方法。

interface ItemCreatorBlankConstruct {
        Item getItem();
    }
    interface ItemCreatorParamContruct {
        Item getItem(int id, String name, double price);
    }
    
    public class Exe2 {
        public static void main(String[] args) {
            ItemCreatorBlankConstruct creator = () -> new Item();
            Item item = creator.getItem();
    
            ItemCreatorBlankConstruct creator2 = Item::new;
            Item item2 = creator2.getItem();
    
            ItemCreatorParamContruct creator3 = Item::new;
            Item item3 = creator3.getItem(112, "小刘学编程", 135.99);
        }
    }

#### 6.4 Lambda 表达式创建线程 ####

创建线程一般都是通过创建`Thread`对象，然后通过匿名内部类重写`run()`方法，一提到匿名内部类就应该想到可以使用 lambda 表达式来简化线程的创建过程。

Thread t = new Thread(() -> {
        for (int i = 0; i < 10; i++) {
            System.out.println("新建线程->" + ":" + i);
        }
    });
    t.start();

#### 6.5 遍历集合 ####

可以调用集合的 `public void forEach(Consumer<? super E> action)` 方法，通过 lambda 表达式的方式遍历集合中的元素。以下是`Consumer接口`的方法以及遍历集合的操作。`Consumer`接口是`jdk`提供的一个函数式接口。

@FunctionalInterface
    public interface Consumer<T> {
        void accept(T t);
        //....
    }

ArrayList<Integer> list = new ArrayList<>();
    Collections.addAll(list, 1,2,3,4,5);
    //lambda表达式 方法引用
    list.forEach(System.out::println);
    
    list.forEach(item -> {
        if (element % 2 == 0) {
            System.out.println(item);
        }
    });

#### 6.6 删除集合中的某个元素 ####

通过`public boolean removeIf(Predicate<? super E> filter)`方法来删除集合中的某个元素，`Predicate`也是`jdk`为提供的一个函数式接口，可以简化程序的编写。

ArrayList<Item> items = new ArrayList<>();
    items.add(new Item(11, "小牙刷", 12.05 ));
    items.add(new Item(5, "日本马桶盖", 999.05 ));
    items.add(new Item(7, "格力空调", 888.88 ));
    items.add(new Item(17, "肥皂", 2.00 ));
    items.add(new Item(9, "冰箱", 4200.00 ));
    
    items.removeIf(ele -> ele.getId() == 7);
    
    //通过 foreach 遍历，查看是否已经删除
    items.forEach(System.out::println);

#### 6.7 集合内元素的排序 ####

若要为集合内的元素排序，就必须调用`sort`方法，传入比较器匿名内部类重写`compare 方法`，现在可以使用`lambda 表达式`来简化代码。

ArrayList<Item> list = new ArrayList<>();
    list.add(new Item(13, "背心", 7.80));
    list.add(new Item(11, "半袖", 37.80));
    list.add(new Item(14, "风衣", 139.80));
    list.add(new Item(12, "秋裤", 55.33));
    
    list.sort((o1, o2) -> o1.getId() - o2.getId());
    System.out.println(list);

### 七、注意 ###

这⾥类似于`局部内部类`、`匿名内部类`，依然存在闭包的问题。如果在`lambda表达式`中，使用到了`局部变量`，那么这个`局部变量会被隐式的声明为 final`。是⼀个常量，不能修改值。

如下代码示例：如果我们把注释放开会报错，提示`num`值是`final`不能被改变。这里虽然没有标识`num`类型为`final`，但是在编译期间虚拟机会加上`fina`修饰关键字。

public static void main(String[] args) {
    
        int num = 10;
    
        Test<String> test = () -> {
            System.out.println(num);
        };
    
        //num = num + 2;
        test.doSomeThing("hello world !");
    }

### 总结 ###

本文从Lambda表达式的基础概念、函数式接口、以及Lambda表达式的常用示例几方面完整的讨论了这一Java8新增的特性，实际开发中确实为我们提供了许多便利，简化了代码。欢迎小伙伴继续提出不同的见解一起讨论！