- 概述
Lambda是JDK8的语法糖。它可以对某些匿名内部类的写法进行简化,它是函数式编程的一个重要体现。让我们不用关注什么是对象,重点关注我们对数据做了什么操作,可以说它Lambda表达式就是一个对象
- Lambda表达式在C++、C#、Python、Scala等一些语言中也支持,Java支持的还算比较晚的(确实好用)
- Lambda关注的是方法的参数(),还有具体做了什么{}方法体,中间用-> ,凡是确定的东西都可删除(比如一个内部类,直接确定是它)
基本语法
(参数列表)->{代码}
拓展__匿名内部类
- Runnable是一个接口
- Runnable只有一个抽象方法
LambdaTest代码演示
public class LambdaTest {
@Test
public void test1(){
// Runnable只有一个抽象方法
Runnable r1 = new Runnable() {
@Override
public void run() {
System.out.println("我爱即兴小索奇");
}
};
r1.run();
System.out.println("***********************");
//Lambda表达式
Runnable r2 = () -> {
System.out.println("我是即兴小索奇");
};
r2.run();
}
@Test
public void test2(){
Comparator<Integer> com1 = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return Integer.compare(o1,o2);
}
};
int compare1 = com1.compare(12,21);
System.out.println(compare1);
System.out.println("***********************");
//Lambda表达式的写法,箭头后的{}是可以省略的,参数类型确定也可以省略
Comparator<Integer> com2 = (Integer o1, Integer o2) -> Integer.compare(o1,o2);
// Comparator<Integer> com2 = (o1, o2) -> Integer.compare(o1,o2);
int compare2 = com2.compare(23,21);
System.out.println(compare2);
System.out.println("***********************");
//方法引用
Comparator<Integer> com3 = Integer :: compare;
int compare3 = com3.compare(23,21);
System.out.println(compare3);
}
}
LambdaTest01细节演示
public class LambdaTest1 {
//语法格式一:无参,无返回值
@Test
public void test1(){
Runnable r1 = new Runnable() {
@Override
public void run() {
System.out.println("我是即兴小索奇");
}
};
r1.run();
System.out.println("***********************");
Runnable r2 = () -> {
System.out.println("即兴小索奇运行了");
};
r2.run();
}
//语法格式二:Lambda 需要一个参数,但是没有返回值。
@Test
public void test2(){
Consumer<String> con = new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
};
con.accept("小索奇在摸鱼!");
System.out.println("*******************");
Consumer<String> con1 = (String s) -> {
System.out.println(s);
};
con1.accept("小索奇正在打怪中...");
}
//语法格式三:数据类型可以省略,因为可由编译器推断得出,称为“类型推断”
@Test
public void test3(){
Consumer<String> con1 = (String s) -> {
System.out.println(s);
};
con1.accept("小索奇正在探索中...");
System.out.println("*******************");
Consumer<String> con2 = (s) -> {
System.out.println(s);
};
con1.accept("小索奇正在探索中...");
}
@Test
public void test3_1(){
int[] arr = {1,2,3,4}; //类型推断
HashMap<String,Integer> map = new HashMap<>();//类型推断
var entrySet = map.entrySet(); //类型推断 ,在jdk10及之后可以用,现持续存在
}
//语法格式四:Lambda 若只需要一个参数时,参数的小括号可以省略
@Test
public void test4(){
Consumer<String> con1 = (s) -> {
System.out.println(s);
};
con1.accept("小索奇正在探索中...");
System.out.println("*******************");
Consumer<String> con2 = s -> {
System.out.println(s);
};
con2.accept("小索奇正在睡觉...");
}
//语法格式五:Lambda 需要两个或以上的参数,多条执行语句,并且可以有返回值
@Test
public void test5(){
Comparator<Integer> com1 = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
System.out.println(o1);
System.out.println(o2);
return o1.compareTo(o2);
}
};
System.out.println(com1.compare(12,21));
System.out.println("*****************************");
Comparator<Integer> com2 = (o1, o2) -> {
System.out.println(o1);
System.out.println(o2);
return o1.compareTo(o2);
};
System.out.println(com2.compare(12,21));
}
//语法格式六:当 Lambda 体只有一条语句时,return 与大括号若有,都可以省略
@Test
public void test6(){
Comparator<Integer> com1 = (o1,o2) -> {
return o1.compareTo(o2);
};
System.out.println(com1.compare(12,6));
System.out.println("*****************************");
Comparator<Integer> com2 = (o1,o2) -> o1.compareTo(o2);
System.out.println(com2.compare(12,16));
}
@Test
public void test7(){
Consumer<String> con1 = s -> {
System.out.println(s);
};
con1.accept("小索奇正在睡大街...");
System.out.println("*****************************");
}
}
自定义函数式接口
@FunctionalInterface
public interface MyFunctionalInterface {
void method();
// void method1();
}
public class MyFunctionalInterfaceTest {
@Test
public void test1(){
MyFunctionalInterface m = () -> System.out.println("hello");
m.method();
}
}
总结
直达 java.util.function
文档:https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/function/package-summary.html
- Lambda表达式的使用举例:
(o1, o2) -> Integer.compare(o1,o2);
- Lambda表达式的格式举例:
lambda形参列表 -> lambda体
- Lambda表达式的格式
- lambda操作符或箭头操作符
- -> 的左边: lambda形参列表,对应着要重写的接口中的抽象方法的形参列表。
- -> 的右边: lambda体,对应着接口的实现类要重写的方法的方法体。
- Lambda表达式的本质:
- 一方面,lambda表达式作为接口的实现类的对象。 --->说白了Lambda表达式就是对象, "万事万物皆对象"
另一方面,lambda表达式是一个匿名函数。
- 函数式接口
什么是函数式接口?为什么需要函数式接口?
- 如果接口中只声明有一个抽象方法,则此接口就称为函数式接口(如Runnable就是函数式接口 ,底层加上了
@FunctionalInterface
注解,可以校验它是一个函数式接口,加了最多就只能写一个抽象方法了) - 因为只有给函数式接口提供实现类的对象时,我们才可以使用lambda表达式。
api中函数式接口所在的包
- jdk8中声明的函数式接口都在java.util.function包下。
4个基本的函数式接口
接口 对应的抽象方法
- 消费型接口:Consumer void accept(T t)
消费型接口表示接收一个参数并执行某些操作,但没有返回值。它常用于需要执行一些操作但不需要返回结果的场景,例如遍历集合、修改对象状态等,例如
Consumer<String> consumer = s -> System.out.println(s);
consumer.accept("hello world");
- 供给型接口:Supplier T get()
供给型接口表示不需要接收任何参数,但需要返回一个结果。它常用于需要生成某些数据的场景,例如生成随机数、获取当前时间等,例如
Supplier<Integer> supplier = () -> (int) (Math.random() * 100);
System.out.println(supplier.get());
- 函数型接口:Function<T,R> R apply(T t)
函数型接口表示接收一个参数并返回一个结果。它常用于需要对某些数据进行处理并返回结果的场景,例如字符串转换、数据加工等。例如:
Function<String, Integer> function = s -> s.length();
System.out.println(function.apply("hello world"));
- 判断型接口:Predicate boolean test(T t)
判断型接口表示接收一个参数并返回一个布尔值。它常用于需要对某些数据进行判断并返回布尔值的场景,例如过滤集合、判断对象状态等,例如
Predicate<Integer> predicate = i -> i > 0;
System.out.println(predicate.test(-1));
- Lambda表达式的语法规则总结