java进阶-JDK1.8新特性：Lambda表达式

持久的棒棒君

已于 2022-03-06 21:15:06 修改

阅读量1.1k

点赞数

分类专栏：大杂烩文章标签： java

于 2022-03-05 21:21:14 首次发布

本文链接：https://blog.csdn.net/lalala_dxf/article/details/123217842

版权

大杂烩专栏收录该内容

259 篇文章 3 订阅

订阅专栏

lambda表达式

理解lambda表达式之前，需要先理解行为参数化和函数式编程的概念。

1、行为参数化

观察如下的代码：
（1）根据用户输入的两个数，求两个数之间所有数据的和
在这里插入图片描述
（2）后来用户的需求，变成求两个数之间所有数据的乘积

（3）后来用户的需求，成求两个数之间所有能被3整除的数据的和

这几个方法之间相同的地方，例如：

方法的修饰符
方法的返回类型
方法的参数列表
方法中对数据的遍历

这几个方法之间不同的地方，例如：

方法的名字方法中
遍历数据后的核心操作

在实际项目中，用户需求的变动，是很正常的一件事情，所以在上述的案例中，我们不断的增加方法，来解决用户新的需求，但是在整个过程中，我们复制了大量的相同的代码。

方法的名字其实是无关紧要的，它只是在调用时用到的一个标示符，最关键的是对这个对数据的核心操作，也就是代码中核心的行为操作，每种情况由一个具体的 计算行为 来控制，这时候可以将这个核心的行为操作进行抽象，变成一个参数。在这里插入图片描述
将此处的计算行为定义成一个Action接口，接口中有一个action方法

定义不同计算行为的类并且实现Action接口，如下
在java中，不允许孤立的代码存在，要想将行为（核心操作代码）传递给calculate方法，就必须要将这些核心操作代码，包装在一个实现了Action的类中
在这里插入图片描述
Calculate方法就可以这样定义

将我们要执行的核心计算操作，定义成一个参数，传给calculate方法，我们可以通过这个参数，给方法传递不同的行为，来实现不同操作，这就是行为参数化，如下

为了减少声明和定义类，可以通过匿名内部类的形式来简化上述调用过程（省去了单独类实现接口的部分），如下

class Test{
	pbulic static void main(String[] args){
		int result = 0;
		result = calculate(3,5,new Action(){
			public int action(int result, int i){
				return result+next;
			}
		});
		System.out.println(result);

		result = calculate(3,4,new Action(){
			public int action(int result, int i){
				return result + next;
			}
		});
		System.out.println(result);
	}
}

2、函数式编程

在前面的一小节中，虽然使用了匿名内部类的方式简化了之前的代码，但是每次调用还是编写了很多相同的代码，如：new Action(){},public int action(int result, int next){}
其实我们真正关心的只有三点：方法中的参数列表，方法中的核心操作代码，方法的返回类型，其他的部分可以直接通过简化省略掉，也就是说传入指定参数，通过核心计算，给出最后结果，函数式编程就是将之前通过传递Action匿名对象的过程，变成一个计算求值的过程，那么这个求值的表达式就是所谓的函数式编程。
再次简化后如下：

