1. 行为参数化
在java8之前， 我们想给方法传递不同的行为， 最好的办法就是匿名类了：
比如下面我们想从一个装满苹果的list中的筛选出红苹果，需要传入一个 ApplePredicate， 于是我们在调用filterApples会传入一个匿名类， 实现了test方法来判断苹果的颜色是否为红色。
//过滤方法
public static List<Apple> filterApples(List<Apple> inventory, ApplePredicate p) {
List<Apple> result = new ArrayList<>();
for (Apple apple : inventory){
if (p.test(apple)){
result.add(apple);
}
}
return result;
}
//接口
public interface ApplePredicate{
boolean test (Apple apple);
}
//方法调用
List<Apple> redApples = filterApples(inventory, new ApplePredicate() {
public boolean test(Apple a){
return "red".equals(a.getColor());
}
});
其实我们需要的就是不同的test方法，但是由于在java8之前不支持Lambda表达式， 所以也需要创建一个对象来实现这个方法。
但是java8我们可以这么来完成这件事：
List<Apple> result =
filterApples(inventory, (Apple apple) -> "red".equals(apple.getColor()));
(Apple apple) -> "red".equals(apple.getColor()) 便是在java8中可以直接传递的函数， 这种表达式叫做Lamda表达式，可能现在还看不懂这个表达， 下面我们会详细讲解下lambda表达式。
lamda表达式结构
- 参数列表——这里它采用了 Comparator 中 compare 方法的参数,两个 Apple 。
- 箭头——箭头 -> 把参数列表与Lambda主体分隔开。
- Lambda主体——比较两个 Apple 的重量。表达式就是Lambda的返回值了。
在参数列表里的参数可以在后面的Lambda表达式中使用， 而后面表达式执行结束的值是默认的返回值， 也可以使用return来显式返回。
2. Lambda表达式在哪里使用？
什么条件下Lambda表达式可以作为参数传递呢？ 我们需要函数式接口来作为参数。
之前我们在筛选苹果时使用了接口：
public interface ApplePredicate{
boolean test (Apple apple);
}
这样只定义了一个抽象方法的接口便是函数式接口。 上面我们使用Lambda表达式或者使用匿名类都是对这个接口进行了实现， 原则上是一样的。
3. 函数描述符：
函数式接口的抽象方法的签名基本上就是Lambda表达式的签名。我们将这种抽象方法叫作
函数描述符。
例如上面ApplePredicate的函数描述符就是 Apple -> boolean, 传入一个Apple对象返回一个boolean。
另外java提供了一个标注： @FunctionalInterface
这个标注用于表示该接口会设计成一个函数式接口。如果你用 @FunctionalInterface 定义了一个接口,而它却不是函数式接口的话,编译器将返回一个提示原因的错误。
使用函数式接口
Java8提供了几个函数式接口， 下面来分别介绍下：
Predicate
@FunctionalInterface
public interface Predicate<T>{
boolean test(T t);
}
public static <T> List<T> filter(List<T> list, Predicate<T> p) {
List<T> results = new ArrayList<>();
for(T s: list){
if(p.test(s)){
results.add(s);
}
}
return results;
}
Predicate<String> nonEmptyStringPredicate = (String s) -> !s.isEmpty();
List<String> nonEmpty = filter(listOfStrings, nonEmptyStringPredicate);
Predicate定义了一个叫test的抽象方法， 接受泛型T对象， 并返回一个boolean， 可以在过滤时使用
Consumer
@FunctionalInterface
public interface Consumer<T>{
void accept(T t);
}
public static <T> void forEach(List<T> list, Consumer<T> c){
for(T i: list){
c.accept(i);
}
}
forEach(Arrays.asList(1,2,3,4,5), (Integer i) -> System.out.println(i));
Consumer定义了一个accept的抽象方法，接受泛型T对象，不返回
Function
@FunctionalInterface
public interface Function<T, R>{
R apply(T t);
}
public static <T, R> List<R> map(List<T> list, Function<T, R> f) {
List<R> result = new ArrayList<>();
for(T s: list){
result.add(f.apply(s));
}
return result;
}
List<Integer> l = map(Arrays.asList("lambdas","in","action"), (String s) -> s.length());
另外还提供了一些接口
函数式接口补充
4. lambda访问局部变量
访问局部变量
你可能会问自己,为什么局部变量有这些限制。
第一,实例变量和局部变量背后的实现有一个关键不同。实例变量都存储在堆中,而局部变量则保存在栈上。如果Lambda可以直接访问局部变量,而且Lambda是在一个线程中使用的,则使用Lambda的线程,可能会在分配该变量的线程将这个变量收回之后,去访问该变量。因此,Java在访问自由局部变量时,实际上是在访问它的副本,而不是访问原始变量。如果局部变量仅仅赋值一次那就没有什么区别了——因此就有了这个限制。
第二,这一限制不鼓励你使用改变外部变量的典型命令式编程模式(我们会在以后的各章中解释,这种模式会阻碍很容易做到的并行处理)
闭包
5. 方法引用
如何构建方法引用
方法引用主要有三类。
(1) 指向静态方法的方法引用(例如 Integer 的 parseInt 方法,写作 Integer::parseInt )。
(2) 指 向 任 意 类 型 实 例 方 法 的 方 法 引 用 ( 例 如 String 的 length 方 法 , 写 作 String::length )
(3) 指向现有对象的实例方法的方法引用(假设你有一个局部变量 expensiveTransaction
用于存放 Transaction 类型的对象,它支持实例方法 getValue ,那么你就可以写 expensive-Transaction::getValue )
第二种和第三种方法引用可能乍看起来有点儿晕。类似于 String::length 的第二种方法引用的思想就是你在引用一个对象的方法,而这个对象本身是Lambda的一个参数。例如,Lambda表达式 (String s) -> s.toUppeCase() 可以写作 String::toUpperCase 。但第三种方法引用指 的 是 , 你 在 Lambda 中 调 用 一 个 已 经 存 在 的 外 部 对 象 中 的 方 法 。 例 如 , Lambda 表 达 式()->expensiveTransaction.getValue() 可以写作 expensiveTransaction::getValue 。
方法引用例子
方法引用实战
现在我们来尝试实现一个专门的comparator来对一个装满Apple的List进行排序
- 传递代码
因为java已经有了一个sort的接口：
void sort(Comparator<? super E> c)
看来我们需要实现一个Comparator的接口才行， 首先我们尝试用最早的匿名类来实现：
inventory.sort(new Comparator<Apple>() {
public int compare(Apple a1, Apple a2){
return a1.getWeight().compareTo(a2.getWeight());
}
});
- 使用lambda表达式
匿名类的实现太啰嗦了， 我们来尝试用lambda表达式：
inventory.sort((a1, a2) -> a1.getWeight().compareTo(a2.getWeight()));
因为Comparator有一个静态方法
Comparator<Apple> c = Comparator.comparing((Apple a) -> a.getWeight());
我们就可以再精简为
inventory.sort(comparing((a) -> a.getWeight()));
- 使用方法引用
inventory.sort(comparing(Apple::getWeight));
6. 复合Lambda表达式
- 比较器复合：
inventory.sort(comparing(Apple::getWeight)
.reversed()
.thenComparing(Apple::getCountry));
- 谓词复合：
谓词接口包括三个方法：negate、and和or，让你可以重用已有的Predicate来创建更复杂的谓词
Predicate<Apple> redAndHeavyAppleOrGreen = redApple.and(a -> a.getWeight() > 150).or(a -> "green".equals(a.getColor()));
- 函数复合：
还可以把Function接口所代表的Lambda表达式复合起来。Function接口为此配了andThen和compose两个默认方法，它们都会返回Function的一个实例。
Function<Integer, Integer> f = x -> x + 1;
Function<Integer, Integer> g = x -> x * 2;
用compose的话，它将意味着f(g(x))，而andThen则意味着g(f(x))
网友评论