《Java8实战》-第三章读书笔记(Lambda表达式-02)

当我们第一次提到Lambda表达式时,说它可以为函数式接口生成一个实例。然而,Lambda表达式本身并不包含它在实现哪个函数式接口的信息。为了全面了解Lambda表达式,你应该知道Lambda的实际类型是什么。

类型检查

Lambda的类型是从使用Lambda上下文推断出来的。上下文(比如,接受它传递的方法的参数,或者接受它的值得局部变量)中Lambda表达式需要类型称为目标类型。

同样的Lambda,不同的函数式接口

有了目标类型的概念,同一个Lambda表达式就可以与不同的函数接口关联起来,只要它们的抽象方法能够兼容。比如,前面提到的Callable,这个接口代表着什么也不接受且返回一个泛型T的函数。

同一个Lambda可用于多个不同的函数式接口:

Comparator<Apple> c1 = (Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight());
ToIntBiFunction<Apple, Apple> c2 = (Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight());
BiFunction<Apple, Apple, Integer> c3 = (Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight());;
复制代码

是的,ToIntFunction和BiFunction都是属于函数式接口。还有很多类似的函数式接口,有兴趣的可以去看相关的源码

到目前为止,你应该能够很好的理解在什么时候以及在哪里使用Lambda表达式了。它们可以从赋值的上下文、方法调用(参数和返回值),以及类型转换的上下文中获得目标类型。为了更好的了解Lambda表达的时候方式,我们来看看下面的例子,为什么不能编译

Object o = () -> {System.out.println("Tricky example");};
复制代码

答案:很简单,我们都知道Object这个类并不是一个函数式接口,所以它不支持这样写。为了解决这个问题,我们可以把Object改为Runnable,Runnable是一个函数式接口,因为它只有一个抽象方法,在上一节的读书笔记中我们有提到过它。

Runnable r = () -> {System.out.println("Tricky example");};
复制代码

你已经见过如何利用目标类型来检查一个Lambda是否可以用于某个特定的上下文。其实,它也可以用来做一些略有不同的事情:tuiduanLambda参数的类型。

类型推断

我们还可以进一步的简化代码。Java编译器会从上下文(目标类型)推断出用什么函数式接口来匹配Lambda表达式,这意味着它也可以推断出适合Lambda的签名,因为函数描述符可以通过目标类型来得到。这样做的好处在于,编译器可以了解Lambda表达式的参数类型,这样就可以在Lambda与法中省去标注参数类型。换句话说,Java编译器会向下面这样推断Lambda的参数类型:

// 参数a没有显示的指定类型
List<Apple> greenApples = filter(apples, a -> "green".equals(a.getColor()));
复制代码

Lambda表达式有多个参数,代码可独行的好处就更为明显。例如,你可以在这用来创建一个Comparator对象:

// 没有类型推断,显示的指定了类型
Comparator<Apple> cApple1 = (Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight());

// 有类型推断,没有现实的指定类型
Comparator<Apple> cApple2 = (a1, a2) -> a1.getWeight().compareTo(a2.getWeight());
复制代码

有时候,指定类型的情况下代码更易读,有时候去掉它们也更易读。并没有说哪个就一定比哪个好,需要根据自身情况来选择。

使用局部变量

我们迄今为止所介绍的所有Lambda表达式都只用到了其主体里的参数。但Lambda表达式也允许用外部变量,就像匿名类一样。他们被称作捕获Lambda。例如:下面的Lambda捕获了portNumber变量:

int portNumber = 6666;
Runnable r3 = () -> System.out.println(portNumber);
复制代码

尽管如此,还有一点点小麻烦:关于能对这些变量做什么有一些限制。Lambda可以没有限制地捕获(也就是在主体中引用)实例变量和静态变量。但局部变量必须显示的声明final,或实际上就算final。换句话说,Lambda表达式只能捕获指派给它们的局部变量一次。(注:捕获实例变量可以被看作捕获最终局部变量this)。例如,下面的代码无法编译。

int portNumber = 6666;
Runnable r3 = () -> System.out.println(portNumber);
portNumber = 7777;
复制代码

portNumber是一个final变量,尽管我们没有显示的去指定它。但是,在代码编译的时候,编译器会自动给这个变量加了一个final,起码我看反编译后的代码是有一个final的。

对于局部变量的限制

