Java8 学习总结 - 基本思想

2019年4月18日 236次阅读 来源: little田同学

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表达式。

《Java8 学习总结 - 基本思想》 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());

另外还提供了一些接口

《Java8 学习总结 - 基本思想》 函数式接口补充

4. lambda访问局部变量

《Java8 学习总结 - 基本思想》 访问局部变量

你可能会问自己,为什么局部变量有这些限制。
第一,实例变量和局部变量背后的实现有一个关键不同。实例变量都存储在堆中,而局部变量则保存在栈上。如果Lambda可以直接访问局部变量,而且Lambda是在一个线程中使用的,则使用Lambda的线程,可能会在分配该变量的线程将这个变量收回之后,去访问该变量。因此,Java在访问自由局部变量时,实际上是在访问它的副本,而不是访问原始变量。如果局部变量仅仅赋值一次那就没有什么区别了——因此就有了这个限制。
第二,这一限制不鼓励你使用改变外部变量的典型命令式编程模式(我们会在以后的各章中解释,这种模式会阻碍很容易做到的并行处理)

《Java8 学习总结 - 基本思想》 闭包

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 。

《Java8 学习总结 - 基本思想》 方法引用例子

方法引用实战

现在我们来尝试实现一个专门的comparator来对一个装满Apple的List进行排序

  1. 传递代码
    因为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());
  }
});
  1. 使用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()));
  1. 使用方法引用
inventory.sort(comparing(Apple::getWeight));

6. 复合Lambda表达式

  1. 比较器复合：
inventory.sort(comparing(Apple::getWeight)
.reversed()
.thenComparing(Apple::getCountry));
  1. 谓词复合：
    谓词接口包括三个方法：negate、and和or，让你可以重用已有的Predicate来创建更复杂的谓词
Predicate<Apple> redAndHeavyAppleOrGreen = redApple.and(a -> a.getWeight() > 150).or(a -> "green".equals(a.getColor()));
  1. 函数复合：
    还可以把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))
    原文作者：little田同学
    原文地址: https://www.jianshu.com/p/93de07fc6f03
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