引子
要求创建一个线程，线程中输出hello world
没学Lambda前的画风：
1
2
3
4
5
6
7
8
|
class myThread implements Runnable{
@Override
public void run() {
System.out.println("hello world!");
}
}
new Thread(new myThread()).start();
|
1
2
3
4
5
6
7
|
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("hello world!");
}
}).start();
|
当你学会Lambda表达式之后，画风是这样的：
1
| new Thread(() -> System.out.println("hello world!")).start();
|
是不是有种打开新世界大门的感觉，一起来看下Java8的新特性之一Lambda表达式吧
函数式接口：接口中只有一个抽象方法的接口
这种接口都可以用lambda表达式来实现
JDK内置四大基础函数式接口
- Consumer#accept(Object)
- void accept(T t); 消费型接口，接受一个参数，无返回
- Supplier#get()
- Function#apply(Object)
- R apply(T t); 函数型接口，接收参数T,返回一个R
- Predicate#test(Object)
- boolean test(T t); 断定型接口，接收参数T，判断其是否满足某一约束，返回一个boolean值
从源码中可以看到这四个基础接口都有注解@FunctionalInterface，他们都有一个特点：
有且仅有一个抽象方法
下面通过以前的写法、Java8的lambda写法进行对比学习
Consumer
消费型接口，接收一个参数，但无返回值
其接口核心源码如下：
1
2
3
4
5
6
7
8
9
|
@FunctionalInterface
public interface Consumer<T> {
void accept(T t);
}
|
写一个小示例：
1
2
3
4
5
6
7
8
9
10
11
12
|
Consumer<String> consumer1 = new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
};
consumer1.accept("接收1个参数，无返回值的函数式接口实现");
Consumer<String> consumer2 = s -> System.out.println(s);
consumer2.accept("接收1个参数，无返回值的lambda表达式");
|
Supplier
供给型接口，无参数，但有返回值
其接口核心源码如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
@FunctionalInterface
public interface Supplier<T> {
T get();
}
|
写一个小示例：
1
2
3
4
5
6
7
8
9
10
11
12
| Supplier<Integer> supplier1 = new Supplier<Integer>() {
@Override
public Integer get() {
return new Random().nextInt(100);
}
};
System.out.println("supplier接口原始写法获取随机数：" +supplier1.get());
System.out.println("----------------------");
Supplier<Integer> supplier2 = () -> new Random().nextInt(100);
System.out.println("supplier接口Lambda表达式写法获取随机数：" +supplier2.get());
|
Function
函数型接口，接收参数T,返回一个R
其核心源码如下：
1
2
3
4
5
6
7
8
9
10
|
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
}
|
新老用法对比例子
1
2
3
4
5
6
7
8
9
10
11
12
| Function<Integer, String> function1 = new Function<Integer, String>() {
@Override
public String apply(Integer integer) {
return "接收整型参数：" + integer;
}
};
System.out.println(function1.apply(100));
System.out.println("----------------------");
Function<Integer, String> function2 = i -> "接收整型参数：" + i;
System.out.println(function2.apply(1000));
|
Predicate
断定型接口，接收参数T，判断其是否满足某一约束，返回一个boolean值
核心源码如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);
|
1
2
3
4
5
6
7
8
9
10
11
12
| Predicate<Integer> predicate1 = new Predicate<Integer>() {
@Override
public boolean test(Integer integer) {
return integer > 100;
}
};
System.out.println("大于100 ? " + predicate1.test(101));
System.out.println("----------------------");
Predicate<Integer> predicate2 = integer -> integer>100;
System.out.println("大于100 ? " + predicate2.test(99));
|