你可能会有一个疑问,为什么局部变量会有这些限制。第一个,实例变量和局部变量背后的实现有一个关键不同。实例变量都存储在堆中,而局部变量则保存在栈上。如果Lambda可以直接访问局部变量,而且Lambda是在一个线程中使用,则使用Lambda的线程,可能会在分配该变量的线程将这个变量回收之后,去访问该变量。因此,Java在访问自由局部变量是,实际上是在访问它的副本,而不是访问原始变量。如果局部变量仅仅复制一次那就没什么区别了,因此就有了这个限制。

现在,我们来了解你会在Java8代码中看到的另一个功能:方法引用。可以把它们视为某些Lambda的快捷方式。

方法引用

方法引用让你可以重复使用现有的方法,并像Lambda一样传递它们。在一些情况下,比起用Lambda表达式还要易读,感觉也更自然。下面就是我们借助Java8 API,用法引用写的一个排序例子:

// 之前
apples.sort((Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight()));
// 之后,方法引用
apples.sort(Comparator.comparing(Apple::getWeight));
复制代码

酷,使用::的代码看起来更加简洁。在此之前,我们也有使用到过,它的确看起来很简洁。

管中窥豹

方法引用可以被看作仅仅调用特定方法的Lambda的一种快捷写法。它的基本思想是,如果一个Lambda代表的只是:“直接调用这个方法”,那最好还是用名称来调用它,而不是去描述如何调用它。事实上,方法引用就是让你根据已有的方法实现来创建Lambda表达式。但是,显示地指明方法的名称,你的代码可读性会更好。它是如何工作的? 当你需要使用方法引用是,目标引用放在分隔符::前,方法的名称放在后面。 例如,Apple::getWeight就是引用了Apple类中定义的getWeight方法。请记住,不需要括号,因为你没有实际调用这个方法。方法引用就是用Lambda表达式(Apple a) -> a.getWeight()的快捷写法。

我们接着来看看关于Lambda与方法引用等效的一些例子:

Lambda:(Apple a) -> a.getWeight() 
方法引用:Apple::getWeight

Lambda:() -> Thread.currentThread().dumpStack() 
方法引用:Thread.currentThread()::dumpStack

Lambda:(str, i) -> str.substring(i)
方法引用:String::substring

Lambda:(String s) -> System.out.println(s)
方法引用:System.out::println
复制代码

你可以把方法引用看作是Java8中个一个语法糖,因为它简化了一部分代码。

构造函数引用

对于一个现有的构造函数,你可以利用它的名称和关键字new来创建它的一个引用:ClassName::new。如果,一个构造函数没有参数,那么可以使用Supplier来创建一个对象。你可以这样做:

Supplier<Apple> c1 = Apple::new;
Apple apple = c1.get();
复制代码

这样做等价于

Supplier<Apple> c1 = () -> new Apple();
Apple apple = c1.get();
复制代码

如果,你的构造函数的签名是Apple(Integer weight),那么可以使用Function接口的签名,可以这样写:

Function<Integer, Apple> c2 = Apple::new;
Apple a2 = c2.apply(120);
复制代码

这样做等价于

Function<Integer, Apple> c2 = (weight) -> new Apple(weight);
Apple a2 = c2.apply(120);
复制代码

如果有两个参数Apple(weight, color),那么我们可以使用BiFunction:

BiFunction<Integer, String, Apple> c3 = Apple::new;
Apple a3 = c3.apply(120, "red");
复制代码

这样做等价于

BiFunction<Integer, String, Apple> c3 =(weight, color) -> new Apple(weight, color);
Apple a3 = c3.apply(120, "red");
复制代码

到目前为止,我们了解到了很多新内容:Lambda、函数式接口和方法引用,接下来我们将把这一切付诸实践。

Lambda和方法引用实战

为了更好的熟悉Lambda和方法引用的使用,我们继续研究开始的那个问题,用不同的排序策略给一个Apple列表排序,并需要展示如何把一个圆使出报的解决方案变得更为简明。这会用到我们目前了解到的所有概念和功能:行为参数化、匿名类、Lambda表达式和方法引用。我们想要实现的最终解决方案是这样的:

apples.sort(comparing(Apple::getWeight));
复制代码

第1步:代码传递

