添加URL
分享

lambda表达式,看完了你就是大佬了!

今天讲两个重要函数式接口`Predicate`和`Function`接口。这几个接口在Java中应用广泛,比方Stream流式API中就经常用到。


## 2. Predicate接口


当我们需要对某种数据类型进行判断,得到一个boolean值结果时候,可以采用`java.util.function.Predicate<T>`接口。比方说对传进来的List判断是否包含某个特定字符PHP。


### 2.1 条件判断


我们有时候需要进行业务判断,假设我要实现一个功能入参为List,如果List参数满足某个条件则输出对应的结果。比方说下面的代码`checkchar()`如果入参`list1`满足某个条件那么输出`System.out.println("满足对应条件")`,具体条件是什么还不确定,可能是判断List中是否包含某个元素,大小是否符合要求。具体由调用方来实现。


```java

private static boolean checkChar(List list1, Predicate<List> predicateList) {

boolean rs = predicateList.test(list1);

if (rs) {

System.out.println("满足对应的条件");

}

return rs;

}

```


下面我们实现main方法调用上面`checkchar()`方法,并且通过lambda表达式来实现里面具体判断条件。


```java

public static void main(String[] args) {

List list1 = new ArrayList();

list1.add("PHP");

list1.add("JAVA");

list1.add("C++");

boolean rs = checkChar(list1, s -> {

return s.contains("PHP");

});


if (rs) {

System.out.println("list1中包含PHP 字符");

} else {

System.out.println("list1中不包含PHP 字符");

}

}

```


`main`方法中,调用`checkChar()`方法的时候,传入lambda表达式`s->{return s.contains("PHP")}`来进行判断。这意思就是说在调用`checkChar`方法的时候如果`list1`列表中包含`PHP`这个元素执行`System.out.println("满足对应的条件")`语句。


上述代码执行结果为:


```java

满足对应的条件

list1中包含PHP 字符

```




### 2.2 与判断


上面我们说了单个条件判断,如果想多个条件判断怎么办?可以使用`Predicate的and()`方法。


我们先定义一个函数,这个函数里会进行两个判断,两个判断具体的逻辑由外部传过来。


```java

private static boolean checkChar2(List list1, Predicate<List> pre, Predicate<List> other) {

return pre.and(other).test(list1);

}

```


`main`方法中,传入两个判断逻辑` s -> { return s.contains("PHP");}` 和 ` s -> { return s.contains("C++");}`,然后通过`Predicate.and()`方法执行与操作。


```java

public static void main(String[] args) {

List list1 = new ArrayList();

list1.add("PHP");

list1.add("JAVA");

list1.add("C++");

boolean rs = checkChar2(list1, s -> {

return s.contains("PHP");

}, s -> {

return s.contains("C++");

});


if (rs) {

System.out.println("list1同时有PHP和C++字符");

} else {

System.out.println("list1不满足同时有PHP和C++字符");

}

}

```


上述代码的执行结果为:


```java

list1同时有PHP和C++字符

```




### 2.3 非判断


"与"、"或"我们已经了解了,剩下还有一个"非"(取反)操作,我们看一下取反操作`negate`如何使用。


`Predicate`的`negate()`方法如下:


```java

default Predicate<T> negate() {

return (t) -> !test(t);

}

```


从源码我们可以看到`negate`方法是在执行了`test()`方法之后,对结果`boolean`值进行取反而已。请注意,一定要先调用`negate`方法然后调用`test`方法 ,这个跟`and`和`or`方法一样:


```java

private static boolean checkNotChar(List list1, Predicate<List> pre1) {

return pre1.negate().test(list1);

}


public static void main(String[] args) {

List list1 = new ArrayList();

list1.add("PHP");

list1.add("JAVA");

list1.add("C++");

boolean rs = checkNotChar(list1, s -> {

return s.contains("C#");

});


if (rs) {

System.out.println("list1没有C#");

} else {

System.out.println("list1有C#");

}

}

```


上述代码执行结果为:


```java

list1没有C#

```


## 3. Function接口


