lambda表达式简介
1：什么是lambda表达式
是JAVA8 的一种新特性，其实本质就是一个匿名函数
2：为什么要使用lambda表达式
首先先来看一下对接口的引用的三种方式，第一种通过实现类
//第一种方式
class MyTests implements myTest{
@Override
public int test(int a, int b) {
return a-b;
}
}
interface myTest{
int test(int a,int b);
}
第二种：匿名内部类
myTest myTest = new myTest() {
@Override
public int test(int a, int b) {
return a-b;
}
};
第三种也就是lambda
myTest myTest1 = (a,b) -> a -b;
那种方式最简单就不用我多说了吧，lambda能对接口中的抽象方法简单的实现
3:lambda对接口的要求
lambda只能对接口中有一个必须抽象方法实现
这里值得注意的是在java8之后提出了default
@FunctionalInterface:函数式接口，约定了这个接口只能有一个必须实现的抽象方法
lambda接口的基础语法
准备工作
6个接口
基础语法
基础语法：由于lambda表达式是一个匿名函数，我们只需要注意 参数列表以及方法体 /*
- ():用来描述参数列表
- {}:用来表述方法体
- ->:来分开前两个，读作goes to lambda 运算符 _ _/
package com.interfaces;
public class Test {
public static void main(String[] args) {
// 基础语法：由于lambda表达式是一个匿名函数，我们只需要注意 参数列表以及方法体
/*
* ():用来描述参数列表
* {}:用来表述方法体
* ->:来分开前两个，读作goes to lambda 运算符
* */
// 无参无返回
demo1 demo1 = () ->{
System.out.println("hello,lambda");
};
demo1.test();
// 一参无返回
demo2 demos2 = (int a) -> {
System.out.println(a*10);
};
demos2.test(2);
// 多参无返回
demo3 demo3 = (int a, int b) -> {
System.out.println(a+b);
};
demo3.test(10,20);
// 又返回无参
demo4 demo4 = () -> {
System.out.println("demo4");
return 0;
};
System.out.println(demo4.test());
// 返回一个参
demo5 demo5 = (int a) -> {
return a*10;
};
System.out.println(demo5.test(10));
}
}
lambda表达式的语法精简
1：参数类型可省略，但是必须以接口中的一致
2：参数中只有一个，小括号也可以省略
3：方法体中只有一条语句，且没有return 方法体也可以省略。
4：若有return，return也省略
// 1,2,3条结合起来精简
demo2 demo2 = a -> System.out.println("hello,word");
// 第四条与前三个结合精简
demo4 demo4 = () -> 0;
方法的引用：
lambda实现的函数若都是一样的话，那么每次用起来还需要去简写表达式。为了方便我们直接封装成一个方法，直接用方法引用调用方法： 语法: 对象:: 方法名 如果是静态方法：直接用类名称：：方法名不用new对象
``
package arrayList.src.JavaSE.lambda;
import java.util.Comparator;
public class lambdaTest3s {
public static void main(String[] args) {
lambdaTest3s test3 = new lambdaTest3s();
lambdaTest4s lambdaTest4s = test3::methodyinyong;
System.out.println("方法的引用："+lambdaTest4s.methodyinyong(1, 3));
lambdaTest4s lambdaTest4ss = lambdaTest3s::methodyinyongs;
System.out.println("静态方法的引用："+lambdaTest4s.methodyinyong(1, 3));
}
public int methodyinyong(int a, int b){
return a+b;
}
public static int methodyinyongs(int a, int b){
return a+b;
}
public interface lambdaTest4s{
int methodyinyong(int a, int b);
}
}
构造方法的引用：
语法： 类名:: new 定义一个Person的实体类
package arrayList.src.JavaSE.lambda;
public class Person {
public Person(String name, int sex) {
System.out.println("有参构造");
this.name = name;
this.sex = sex;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + ''' +
", sex=" + sex +
'}';
}
public Person() {
System.out.println("空参构造");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getSex() {
return sex;
}
public void setSex(int sex) {
this.sex = sex;
}
private String name;
private int sex;
}
定义一个Test类，有两个接口声明方法
public class Test2 {
public static void main(String[] args) {
// 以前的写法
// PersonTest1 personTest1 = () -> new Person();
// personTest1.getPerson();
/*构造的写法*/
PersonTest2 personTest1 = Person::new;
System.out.println(personTest1.getPerson("小花", 23).toString());
}
}
interface PersonTest1{
Person getPerson();
}
interface PersonTest2{
Person getPerson(String name,int sex);
}
@FunctionalInterface 注解
特点：声明为函数式接口：里只能有一个抽象方法。 可以有静态方法 可以有默认方法 此接口不是必须的
实例
package arrayList.src.JavaSE.lambda;
@FunctionalInterface //函数式接口
public interface TestInteface {
public void ad(); //抽象方法
public default void add(){ //默认方法
};
public static void adds(){}; //静态方法
}
package arrayList.src.JavaSE.lambda;
@FunctionalInterface //函数式接口
public interface TestInteface {
public void add(); //抽象方法
public void adds(); //抽象方法
}
系统内置的函数式接口
在java.util.function都可以直接使用
