lambda 表达式、函数接口及四大内置函数接口 详解
优点
-
简化代码
-
更加容易并行计算
语法
lambda表达式的标准语法（）-> { }
-> 左侧 () 内为 参数
-> 右侧 { } lambda 方法体
函数接口
定义：
接口中 只有一个 必须 实现的方法，这种接口就是 函数接口
注解标识：
java8 以后可以使用 @FunctionalInterface 进行标识
源码{各种入参方式}
-
入参：无
返回值：无
/** * 入参：无 * 返回值：无 * * 函数接口 */ @FunctionalInterface interface NullParamVoid { void test(); } /** * 入参：无 * 返回值：无 * 测试 */ @Test public void test1(){ // 匿名内部类的方式 NullParamVoid nullParamVoid = new NullParamVoid() { @Override public void test() { System.out.println("测试方式: 匿名内部类\n"); } }; // lamda 表达式 标准语法 NullParamVoid nullParamVoid1 = () -> { System.out.println("测试方式: lanbda表达式\n"); }; // lamda 表达式 简化 NullParamVoid nullParamVoid2 = () -> System.out.println("测试方式: lanbda表达式 \n如果lambda 体的代码只有一行，大括号 可以省略"); System.out.println("无入参，无返回值的 函数接口测试 \n "); nullParamVoid.test(); nullParamVoid1.test(); nullParamVoid2.test(); } -
入参：无
返回值：有
/** * 入参：无 * 返回值：有 * * 函数接口 */ @FunctionalInterface interface NullParamReturn { String test(); } /** * 入参：无 * 返回值：有 * 测试 */ @Test public void test2(){ // 匿名内部类的方式 NullParamReturn interfaceInstance = new NullParamReturn() { @Override public String test() { return "匿名内部类"; } }; // lamda 表达式 标准语法 NullParamReturn interfaceInstance1 = () -> { return "lamda 表达式 标准语法"; }; // lamda 表达式 简化 NullParamReturn interfaceInstance2 = () -> "测试方式: lanbda表达式 \n如果lambda 体的代码只有一行，大括号 可以省略"; System.out.println("无入参，有返回值的 函数接口测试 \n "); System.out.println(interfaceInstance.test()); System.out.println(interfaceInstance1.test()); System.out.println(interfaceInstance2.test()); } -
入参：有 一个
返回值：无
**note:**与4 类似 见 4具体实现
-
入参：有 一个
返回值：有
/** * 入参：一个 * 返回值：有 * * 函数接口 */ @FunctionalInterface interface OneParamReturn<T> { T test(T x); } /** * 入参：一个 * 返回值：有 * 测试 */ @Test public void test3(){ // 匿名内部类的方式 OneParamReturn<Integer> interfaceInstance = new OneParamReturn<Integer>() { @Override public Integer test(Integer x) { return ++x; } }; // lamda 表达式 标准语法 OneParamReturn<Integer> interfaceInstance1 = (Integer x) -> { return ++x; }; // lamda 表达式 简化1 // lambda 体 只有一行代码 可以省略 {} OneParamReturn<Integer> interfaceInstance2 = (Integer x) -> ++x; // lamda 表达式 简化 // 可以不写入参 类型 OneParamReturn<Integer> interfaceInstance3 = (x) -> ++x; // lamda 表达式 简化 // 如果入参只有一个 参数 可以 省略 （） OneParamReturn<Integer> interfaceInstance4 = x -> ++x; System.out.println("一个入参，有返回值的 函数接口测试 \n "); System.out.println(interfaceInstance.test(1)); System.out.println(interfaceInstance1.test(1)); System.out.println(interfaceInstance2.test(1)); System.out.println(interfaceInstance3.test(1)); System.out.println(interfaceInstance4.test(1)); }note:
-
入参：有 多个
返回值：无
**note:**与6 类似 见6 具体实现
-
入参：有 多个
返回值：有
/** * 入参：多个 * 返回值：有 * * 函数接口 */ @FunctionalInterface interface MoreParamReturn<T,R> { R test(T x,T y); } /** * 入参：多个 * 返回值：有 * 测试 */ @Test public void test4(){ // 匿名内部类的方式 MoreParamReturn<Integer,Integer> interfaceInstance = new MoreParamReturn<Integer, Integer>() { @Override public Integer test(Integer x, Integer y) { return x + y; } }; // lamda 表达式 标准语法 MoreParamReturn<Integer,Integer> interfaceInstance1 = (Integer x, Integer y) -> { return x + y; }; // lamda 表达式 简化1 // lambda 体 只有一行代码 可以省略 {} MoreParamReturn<Integer,Integer> interfaceInstance2 = (Integer x, Integer y) -> x + y; // lamda 表达式 简化 // 可以不写入参 类型 // 敲黑板： 多个参数 要么类型 全部省略 要么 全部不省略 不允许 省略部分 MoreParamReturn<Integer,Integer> interfaceInstance3 = (x, y) -> x + y; System.out.println("多个入参，有返回值的 函数接口测试 \n "); System.out.println(interfaceInstance.test(1, 2)); System.out.println(interfaceInstance1.test(1, 2)); System.out.println(interfaceInstance2.test(1, 2)); System.out.println(interfaceInstance3.test(1, 2)); }note:
四大核心函数接口及子接口
对比
| 函数接口 | 入参类型 | 返回类型 |
|---|---|---|
| Function<T,R> | T | R |
| Consumer | T | void |
| Supplier | N/A | T |
| Predicate | T | boolean |
Function<T,R>
package java.util.function;
import java.util.Objects;
@FunctionalInterface
public interface Function<T, R> {
R apply(T var1);
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (v) -> {
return this.apply(before.apply(v));
};
}
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (t) -> {
return after.apply(this.apply(t));
};
}
static <T> Function<T, T> identity() {
return (t) -> {
return t;
};
}
}
Consumer
package java.util.function;
import java.util.Objects;
@FunctionalInterface
public interface Consumer<T> {
void accept(T var1);
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (t) -> {
this.accept(t);
after.accept(t);
};
}
}
Supplier
package java.util.function;
@FunctionalInterface
public interface Supplier<T> {
T get();
}
Predicate
package java.util.function;
import java.util.Objects;
@FunctionalInterface
public interface Predicate<T> {
boolean test(T var1);
default Predicate<T> and(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> {
return this.test(t) && other.test(t);
};
}
default Predicate<T> negate() {
return (t) -> {
return !this.test(t);
};
}
default Predicate<T> or(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> {
return this.test(t) || other.test(t);
};
}
static <T> Predicate<T> isEqual(Object targetRef) {
return null == targetRef ? Objects::isNull : (object) -> {
return targetRef.equals(object);
};
}
static <T> Predicate<T> not(Predicate<? super T> target) {
Objects.requireNonNull(target);
return target.negate();
}
}
