Java 8 - 07 复合 Lambda 表达式

ゞ浴缸里的玫瑰 2023-03-14 13:15 83阅读 0赞

### 文章目录 ###

*  Pre
 *  Comparator 比较器复合
 *   *  逆序 reversed()
     *  比较器链 thenComparing
 *  Predicate 谓词复合
 *   *  negate
     *  and / or
 *  Function 函数复合
 *   *  andThen
     *  compose

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70]

# Pre #

前面几个我们使用lambda表达式，都用的是默认的抽象方法，还记得不？

事实上，许多函数式接口，比如用于传递Lambda表达式的 Comparator 、 Function 和 Predicate 都提供了允许你进行复合的方法

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 1]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 2]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 3]

这些函数接口中的其他方法（default方法或者static方法） 有啥用呢？

在实际使用场景中，可以把多个简单的Lambda复合成复杂的表达式。 比如 可以让两个谓词之间做一个 or 操作，组合成一个更大的谓词，还可以让一个函数的结果成为另一个函数的输入等等

接下来我们挑几个函数式接口来实战一下

--------------------

# Comparator 比较器复合 #

![在这里插入图片描述][20200517233945747.png]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 4]

是不是懵了，这么多default 和 static方法 。。。

不急，一点点看

[Java 8 - Lambda 和方法引用实战][Java 8 - Lambda] 中推导了一个表达式如下

enginnerList.sort(comparing(Enginner::getJob));

## 逆序 reversed() ##

对enginnerList进行排序，比较工程师的职位 ， 这个时候如果想倒叙排列呢？

用不着去建立另一个 Comparator 的实例。接口有一个默认方法 reversed 可以使给定的比较器逆序。因此仍然用开始的那个比较器，只要修改一下前一个例子就可以对Enginner按职位递减排序：

enginnerList.sort(comparing(Enginner::getJob).reversed());

## 比较器链 thenComparing ##

如果发现有两个Engineer的职位一样 怎么办？哪个Engineer应该排在前面呢？你可能  
需要再提供一个 Comparator 来进一步定义这个比较，比如再按年龄排序。 thenComparing 方法就是做这个用的。它接受一个函数作为参数（就像 comparing 方法一样），如果两个对象用第一个 Comparator 比较之后是一样的，就提供第二个 Comparator 。

enginnerList.sort(comparing(Enginner::getJob)
                        .reversed()  // 倒叙
                        .thenComparing(Enginner::getAge)); // 职位相同时， 进一步按年龄排序

--------------------

# Predicate 谓词复合 #

谓词接口包括三个方法： negate 、 and 和 or ，让你可以重用已有的 Predicate 来创建更复杂的谓词。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 3]

## negate ##

比如，我们可以使用 negate 方法来返回一个 Predicate 的非 。

例如 不是Java工程师

// 产生现有 Predicate 对象 redApple 的非
    
    Predicate<Apple> notRedApple = redApple.negate();

## and / or ##

还可能想要把两个Lambda用 and 方法组合起来，比如一个苹果既是红色又比较重：

// 链接两个谓词来生成另 一个 Predicate 对象
    
    Predicate<Apple> redAndHeavyApple = redApple.and(a -> a.getWeight() > 150);

可以进一步组合谓词，表达要么是重（150克以上）的红苹果，要么是绿苹果

// 链接 Predicate 的 方法来构造更复杂 Predicate 对象
    
    Predicate<Apple> redAndHeavyAppleOrGreen = redApple.and(a -> a.getWeight() > 150)
    .or(a -> "green".equals(a.getColor()));

--------------------

# Function 函数复合 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 1]

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

## andThen ##

andThen 方法会返回一个函数，它先对输入应用一个给定函数，再对输出应用另一个函数。

Function<Integer, Integer> f = x -> x + 1;
    Function<Integer, Integer> g = x -> x * 2;
    Function<Integer, Integer> h = f.andThen(g); // 数学上会写作 g(f(x)) 或 (g o f)(x)
    int result = h.apply(1); // 这将返回4

## compose ##

compose 方法，先把给定的函数用作 compose 的参数里面给的那个函数，然后再把函数本身用于结果。

比如在上一个例子里用 compose 的话，它将意味着 f(g(x)) ，而 andThen 则意味着 g(f(x)) ：

Function<Integer, Integer> f = x -> x + 1;
    Function<Integer, Integer> g = x -> x * 2;
    Function<Integer, Integer> h = f.compose(g); // 数学上会写作 f(g(x)) 或 (f o g)(x)
    int result = h.apply(1); // 这将返回3

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70]: /images/20230312/b74b1a733acf4c79bb6f1de92fb486ac.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 1]: /images/20230312/7fa8f9d24c914446b848e6fd4086459a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 2]: /images/20230312/82951c7b61b841788730355d329dc89a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 3]: /images/20230312/ae045cc2ec0946f38c0dbe5241dc0c39.png
[20200517233945747.png]: /images/20230312/3ab7e4cb10b2489e909a5c593c86b8ba.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70 4]: /images/20230312/8215e175587448c1a0666c69899336dc.png
[Java 8 - Lambda]: https://blog.csdn.net/yangshangwei/article/details/106182816