什么是lambda？java8的lambda表达式

什么是lambda？

就是一个匿名函数；

为什么要使用lambda？

就是为了对某一些方法进行实现，lambda实现的接口只能有一个方法；

1.简单案例：

1.定义接口

import com.yimocha;

@FunctionalInterface //* 函数式接口注解
interface Comparator{
	int compare(int a,int b);
}

2.接口的实现类

import com.yimocha;

//* 接口实现
public class MyComparator implements Comparator {

	@Override
	public int compare(int a, int b) {
		// TODO Auto-generated method stub
		return a-b;
	}
	
}

3.运行案例

import com.yimocha.*;

public class test {
	
	public static void main(String[] args) {
		
		//* 1.使用接口实现类的
		Comparator comparator = new MyComparator();
		
		//* 2.使用匿名内部类
		Comparator comparator1 = new Comparator() {
			
			@Override
			public int compare(int a, int b) {
				// TODO Auto-generated method stub
				return a-b;
			}
		};
		
		//* 3.lambda表达式
		Comparator comparator2 = (a,b)->a-b;
	}
}

2.分析：

//* 1.使用接口实现类的

我们需要写一个接口的实现类，去实现接口中的方法

//* 2.使用匿名内部类

使用匿名内部类，相对的比使用接口的实现类，实现方法简单许多；
不用在去写一个，接口的实现类；

//* 3.lambda表达式

使用lambda就更简洁了从代码上来看，相对前两种方式简单了许多；
不需要写接口的实现类，也不用像匿名内部类写辅助代码；
简单的 通过lambda的表达式，就可以实现方法；

扫描二维码关注公众号，回复： 9076668 查看本文章

2.Lambda的基础语法：

Lambda的基础语法查看

lambda表达式： 参数列表 -> 方法体
() : 用来描述传参数列表
{} : 用来描述方法体
-> : Lambda运算符，读作goes to

2.自定义案例：

2.1： 需求：编写4个接口，分别是{无参数，无返回值}，{无参数，有返回值}，{有参数，无返回值}，{有参数，有返回值}

• 无参数，无返回值 - interface

package com.mylambda;

/**
 * 无参数，无返回
 * @author 一抹茶
 *
 */

@FunctionalInterface //* 函数式接口注解，只能有一个方法
public interface NoneReturnNoneParameter {
	void test();
}

• 无参数，有返回值

package com.mylambda;

/**
 * 无参数，有返回值
 * @author 一抹茶
 *
 */

@FunctionalInterface
public interface SingleReturnNoneParameter {
	int test();
}

• 有参数，无返回值

package com.mylambda;

/**
 * 有参数，无返回值
 * @author 一抹茶
 *
 */

@FunctionalInterface
public interface NoneReturnSingleParamter {
	void test(int n);
}

• 有参数，有返回值

package com.mylambda;

/**
 * 多参数，有返回值
 * @author 一抹茶
 *
 */

@FunctionalInterface
public interface SingleReturnMutipleParameter {
	int test(int a, int b);
}

2.2：实现方法

package com.syntax;

import com.mylambda.*;

public class Syntax1 {
	
	public static void main(String[] args) {
		
		//* 无参数，无返回
		NoneReturnNoneParameter noneReturnNoneParameter = () -> {
			System.out.println("hello world");
		};
		noneReturnNoneParameter.test();

		//* 无参数，有返回值
		SingleReturnNoneParameter singleReturnNoneParameter = () -> {
		System.out.println("无参数，有返回值"); // * 相当于一个实现类
		return 100;
		}
		int ret = singleReturnNoneParameter.test();
		System.out.println(ret);
		
		//* 有参数，无返回值
		NoneReturnMutipleParameter noneReturnMutipleParameter = (a, b) -> {
			System.out.println(a + b);
		};
		noneReturnMutipleParameter.test(2, 3);

		//* 有参数，有返回值
		SingleReturnMutipleParameter singleReturnMutipleParameter = (a, b) -> {
			return a + b;
		};
		int ret3 = singleReturnMutipleParameter.test(4,4);
		System.out.println(ret3);

	}
}