Java 8中的Lambda和方法引用

在Java 8中添加了Lambda新特性。如果接口中只有一个方法,则可以使用Lambda来完成。

例如Runnable接口,只有一个run方法。在Java 8以下中我们需要这么写:

1
2
3
4
5
6
new Thread(new Runnable(){
@Override
public void run(){
// ...
}
}).start();

在Java 8及以上版本:

1
new Thread(() -> ...).start();

Lambda表达式语法格式如下:

1
2
3
(partameters) -> expression
// 或者
(partameters) -> { stamements; }

例如:

1
2
3
4
5
6
7
(int a,int b) -> a + b

(a,b) -> a + b

(a,b) -> { return a + b;}

a -> a + 1

Lambda表达式的重要特征是:
类型声明可选:不需要声明参数的类型,编译器可以自动识别
参数圆括号可选:如果只有一个参数,可以省略定义参数的圆括号
大括号可选:如果表达式只有一条语句,可以省略主体的花括号
return关键字可选:如果主体只有一条语句有表达式,编译器会返回该值。花括号内需要手动return指定返回值

下面是一个简单的Lambda实例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import static java.lang.System.out;

interface BinOper<T> {
T apply(T a, T b);
}

public class Main {
public static void main(String[] args) {
out.println(run(2, 3, (a, b) -> a + b));
}

private static int run(int a, int b, BinOper<Integer> oper) {
return oper.apply(a, b);
}
}

方法引用
在Java 8以上版本中,增加了方法引用。方法引用和Lambda很相似,可以使语言更加的紧凑和简介。减少冗余代码。Java中的方法引用使用两个冒号 :: 完成
下面我们来看一个最简单的用法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import static System.out;

@FunctionalInterface
interface MyConsumer<T> {
void accpet(T obj);
}

public class Main {
public static void main(String[] args) {
echo("Hello Java 8", Main::print);
}

private static void print(Object o) {
out.println(o.toString());
}

private static void echo(Object obj,MyConsumer<? super Object> consumer){
consumer.accpet(obj);
}
}

上面代码中一共经历了以下几个步骤:
在把Main::print传入echo方法时,实际上相当于是实现了MyConsumer接口,类似于Lambda的(obj) -> Main.print(obj)
echo方法内调用accept并传入obj,相当于调用了print方法
print方法输出变量obj
Java 8中包含的预定义函数式接口

接口 用法
Function<T,R> 接受一个参数,并且返回一个结果
IntFunction<R> 接受一个int型参数,并且返回一个结果
LongFunction<R> 接受一个long型参数,并且返回一个结果
DoubleFunction<R> 接受一个double型参数,并且返回一个结果
IntToLongFunction 接受一个int型的参数,并且返回一个long型的结果
IntToDoubleFunction 接受一个int型的参数,并且返回一个double型的结果
LongToIntFunction 接受一个long型的参数,并且返回一个int型的结果
LongToDoubleFunction 接受一个long型的参数,并且返回一个double型的结果
DoubleToIntFunction 接受一个double型的参数,并且返回一个int型的结果
DoubleToLongFunction 接受一个double型的参数,并且返回一个long型的结果
BiFunction<T,U,R> 接受两个参数,并且返回一个结果
ToIntFunction<T> 接受一个参数,并且返回一个int类型的结果
ToLongFunction<T> 接受一个参数,并且返回一个long类型的结果
ToDoubleFunction<T> 接受一个参数,并且返回一个double类型的结果
ToIntBiFunction<T,U> 接受两个参数,并且返回一个int类型的结果
ToLongBiFunction<T,U> 接受两个参数,并且返回一个long类型的结果
ToDoubleBiFunction<T,U> 接受两个参数,并且返回一个double类型的结果
Consumer<T> 接受一个参数,无返回值
BiConsumer<T,U> 接受两个参数,无返回值
IntConsumer 接受一个int型参数,无返回值
LongConsumer 接受一个long型参数,无返回值
DoubleConsumer 接受一个double型参数,无返回值
ObjIntConsumer<T> 接受一个Object类型和一个int型参数,无返回值
ObjLongConsumer<T> 接受一个Object类型和一个long型参数,无返回值
ObjDoubleConsumer<T> 接受一个Object类型和一个double型参数,无返回值
UnaryOperator<T> 接受一个T类型的参数,并且返回一个T类型的结果
IntUnaryOperator 接受一个int类型参数,并且返回一个int类型结果
LongUnaryOperator 接受一个long类型参数,并且返回一个long类型结果
DoubleUnaryOperator 接受一个double类型参数,并且返回一个double类型结果
BinaryOperator<T> 接受两个T类型的参数,并且返回一个T类型结果
IntBinaryOperator 接受两个int参数,并且返回int类型结果
LongBinaryOperator 接受两个long参数,并且返回long类型结果
DoubleBinaryOperator 接受两个double参数,并且返回double类型结果
Supplier<T> 不接受参数,并返回一个T类型结果
BooleanSupplier 不接受参数,返回一个boolean结果
IntSupplier 不接受参数,并且返回一个int类型结果
LongSupplier 不接受参数,并且返回一个long类型结果
DoubleSupplier 不接受参数,并且返回一个double类型结果
Predicate<T> 接受一个T类型参数,并且返回boolean类型结果
IntPredicate 接受一个int参数,并且返回boolean类型结果
LongPredicate 接受一个long参数,并且返回boolean类型结果
DoublePredicate 接受一个double参数,并且返回boolean类型结果
BiPredicate<T,U> 接受两个参数,并且返回一个boolean类型结果