class Test{
	public static void main(String[] args){
		int result = 0;
		/*
		result = calculate(3,5,new Action(){
			public int action(int result, int i){
				return result+next;
			}
		});
		*/
		//忽略掉匿名内部类形式中，不重要的部分
		/*
		Action add = (int result, int i) ->{
			return result + i;
		};
		
		//进一步简化
		Action add = (result, i) ->result + i;
		result = calculate(3,5,add);
		
		System.out.println(result);
	}
}

函数式编程概述

函数式编程是面向数学的抽象，将计算过程描述为一种表达式求值。简单说，函数式程序就是一个表达式。
严格意义上的表达式，就是由数据和操作符按照一定的规则，组合在一起形成的序列，并且所有的表达式都是有返回结果的，这是这里所说的表达式和代码语句的最大的区别。但在java中，是允许函数式编程中没有任何返回值的，因为java中有关键字void。
在这里插入图片描述
上面代码中的(result,next)->result+next; 就是java中函数式编程的一些体现，本质意义就是根据函数的入参，通过表达式的计算，最后返回一个结果，在JDK1.8中这一部分就叫Lambda表达式。

3、Lambda表达式概述

Lambda表达式是JDK1.8新增的一种语法，以确保在java代码中可以支持函数式编程，让代码的表示含义更简单。
Lambda表达式，可以用来表示一个函数，它只关注函数的参数列表，函数主体、返回类型，并且可以将此函数作为一个参数，进行传递。
在java中，Lambda表达式还有另一个存在的意义，那就是作为一个接口的实现类对象。
例如：

interface Action{
	public int test(String str);
)

class Test{
	public static void main(String[] args){
		Action a = (str)->str.length();
		System.out.println(a.test("hello"));
	)
)

Lambda表达式虽然可以通过（参数列表，函数主体、返回类型）三部分来表示一个具体的函数操作，但是它必须是依托在一个接口才行，所以Lambda表达式就是对接口中抽象方法的实现。

需要注意的是，并不是任意接口都可以使用Lambda表达式来进行简化实现的，例如当一个接口中带有多个未实现的方法时，Lambda表达式就不能在这种情况下使用了，一个Lambda表达式，只是描述了一个函数的参数列表、函数主体、返回类型，那么它顶多是对接口中的一个抽象方法的实现，无法实现接口中多个抽象方法，所以，接口中有且只有一个抽象方法的时候，才可以使用Lambda表达式来对其进行实现

4、函数式接口

有且只有一个抽象方法的接口，就是函数式接口。该接口中，也允许有其他的默认方法和静态方法。
当一个含有一个抽象方法的接口又继承了另一个含有一个抽象方法的接口时，这个接口就不是函数式接口了。

@FunctionalInterface注解

该注解是用来检查被标注的接口是不是一个函数式接口，如果不是，那么编译器报错。但该注解不是必须要用的，它只是会让编辑器帮我们检查一下而已，以免出现接口中抽象方法的个数不是1的情况.

5、Lambda语法

Lambda表达式的格式为：( ) -> { }

() 表示参数列表
-> 表示后面跟的函数主体
{} 函数主体，表达式的返回值有这个函数主体中的代码来决定

针对函数式接口中抽象方法有无参数，有无返回值的不同情况，lambda表达式也可再进一步的省略。

1、函数式接口中抽象方法无参，无返回值时

//这是一个函数式接口
interface Action{
	public void run();	
}

class Test{
	public static void main(String[] args){
		//（1）当函数主体中无任何代码句式时
		/*
		Action action1 = new Action(){
			public void run(){
				//空
			}
		};
		*/
		//上述代码课简化成如下Lambda表达式形式
		Action action1 = ()->{};


		//--------------------------------------------------------
		//（2）当函数主体中只有一句代码时,简化时甚至可以把大括号省去
		/*
		Action action2 = new Action(){
			public void run(){
				System.out.println("world peace!!!");
			}
		};
		*/
		//简化时后如下
		Action action2 = ()->System.out.println("world peace!!!");
		
		
		//----------------------------------------------------------
		//（3）当函数主体中有多句代码时，大括号就不能省
		/*
		Action action3 = new Action(){
			public void run(){
				int a = 1;
				int b = 2;
				System.out.println(a + b);
			}
		};
		*/
		//简化后如下
		Action action3 = ()->{
			int a = 1; 
			int b = 2;
			System.out.println(a + b);
		};
	}
}

2、函数式接口中，抽象方法有参，无返回值
（1）当接口中抽象方法是一个参数的情况

interface Action{
	public void run(int a);
}

class Test{
	public static void main(String[] args){
		//（1）当函数主体中无代码时
		/*
		Action action1 = new Action(){
			public void run(int a){
				
			}
		};
		*/
		Action action1 = (int a) -> {};
		//当参数只有一个时，参数列表部分甚至可以不加小括号，参数类型也可不写，因为即使不写参数类型，JVM运行时也会自动推断这个参数的类型
		Action action= a -> {};

		//-------------------------------------------------
		//（2）当函数主体中只有一句代码时
		/*
		Action action2 = new Action(){
			public void run(int a){
				System.out.println(a);
			}
		};
		*/
		Action action2 = a ->System.out.println(a);
	}
}

（2）当抽象方法中含有多个参数的情况下

interface Action{
	public void run(int a, int b);
}

class Test{
	public static void main(String[] args){
		/*
		Action action = new Action(){
			public void run(int a, int b){
				System.out.println(a+b);
			}
		};
		*/
		Action action = (a,b) -> System.out.println(a + b);
	}
}

3、函数式接口中抽象方法中无参，有返回值

interface Action{
	public int run(){

	}
}

class Test{
	public static void main(String[] args){
		/*
		Action action1 = new Action(){
			public void run(){
				return 1;
			}
		};
		*/
		//如果就一句代码，可以省略大括号，return关键字也可省去
		Action action1 = ()->1;

		//------------------------------------------------------------
		/*
		Action action1 = new Action(){
			public void run(){
				int num = 10; 
				return (int)(Math.random()*num);
			}
		};
		*/
		//如果函数主体中有多句代码，则都不可省去，如下
		Action action2 = () -> {
			int num = 10;
			return (int)(Math.random()*num);
		};
		
	}
}

4、函数式接口中抽象方法有参，有返回值

interface Action{
	public int run(int a, int b);
}

class Test{
	public static void main(String[] args){
		//（1）当函数主体中只有一串代码时
		/*
			Action action1 = new Action(){
				public int run(){
					return a + b;
				}
			};
		*/
		//上面代码简化后如下
		Action action1 = (a,b) -> a + b;
		
		//----------------------------------------------------
		//（2）当函数主题中有多串代码时
		/*
			Action action1 = new Action(){
				public int run(){
					int num = a + b;
					return num;
				}
			};
		*/
		//简化后如下
		Action action2 = (a, b) ->{
			int num = a + b;
			return num;
		};
		
	}
}