什么是函数式接口
如果一个接口只有一个抽象方法（Object类中的方法除外），那么该接口就是函数式接口。@FunctionalInterface此注解是函数式接口
在jdk8中rt.jar下java.util.function包中几乎都是函数式接口
如：
- Supplier代表输出
- Consumer代表输入
- BiConsumer代表两个输入
- Function<T,R>代表一个输入，一个输出
- BiFunction<T,U,R>代表两个输入，一个输出
- UnaryOperator<T>代表输入和输出相同类型
lambda表达式语法
- args ->expr
- （Object...args）->{函数式接口抽象方式实现逻辑}
- （）里参数的个数，根据函数式接口里面抽象方法的参数个数来决定的
- 当且仅当只有一个参数的时候，()可以省略
- 当expr逻辑非常简单的时候，()和return可以省略
- ()->{}; //无参，无返回值
- ()->{System.out.println(1);} ; //无参，无返回值
- ()->System.out.println(1); //无参，无返回值(简写)
- ()-> {return 100;} ; //无参，有返回值，
- ()-> 100; //无参，有返回值，(简写)
- ()-> null; //无参，有返回值（返回null）
- (int x)->{ return x+1;}; //单个参数，有返回值
- (int x)-> x+1; //单个参数，有返回值(简写)
- (x) ->x+1; //单个参数，有返回值(不指定参数类型，多个参数必须用括号),lambda的特点就是参数类型自动推断，所以可以省略类型
- x ->x+1; //单个参数，有返回值(简写)
lambda的注意事项
- (x,int y)-> x+y; //参数不能部分省略，要么(int x,int y)-> x+y ,要么(x, y)-> x+y
- (x,final y)-> x+y; //参数不能使用final修饰
- Object obj=()-> "hello"; //不能把lambda表达式赋值给非函数式接口，只能把lambda表达式强转成函数式接口Object obj=(Supplier<?>)()-> "hello";
- 不需要也不允许使用throws语句来声明它可能会抛出的异常
一些例子
package lambda1;
import java.util.concurrent.Callable;
import java.util.function.Function;
public class Test1 {
public static void main(String[] args) throws Exception {
// 无参无返回值
Runnable r1 = new Runnable() {
@Override
public void run() {
System.out.println("普通方式");
}
};
r1.run();
Runnable r2 = () -> System.out.println("lambda表达式");
r2.run();
// 无参有返回值
Callable<String> c1 = new Callable<String>() {
@Override
public String call() throws Exception {
// TODO Auto-generated method stub
return "hello world";
}
};
Callable<String> c2 = () -> {
return "hello lambda";
};
Callable<String> c3 = () -> "hello lambda";
System.out.println(c1.call());
System.out.println(c2.call());
System.out.println(c3.call());
// 有参无返回值
UserMapper u1 = new UserMapper() {
@Override
public void insert(User user) {
// TODO Auto-generated method stub
System.out.println("普通方式插入" + user);
}
};
u1.insert(new User());
UserMapper u2 = (User user) -> {
System.out.println("lambda表达式插入" + user);
};
u2.insert(new User());
// 有参有返回值
OrderMapper o1 = new OrderMapper() {
@Override
public int del(Order order) {
// TODO Auto-generated method stub
return 1;
}
};
OrderMapper o2 = (Order order) -> {
return 0;
};
OrderMapper o3 = order -> 0;
System.out.println(o1.del(new Order()));
System.out.println(o2.del(new Order()));
System.out.println(o3.del(new Order()));
Function<Integer, Integer> fun1 = a -> {
int sum = 0;
for (int i = 0; i < a; i++) {
sum++;
}
return sum;
};
System.out.println(fun1.apply(9));
Runnable ru1 = () -> get();// 无返回值当执行方法的只管get()方法的执行，不管有没有返回值
Runnable ru2 = () -> exec();
Foo f1 = () -> get();
// Foo f2=()->exec();对于该抽象方法有返回值，但是exec()没有返回值
Foo f3 = () -> 100;
Foo f4 = () -> true ? 1 : -1;// 有返回值，没问题
// 如何直接调用接口中的非抽象方法
System.out.println(f1.get());
System.out.println(Foo.find());
}
static void exec() {
}
static int get() {
return 1;
}
}
//函数是接口中的抽象方法不能是Object类中的方法
@FunctionalInterface
interface UserMapper{
void insert(User user);
default void get() {
System.out.println("这不是抽象方法");
}
static void find() {
System.out.println("这也不是抽象方法");
}
}
interface OrderMapper{
int del(Order order);
}
interface Foo{
int make();
default int get() {
return 1000;
}
static int find() {
return 200;
}
}
class User{
}
class Order{
}
