语法:
(参数列表)->{方法体}
():参数列表
{}:方法体
->lambda运算符
package com.ckq.lambda;
public class LambdaDemo {
public static void main(String[] args) {
A1 a1=()->{
System.out.println("无参数无返回值1:");
};
a1.test();
A2 a2=(a)->{
System.out.println("单个参数无返回值:"+a);
};
a2.test2(3);
A3 a3=(a,b)->{
System.out.println("多个参数无返回值:"+(a+b));
};
a3.test3(3,4);
A4 a4=()->{
return 5;
};
System.out.println("无参有返回值:"+a4.test4());
A5 a5=(a)->{
return a;
};
System.out.println("单参数有返回值:"+a5.test5("疾风已有归途"));
A6 a6=(a,b,c)->{
return (a+b)+c;
};
System.out.println("多参数有返回值:"+a6.test6(500,20,"大傻蛋"));
}
}
interface A1{
//无参数无返回值
void test();
}
interface A2{
void test2(int a);
}
interface A3{
void test3(int a,int b);
}
interface A4{
int test4();
}
interface A5{
String test5(String a);
}
interface A6{
String test6(int a,int b,String c);
}
结果:
无参数无返回值1:
单个参数无返回值:3
多个参数无返回值:7
无参有返回值:5
单参数有返回值:疾风已有归途
多参数有返回值:520大傻蛋
语法精简:
1、参数类型可以省略
2、加入只有一个参数,()可以省略
3、如果方法体只有一条语句,{}可以省略
4、如果方法体中唯一语句是return返回语句,那省略大括号的同时returen也要省略
public static void main(String[] args) {
A1 a1=()-> System.out.println("无参数无返回值1:");
a1.test();
A2 a2=a-> System.out.println("单个参数无返回值:"+a);
a2.test2(3);
A3 a3=(a,b)->
System.out.println("多个参数无返回值:"+(a+b));
a3.test3(3,4);
A4 a4=()-> 5;
System.out.println("无参有返回值:"+a4.test4());
A5 a5=a->a;
System.out.println("单参数有返回值:"+a5.test5("疾风已有归途"));
A6 a6=(a,b,c)->(a+b)+c;
System.out.println("多参数有返回值:"+a6.test6(500,20,"大傻蛋"));
}
方法引用:
如果多个Lambda表达式实现函数是一样的话,可以封装成通用方法,以便于维护,这时候可以用方法引用实现;
语法:
对象::方法
如果方法是static方法,可以直接 类名::方法
构造方法引用:
如果函数式接口的实现恰好可以通过调用一个类的构造方法来实现,那么就可以使用构造方法引用;
语法:
类名::new
public class LambdaDemo3 {
public static void main(String[] args) {
LambdaDemo3 l=new LambdaDemo3();
Test t1=l::testA;
Test t2=l::testA;
Test t3=LambdaDemo3::testB;
Test t4=LambdaDemo3::testB;
System.out.println(t1.ts("YOINGEN"));
System.out.println(t2.ts("yasuo"));
System.out.println(t3.ts("索子哥"));
System.out.println(t4.ts("枣子哥"));
}
public String testA(String a){
return "哥哥"+a;
}
public static String testB(String a){
return "静态哥哥"+a;
}
}
interface Test{
String ts(String a);
}
运行结果:
哥哥YOINGEN
哥哥yasuo
静态哥哥索子哥
静态哥哥枣子哥
函数式接口:
1、接口有且仅有一个抽象方法
2、可以有普通方法、静态方法
3、Lambda表达式只能适用于函数式接口
4、@Functionallnterface注解 限定接口为函数式接口,如果不是加上这个接口编译不通过
5、允许有java.lang.Object中的public方法,例如equals方法
java内置函数式接口:
java.util.function下的一系列函数式接口包括Consumer、Supplier、Function、Predicat等常用接口
补充:
1、lambda表达式实现构造方法
public class Dog {
private int age;
private String name;
public Dog(int age, String name) {
System.out.println("有参构造");
this.age = age;
this.name = name;
}
public Dog() {
System.out.println("无参构造");
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Dog{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
}
public class LambdaDemo4 {
public static void main(String[] args) {
DogService d1=Dog::new;
System.out.println(d1.getDog());
DogService2 d2=Dog::new;
System.out.println(d2.getDog(2,"老哈"));
}
}
interface DogService{
Dog getDog();
}
interface DogService2{
Dog getDog(int age,String name);
}
运行结果:
无参构造
Dog{age=0, name='null'}
有参构造
Dog{age=2, name='老哈'}
2、lambda表达式实现集合遍历与排序
public class LambdaDemo5 {
public static void main(String[] args) {
List<Dog> list=new ArrayList<>();
list.add(new Dog(2,"小红"));
list.add(new Dog(1,"小花"));
list.add(new Dog(4,"小黑"));
list.add(new Dog(5,"小黄"));
list.add(new Dog(3,"小白"));
System.out.println("Lambda表达式集合排序——————————————————");
list.sort((o1,o2)->o1.getAge()-o2.getAge());
System.out.println(list);
list.forEach(System.out::println);
}
}
运行结果:
有参构造
有参构造
有参构造
有参构造
有参构造
Lambda表达式集合排序——————————————————
[Dog{age=1, name='小花'}, Dog{age=2, name='小红'}, Dog{age=3, name='小白'}, Dog{age=4, name='小黑'}, Dog{age=5, name='小黄'}]
Dog{age=1, name='小花'}
Dog{age=2, name='小红'}
Dog{age=3, name='小白'}
Dog{age=4, name='小黑'}
Dog{age=5, name='小黄'}