`java.util.function.Function<T,R>`相当于数据中的函数,一个类型的数据作为输入得到另一个类型数据的输出。


### 3.1 转换方法:apply


`Function`中执行转换的方法为抽象方法`R apply(T t)`,该方法根据参数`T`类型数据获取类型为`R`的结果。比如下面我要将`String`类型转化为`Integer`类型。具体如何转换由调用方通过`lambda`来决定。


我们先定义转换的方法:


```java

private static Integer transfer(String param, Function<String, Integer> function) {

int num = function.apply(param);

return num;

}

```


具体转换逻辑在`main`方法中定义:


```java

public static void main(String[] args) {

String str = "99";

int num = transfer(str, s -> (Integer.parseInt(s) + 1));//这里定义具体的转换逻辑

System.out.println("DemoFunc执行结果为" + num);

}

```


### 3.2 级联转换:andThen


如果我们想做多步转换那么就需要用到`andThen()`方法了,这些具体转换的实现在调用放通过lambda来实现。


我先定义一个级联转换的方法`chainTransfer`,该方法中传入三个`Function`依次经过one,two,three进行转换,然后返回结果。


```java

private static Integer chainTransfer(String str, Function<String, Integer> one, Function<Integer, Integer> two,

Function<Integer, Integer> three) {

int num = one.andThen(two).andThen(three).apply(str);

return num;

}


```


下面在`main`方法中实现3个`Function`然后调用转换函数`chainTransfer`:


```java

public static void main(String[] args) {

int num = chainTransfer("9", str -> Integer.parseInt(str) + 10,

i -> i *= 10, i -> i + 5);

System.out.println("转换后的结果为:" + num);

}

```


我们执行上面`main`方法结果为:


```java

转换后的结果为:195

```


具体转换步骤为:


```java

1. 先将9转换成Integer类型然后+10,对应Integer.parseInt(str) + 10,得到19;

2. 然后乘以10,得到19*10 = 190;

3. 第三部加5,得到190+5 = 195。

```


当然定义这个方法的时候有一个要注意的,依赖被调用的`Function`参数类型要是适配,比方说`Function<String,Integer> one`入参为`String`返回值为`Integer`,那么后面`Function two `的入参必须是`Integer`。即前一个`Function`的返回值跟后一个`Function`入参类型应该兼容。


### 3.2 讨论级联转换中的类型兼容问题


前面我们说了,即前一个`Function`的返回值跟后一个`Function`入参类型应该兼容。因为前一个`Function`是后一个`Function`的入参,在函数调用中当实际入参是形参的子类那么是兼容的。


即如下的转换函数式兼容的:


```java

private static User objChainTransfer(String str, Function<String, VipUser> one, Function<User, User> two) {

User u = one.andThen(two).apply(str);

return u;

}

}

```


前面一个`Function`返回的是`VipUser`,其为第二个`Function`的入参`User`的子类。我们在`main`函数中调用上面的函数,其代码如下:


```java

public static void main(String[] args) {

User u = objChainTransfer("19", str -> {

return new VipUser("name" + str, str);

}, vipUser -> {

vipUser.setName(vipUser.getName() + "_new");

return vipUser;

});


System.out.println("转换后的结果为:" + u);

}

```


运行后其结果为:


```java

转换后的结果为:VipUser{name='name19_new', id='19'}

```


这段代码做了如下事情:


```java

1. 我们先创建一个`VipUser`对象

2. 修改name属性,

3. 返回User对象。

```




进一步我们可以分析源码:


```java

default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {

Objects.requireNonNull(after);

return (T t) -> after.apply(apply(t));

}

```


源码中,`andThen`方法中`Function<? super R, ? extends V> after`,表示`after`的这个`Function`的入参必须是R的超类,其中R是第一个`Function`的返回值。


具体可以查看Function.java的源码:


```java


public interface Function<T, R> {

/**

* Applies this function to the given argument.

*

* @param t the function argument

* @return the function result

*/

R apply(T t);

//...

}

```

发布于 2020-06-20