java8特性，lambda表达式,简写的演变及应用

🍬博主介绍
👨‍🎓 博主主页：chad_chang的主页
✨主攻领域：【大数据】【java】【python】【面试分析】

lambda表达式

1.1.简介

1.1.1.什么是Lambda？

Lambda是JAVA 8添加的新特性，说白了，Lambda是一个匿名函数

1.1.2.为什么使用Lambda

使用Lambda表达式可以对一个接口的方法进行非常简洁的实现

1.1.3.Lambda对接口的要求

虽然可以使用Lambda表达式对某些接口进行简单的实现，但是并不是所有的接口都可以用Lambda表达式来实现，要求接口中定义的必须要实现的抽象方法只能是一个
在JAVA8中 ，对接口加了一个新特性：default
可以使用default对接口方法进行修饰，被修饰的方法在接口中可以默认实现

1.1.4.@FunctionalInterface

修饰函数式接口的，接口中的抽象方法只有一个

1.2.基本语法

1.2.1.语法格式

(parameters) -> expression
或
(parameters) -> { statements; }
() 用来描述参数列表
{} 用来描述方法体 有时可以省略
-> lambda运算符

1.2.2.准备工作: 创建接口

/**
 * 无参数无返回值接口
 */
@FunctionalInterface
interface LambdaNoneReturnNoneParmeter {

    void test();
}

/**
 * 无返回值有单个参数
 */
@FunctionalInterface
interface LambdaNoneReturnSingleParmeter {

    void test(int n);
}

/**
 * 无返回值 多个参数的接口
 */
@FunctionalInterface
interface LambdaNoneReturnMutipleParmeter {

    void test(int a,int b);
}

/**
 * 有返回值 无参数接口
 */
@FunctionalInterface
interface LambdaSingleReturnNoneParmeter {

    int test();
}

/**
 * 有返回值 有单个参数的接口
 */
@FunctionalInterface
interface LambdaSingleReturnSingleParmeter {

    int test(int n);
}

/**
 * 有返回值 有多个参数的接口
 */
@FunctionalInterface
interface LambdaSingleReturnMutipleParmeter {

    int test(int a,int b);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

1.2.3.创建类Demo

import org.junit.Test;

public class Demo {

    @Test
    public void test01() {

        LambdaSingleReturnMutipleParmeter lambda1 = new LambdaSingleReturnMutipleParmeter() {
            @Override
            public int test(int a, int b) {
                return a + b;
            }
        };

        int result = lambda1.test(1, 2);
        System.out.println(result);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

注意：运行，会出现以下错误

解决方法
修改工作空间
修改工作空间，路径为：.idea --> workspace.xml

找到标签 。在标签里加一行：

<property name="dynamic.classpath" value="true" />
1

如下图：

此刻可以顺利运行，但是这不是我们的重点；
重点是lambda的学习。

1.3语法精简

1.3.1. lambda写法

在Demo类中继续写以下代码：

    @Test
    public void test02(){
        LambdaSingleReturnMutipleParmeter lambda2 = (int a, int b) -> {
                return a + b;
        };

        int result2 = lambda2.test(1, 2);
        System.out.println(result2);
    }
}
1
2
3
4
5
6
7
8
9
10

1.3.2. 参数类型精简

因为在接口的方法中, 已经定义类参数的类型, 所以在lambda表达式中参数的类型可以省略

    @Test
    public void test02(){
        LambdaSingleReturnMutipleParmeter lambda2 = (a, b) -> {
                return a + b;
        };

        int result2 = lambda2.test(1, 2);
        System.out.println(result2);
    }
}
1
2
3
4
5
6
7
8
9
10

1.3.3. 参数小括号精简

如果参数列表中, 参数的个数只有一个, 此时小括号可以省略；

    @Test
    public void test03(){
    //一个参数一个返回值
        LambdaSingleReturnSingleParmeter lambda3 = a -> {return 10;};

        int result3 = lambda3.test(1);
        System.out.println(result3);
    }
1
2
3
4
5
6
7
8

1.3.4.方法大括号精简

如果方法中只有一条语句, 此时大括号也可以省略

1.3.5.大括号精简补充

如果方法体中唯一的一条语句是一个返回结果语句,
则省略大括号的同时 也必须省略return关键字

    @Test
    public void test04(){
    //无参一个返回值
        LambdaSingleReturnNoneParmeter lambda4 =()  -> 10;

        int result4 = lambda4.test();
        System.out.println(result4);
    }
1
2
3
4
5
6
7
8

1.4.语法进阶

1.4.1.方法引用(静态方法和普通方法)

1.4.1.1.why

在实际应用过程中, 一个接口在很多地方都会调用同一个实现, 例如

LambdaSingleReturnMutipleParmeter lambda1 = (a, b) -> a + b;
LambdaSingleReturnMutipleParmeter lambdab = (a, b) -> a * b;
1
2

这样一来每次都要写上具体的实现方法, 如果需求变更, 则每一处都需要更改, 基于这种情况, 可以将后续的实现更改为自定义的方法, 需要时直接调用即可.

1.4.1.2.what

方法引用:
可以快速的将一个lambda表达式的实现指向一个已经实现的方法
方法的隶属者 如果是静态方法, 隶属者就是一个类, 其他的话都是隶属对象
语法: 方法的隶属者::方法名
注意:

1 引用的方法中, 参数的个数和类型一定要和接口中定义的方法一致
2 返回值的类型也一定要和接口中的方法一致

1.4.1.3.how

1.4.1.3.1.静态方法

package stream.lambda.cn.itcast.b;

public class Demo {
    public static void main(String[] args) {
        // 精简前
        LambdaSingleReturnMutipleParmeter lambda1 = (a, b) -> a + b;
        LambdaSingleReturnMutipleParmeter lambda2 = (a, b) -> a * b;

        // 精简后
        LambdaSingleReturnMutipleParmeter lambda3 = (a, b) -> MyStaticClass.add(a, b);
        LambdaSingleReturnMutipleParmeter lambda4 = MyStaticClass::multiplication;
    }


}

// 静态方法类
class MyStaticClass {
    public static int add(int x, int y) {
        return x + y;
    }

    public static int multiplication(int x, int y) {
        return x * y;
    }
}


/**
 * 有返回值 有多个参数的接口
 */
@FunctionalInterface
interface LambdaSingleReturnMutipleParmeter {

    int test(int a, int b);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

1.4.1.3.2.非静态普通方法

package stream.lambda.cn.itcast.c;

public class Demo {
    public static void main(String[] args) {
        // 精简前
        LambdaSingleReturnMutipleParmeter lambda1 = (a, b) -> a + b;
        LambdaSingleReturnMutipleParmeter lambda2 = (a, b) -> a * b;

        // 精简后
        MyNotStaticClass myNotStaticClassObj = new MyNotStaticClass();
        LambdaSingleReturnMutipleParmeter lambda3 = (a, b) -> myNotStaticClassObj.add(a, b);
        LambdaSingleReturnMutipleParmeter lambda4 = myNotStaticClassObj::multiplication;
        int result3 = lambda3.test(10, 20);
        int result4 = lambda4.test(10, 20);
        System.out.println("result3 = " + result3);
        System.out.println("result4 = " + result4);
    }
}

// 自定义非静态类
class MyNotStaticClass {
    public int add(int x, int y) {
        return x + y;
    }

    public int multiplication(int x, int y) {
        return x * y;
    }
}

/**
 * 有返回值 有多个参数的接口
 */
@FunctionalInterface
interface LambdaSingleReturnMutipleParmeter {
    int test(int a, int b);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37