很幸运,Java8的Api已经提供了一个List可用的sort方法,我们可以不用自己再去实现它。那么最困难部分已经搞定了!但是,如果把排序策略传递给sort方法呢?你看,sort方法签名是这样的:

void sort(Comparator<? super E> c)
复制代码

它需要一个Comparator对象来比较两个Apple!这就是在Java中传递策略的方式:它们必须包裹在一个对象利。我们说sort的行为被参数化了了:传递给他的排序策略不同,其行为也会不同。

可能,你的第一个解决方案是这样的:

public class AppleComparator implements Comparator<Apple> {
    @Override
    public int compare(Apple o1, Apple o2) {
        return o1.getWeight().compareTo(o2.getWeight());
    }
}

apples.sort(new AppleComparator());
复制代码

它确实能实现排序,但是还需要去实现一个接口,并且排序的规则也不复杂,或许它还可以简化一下。

第2步:使用匿名类

或许你已经想到了一个简化代码的办法,就是使用匿名类而且每次使用只需要实例化一次就可以了:

apples.sort(new Comparator<Apple>() {
    @Override
    public int compare(Apple o1, Apple o2) {
        return o1.getWeight().compareTo(o2.getWeight());
    }
});
复制代码

看上去确实简化一些,但感觉还是有些啰嗦,我们接着继续简化:

第3步:使用Lambda表达式

我们可以使用Lambda表达式来替代匿名类,这样可以提高代码的简洁性和开发效率:

apples.sort((o1, o2) -> o1.getWeight().compareTo(o2.getWeight()));
复制代码

太棒了!这样的代码看起来很简洁,原来四五行的代码只需要一行就可以搞定了!但是,我们还可以使这行代码更加的简洁!

第4步:使用方法引用

使用Lambda表达式的代码确实简洁了不少,那你还记得我们前面说的方法引用吗?它是Lambda表达式的一种快捷写法,相当于是一种语法糖,那么我们来试试糖的滋味如何:

apples.sort(Comparator.comparing(Apple::getWeight));
复制代码

恭喜你,这就是你的最终解决方案!这样的代码比真的很简洁,这比Java8之前的代码好了很多。这样的代码比较简短,它的意思也很明显,并且代码读起来和问题描述的差不多:“对库存进行排序,比较苹果的重量”。

复合(组合)Lambda表达式的有用方法

Java8的好几个函数式接口都有为方便而设计的的方法。具体而言,许多函数式接口,比如用于传递Lambda表达式的Comparator、Function和Predicate都提供了允许你进行复合的方法。这是什么意思呢?在实践中,这意味着你可以把多个简单的Lambda复合成复杂的表达式。比如,你可以让两个谓词之间做一个or操作,组合成一个更大的谓词。而且,你还可以让一个函数的结果成为另一个函数的输入。你可能会想,函数式接口中怎么可能有更多的方法?(毕竟,这违背了函数式接口的定义,只能有一个抽象方法)还记得我们上一节笔记中提到默认方法吗?它们不是抽象方法。关于默认方法,我们以后在进行详细的了解吧。

比较复合器

还记刚刚我们对苹果的排序吗?它只是一个从小到大的一个排序,现在我们需要让它进行逆序。看看刚刚方法引用的代码,你会发现它貌似无法进行逆序啊!不过不用担心,我们可以让它进行逆序,而且很简单。

1.逆序

想要实现逆序其实很简单,需要使用一个reversed()方法就可以完成我们想要的逆序排序:

apples.sort(Comparator.comparing(Apple::getWeight).reversed());
复制代码

按重量递减排序,就这样完成了。这个方法很有用,而且用起来很简单。

2.比较器链

上面的代码很简单,但是你仔细想想,如果存在两个一样重的苹果谁前谁后呢?你可能需要再提供一个Comparator来进一步定义这个比较。比如,再按重量比较了两个苹果之后,你可能还想要按原产国进行排序。thenComparing方法就是做这个用的。它接受一个函数作为参数(就像comparing方法一样),如果两个对象用第一个Comparator比较之后还是一样,就提供第二个Comparator。我们又可以优雅的解决这个问题了:

apples.sort(Comparator.comparing(Apple::getWeight).reversed()
                .thenComparing(Apple::getCountry));
复制代码

复合谓词

谓词接口包括了三个方法: negate、and和or,让你可以重用已有的Predicate来创建更复杂的谓词。比如,negate方法返回一个Predicate的非,比如苹果不是红的:

