什么是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的表达式,就可以实现方法;
2.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);
}
}