java8中预定义的函数式接口:Predicate、Consumer、Function等

雨点打透心脏的1/2处 2022-05-12 11:06 199阅读 0赞

上一篇中介绍的函数式接口的抽象方法是Lambda表达式的函数描述符，Lambda表达式需要有与之相匹配的函数式接口才能正常工作，那么在java8中，java的设计者为我们提供了哪些常用的函数式接口？

java.util.function.Predicate< T >

Predicate(谓词)函数式接口定义了一个test抽象方法，它接受泛型参数T并返回布尔值，其定义如下：

1.  `@FunctionalInterface`
2.  `public interface Predicate<T>{`
3.  `boolean test(T t);`
4.  `}`

> 谓词（predicate）在数学上常常用来代表一个类似函数的东西，它接受一个参数值，并返回true或false。

如果定义一个接受String对象的Lambda表达式，代码如下：

1.  `//根据条件（行为）p过滤集合，符合条件p的加入过滤结果中`
2.  `public static <T> List<T> filter(List<T> list, Predicate<T> p) {`
3.  `List<T> results = new ArrayList<>();`
4.  `for(T s: list){`
5.  `if(p.test(s)){`
6.  `results.add(s);`
7.  `}`
8.  `}`
9.  `return results;`
10. `}`
11. `//Lambda表达式，判断非空`
12. `Predicate<String> nonEmptyStringPredicate = (String s) -> !s.isEmpty();`
13. `//从集合中过滤出非空的字符串`
14. `List<String> nonEmpty = filter(listOfStrings, nonEmptyStringPredicate);`

java.util.function.Consumer< T >

Consumer翻译成中文是“消费者”的意思，如果从输入输出的角度来考虑，消费这一行为有输入但没有输出，因为输入的东西被消费掉了，对应到java里的函数就是一个有参数但没有返回值的函数，这个函数就是函数式接口Consumer的抽象方法，方法名叫accept,接收一个泛型参数T,无返回（void）,定义如下：

1.  `@FunctionalInterface`
2.  `public interface Consumer<T>{`
3.  `void accept(T t);`
4.  `}`

应用如下：

1.  `public static <T> void forEach(List<T> list, Consumer<T> c){`
2.  `for(T i: list){`
3.  `c.accept(i);`
4.  `}`
5.  `}`
6.  `//Lambda是函数式接口Consumer中抽象方法accept的实现`
7.  `forEach(Arrays.asList(1,2,3,4,5),(Integer i) -> System.out.println(i));`

这里传递给forEach方法的第二个参数：Lambda表达式，就相当于实现了函数式接口Consumer中抽象方法accept.

java.util.function.Function< T, R >

定义：

1.  `@FunctionalInterface`
2.  `public interface Function<T, R>{`
3.  `R apply(T t);`
4.  `}`

从函数式接口Function的定义中可以看出，抽象方法apply是将泛型参数对象T转换成了泛型R对象,常用于将输入信息映射成另一种类型的输出。示例如下：

1.   
2.  `public static <T, R> List<R> map(List<T> list,Function<T, R> f) {`
3.  `List<R> result = new ArrayList<>();`
4.  `for(T s: list){`
5.  `result.add(f.apply(s));`
6.  `}`
7.  `return result;`
8.  `}`
9.  `//将输入的字符串集合映射成字符串长度的整形集合`
10. `List<Integer> l = map(Arrays.asList("lambdas","in","action"),(String s) -> s.length());`

同样，上面代码传递给map方法的第二个参数：lambda表达式，是Function方法apply的实现。

原始类型特化

前方介绍的三个泛型函数式接口： Predicate< T >、 Consumer< T >和Function< T,R >，只能绑定到引用类型，对于基本类型，如int、double等，虽然也能使用包装类型Intger\\Double等来解决，但会涉及到自动装箱操作，当处理一定量的数据时，会带来性能问题，因此java8针对原始类型特化了一些函数式接口，专门用来处理原始类型数据，避免装箱与拆箱带来的性能问题。如：IntPredicate、LongPredicate等，其使用跟普通的函数式接口一样，只是针对了特定的数据类型。

java8还预定义了其它类型的函数式接口，如Supplier（与Consumer相对应）、UnaryOperator等，将它们总结如下：