private static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
    List<T> result = new ArrayList<>();
    for (T t : list) {
        if (predicate.test(t)) {
            result.add(t);
        }
    }
    return result;
}

List<Apple> apples = Arrays.asList(new Apple(150, "red"), new Apple(110, "green"), new Apple(100, "green"));
// 只要红苹果
Predicate<Apple> apple = a -> "red".equals(a.getColor());
// 只要红苹果的非
Predicate<Apple> notRedApple = apple.negate();
// 筛选
List<Apple> appleList = filter(apples, notRedApple);
// 遍历打印
appleList.forEach(System.out::println);
复制代码

你可能还想要把Lambda用and方法组合起来,比如一个苹果即是红色的又比较重:

Predicate<Apple> redAndHeavyApple = apple.and(a -> a.getWeight() >= 150);
复制代码

你还可以进一步组合谓词,表达要么是重的红苹果,要么是绿苹果:

Predicate<Apple> redAndHeavyAppleOrGreen =
                apple.and(a -> a.getWeight() >= 150)
                        .or(a -> "green".equals(a.getColor()));
复制代码

这一点为什么很好呢?从简单的Lambda表达式出发,你可以构建更复杂的表达式,但读起来仍然和问题陈述的差不多!请注意,and和or方法是按照表达式链中的位置,从左向右确定优先级的。因此,a.or(b).and(c)可以看作(a || b) && c。

函数复合

最后,你还可以把Function接口所代表的Lambda表达式复合起来。Function接口为此匹配了andThen和compose两个默认方法,它们都会返回Function的一个实例。

andThen方法会返回一个函数,它先对输入应用一个给定函数,再对输出应用另一个函数。假设,有一个函数f给数字加1(x -> x + 1),另外一个函数g给数字乘2,你可以将它们组合成一个函数h:

Function<Integer, Integer> f = x -> x + 1;
Function<Integer, Integer> g = x -> x * 2;
Function<Integer, Integer> h = f.andThen(g);
// result = 4
int result = h.apply(1);
复制代码

你也可以类似地使用compose方法,先把给定的函数左右compose的参数里面给的那个函数,然后再把函数本身用于结果。比如在上一个例子用compose的化,它将意味着f(g(x)),而andThen则意味着g(f(x)):

Function<Integer, Integer> f1 = x -> x + 1;
Function<Integer, Integer> g1 = x -> x * 2;
Function<Integer, Integer> h1 = f1.compose(g1);
// result1 = 3
int result1 = h1.apply(1);
复制代码

它们的关系如下图所示:

《Java8实战》-第三章读书笔记(Lambda表达式-02)

compose和andThen的不同之处就是函数执行的顺序不同。compose函数限制先参数,然后执行调用者,而andThen限制先调用者,然后再执行参数。

总结

在《Java8实战》第三章中,我们了解到了很多概念关键的念。

  1. Lambda表达式可以理解为一种匿名函数:它没有名称,但有参数列表、函数主体、返回类型,可能还有一个可抛出的异常列表。
  2. Lambda表达式让我们可以简洁的传递代码。
  3. 函数式接口就是仅仅只有一个抽象方法的接口。
  4. 只有在接受函数式接口的地方才可以使用Lambda表达式。
  5. Lambda表达式允许你直接内联,为函数式接口的抽象方法提供实现,并且将整个表达式作为函数式接口的一个实例。
  6. Java8自带一些常用的函数式接口,在java.util.function包里,包括了Predicate、Function<T, R>、Supplier、Consumer和BinaryOperatory。
  7. 为了避免装箱操作,等于Predicate和Function<T, R>等通用的函数式接口的原始类型特化:IntPredicate、IntToLongFunction等。
  8. Lambda表达式所需要代表的类型称为目标类型。
  9. 方法引用可以让我们重复使用现有的方法实现并且直接传递它们。
  10. Comparator、Predicate和Function等函数式接口都有几个可以用来结合Lambda表达式的默认方法。

第三章的内容确实很多,而且这一章的内容也很重要,如果你有兴趣那么请慢慢的看,最好自己能动手写写代码否则过不了多久就会忘记了。

原文 

https://juejin.im/post/5b7813a6e51d4538c3620473

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » 《Java8实战》-第三章读书笔记(Lambda表达式-02)

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址