<table> 
 <thead> 
  <tr> 
   <th>函数式接口</th> 
   <th>函数描述符</th> 
   <th>原始类型特化</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Predicate&lt; T &gt;</td> 
   <td>T-&gt;boolean</td> 
   <td>IntPredicate,LongPredicate, DoublePredicate</td> 
  </tr> 
  <tr> 
   <td>Consumer&lt; T &gt;</td> 
   <td>T-&gt;void</td> 
   <td>IntConsumer,LongConsumer, DoubleConsumer</td> 
  </tr> 
  <tr> 
   <td>Function&lt; T,R &gt;</td> 
   <td>T-&gt;R</td> 
   <td>IntFunction&lt; R &gt;,IntToDoubleFunction,IntToLongFunction,LongFunction&lt; R &gt;,LongToDoubleFunction,LongToIntFunction,DoubleFunction&lt; R &gt;,ToIntFunction&lt; T &gt;,ToDoubleFunction&lt; T &gt;,ToLongFunction&lt; T &gt;</td> 
  </tr> 
  <tr> 
   <td>Supplier&lt; T &gt;</td> 
   <td>()-&gt;T</td> 
   <td>BooleanSupplier,IntSupplier, LongSupplier,DoubleSupplier</td> 
  </tr> 
  <tr> 
   <td>UnaryOperator&lt; T &gt;</td> 
   <td>T-&gt;T</td> 
   <td>IntUnaryOperator,LongUnaryOperator,DoubleUnaryOperator</td> 
  </tr> 
  <tr> 
   <td>BinaryOperator&lt; T &gt;</td> 
   <td>(T,T)-&gt;T</td> 
   <td>IntBinaryOperator,LongBinaryOperator,DoubleBinaryOperator</td> 
  </tr> 
  <tr> 
   <td>BiPredicate&lt; L,R &gt;</td> 
   <td>(L,R)-&gt;boolean</td> 
   <td>&nbsp;</td> 
  </tr> 
  <tr> 
   <td>BiConsumer&lt; T,U &gt;</td> 
   <td>(T,U)-&gt;void</td> 
   <td>ObjIntConsumer&lt; T &gt;,ObjLongConsumer&lt; T &gt;,ObjDoubleConsumer&lt; T &gt;</td> 
  </tr> 
  <tr> 
   <td>BiFunction&lt; T,U,R &gt;</td> 
   <td>(T,U)-&gt;R</td> 
   <td>ToIntBiFunction&lt; T,U &gt;,ToLongBiFunction&lt; T,U &gt;,ToDoubleBiFunction&lt; T,U &gt;</td> 
  </tr> 
 </tbody> 
</table>

一些常用的Lambda表达式与其对应的函数式接口应用举例：

<table> 
 <thead> 
  <tr> 
   <th>使用案例</th> 
   <th>Lambda表达式</th> 
   <th>对应的函数式接口</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>布尔表达式</td> 
   <td>(List&nbsp;list) -&gt; list.isEmpty()</td> 
   <td>Predicate&lt; List&lt; String &gt; &gt;</td> 
  </tr> 
  <tr> 
   <td>创建对象</td> 
   <td>() -&gt; new Apple(10)</td> 
   <td>Supplier&lt; Apple &gt;</td> 
  </tr> 
  <tr> 
   <td>消费一个对象</td> 
   <td>(Apple a) -&gt; System.out.println(a.getWeight())</td> 
   <td>Consumer&lt; Apple &gt;</td> 
  </tr> 
  <tr> 
   <td>从一个对象中选择/提取</td> 
   <td>(String s) -&gt; s.length()</td> 
   <td>Function&lt; String, Integer &gt;或ToIntFunction&lt; String &gt;</td> 
  </tr> 
  <tr> 
   <td>合并两个值</td> 
   <td>(int a, int b) -&gt; a * b</td> 
   <td>IntBinaryOperator</td> 
  </tr> 
  <tr> 
   <td>比较两个对象</td> 
   <td>(Apple a1, Apple a2) -&gt; a1.getWeight().compareTo(a2.getWeight())</td> 
   <td>Comparator&lt; Apple &gt;或BiFunction&lt; Apple, Apple, Integer &gt; 或 ToIntBiFunction&lt; Apple, Apple &gt;</td> 
  </tr> 
 </tbody> 
</table>