Java8-Lambda表达式

Posted 2020-10-04

  函数式接口定义且只定义了一个抽象方法。函数式接口很有用，因为抽象方法的签名可以描述Lambda表达式的签名。函数式接口的抽象方法的签名称为函数描述符。所以为了应用不同的Lambda表达式，你需要一套能够描述常见函数描述符的函数式接口。Java API 中已经有了几个函数式接口，例如Comparable、Runnable、Callable。

1.系统中的函数式接口

  Java8中的java.util.function包中引入了几个新的函数式接口，例如：Predicate、Consumer、Function等等。

  (1).Predicate

  java.util.function.Preicate<T> 接口定义了一个名为test的抽象方法，它接收泛型T对象，并且返回一个boolean类型。这个恰恰和你先前创建的一样，现在你就可以直接使用了。在你需要表示一个设计类型为T的boolean表达式时，就可以使用这个借口哦。比如，你可以定义一个接受String对象Lambda表达式。

 1 public class Demo3 {
 2     public static void main(String[] args) {
 3         List<String> stringList = Arrays.asList("1", "2", "", "a");
 4         List<String> list = filter(stringList, (String s) -> !s.isEmpty());
 5         for(String string : list){
 6             System.out.println(string);
 7         }
 8     }
 9 
10     public static <T> List<T> filter(List<T> list, Predicate<T> p) {
11         List<T> result = new ArrayList<>();
12         for (T t : list) {
13             if (p.test(t)) {
14                 result.add(t);
15             }
16         }
17         return result;
18     }
19 }

 (2).Consumer

  java.util.function.Consumer<T> 定义了一个名叫accept的抽象方法，它接收泛型T的对象，没有返回(void)。你如果需要访问类型T的对象，并对其执行某些操作，就可以使用这个接口。比如，你可以用它来创建一个forEach方法，接收一个Integers的列表，并且对其中的每个元素执行操作。在下面的代码中，你就可以使用这个forEach方法，并且配合Lambda来打印列表中的所有元素。

 1 public class Demo3 {
 2     public static void main(String[] args) {
 3         List<String> stringList = Arrays.asList("1", "2", "", "a");
 4         List<String> list = filter(stringList, (String s) -> !s.isEmpty());
 5         forEach(list, (String s) -> System.out.println(s));
 6     }
 7 
 8     public static <T> List<T> filter(List<T> list, Predicate<T> p) {
 9         List<T> result = new ArrayList<>();
10         for (T t : list) {
11             if (p.test(t)) {
12                 result.add(t);
13             }
14         }
15         return result;
16     }
17     public static <T> void forEach(List<T> list, Consumer<T> c){
18         for(T t : list){
19             c.accept(t);
20         }
21     }
22 }

(3).Function

  java.uil.functin.function<T, R> 接口定义了一个叫作apply的方法，它接收一个泛型T的对象，并且返回一个泛型R的对象。如果你需要定义一个Lambda，将输入的对象的信息映射到输出，就可以使用这个接口(比如提取苹果的重量，火把字符串映射为它的长度)。在下面的代码中，我们向你展示如何利用它来创建一个map方法，以将String列表映射到包含每个String长度的Integer集合中。

public class Demo4 {
    public static void main(String[] args) {
        List<Integer> list = map(Arrays.asList("lambda", "java", "c++"), (String s) -> s.length());
        for(Integer i : list){
            System.out.println(i);
        }
    }
    public static <T, R> List<R> map(List<T> list, Function <T, R> f){
        List<R> result = new ArrayList<>();
        for(T t : list){
            result.add(f.apply(t));
        }
        return result;
    }
}

2.原始类型特化

 我们介绍了三个泛型函数式接口：Predicate<T>、Consumer<T>和Function<T, R>。还有些函数式接口专为某些类而设计。

  回顾一下:Java类型要么是引用类型(比如Byte、Integer、Object、List等等)，要么是原始类型(比如int、double、byte、char)。但是泛型(比如Consumer<T> 中的T)只能绑定到引用类型。这是由于泛型内部的实现方式造成的。因此，在Java里有一个将原始类型转换为对应的引用类型的机制。这个机制叫做装箱(boxing)。相反的操作，也就是将引用类型转换为对应的原始类型，叫做拆箱(unboxing)。Java还有一个自动装箱机制来帮助程序员执行这个任务：装箱和拆箱都是自动完成的。比如，这就是为什么下面的代码是有效的(一个int类型被装箱为Integer):

1         List<Integer> list = new ArrayList<>();
2         for(int i = 0; i < 10; i++){
3             list.add(i);
4         }

但是这个在性能方面是要付出代价额。装箱后的值本质上就是把原始类型包裹起来，并且保存在堆里。因此装箱后的值需要更多的内存，并且需要额外的内存搜索来获取被包裹的原始值。

  Java8为我们前面所说的函数式接口带来了专门的版本，以便在输入和输出都是原始类型是避免自动装箱的操作。比如下面的代码中，使用IntPredicate就避免了对值1000进行装箱操作，但要是用Predicate<Integer>就会把参数1000装箱到一个Integer对象中：

1         IntPredicate evenNumbers = (int i) -> i % 2 == 0;
2         evenNumbers.test(1000);
3         
4         Predicate<Integer> oddNumbers = (Integer i) -> i % 2== 0;
5         oddNumbers.test(1000);

 一般来说，针对专门的输入参数类型的函数式接口的名称都要加上对应的原始数据类型前缀，比如DoublePredicate、IntConsumer、LongBinaryOperator、IntFunction等等。Function接口还有针对输出类型参数类型的变种：ToIntFunction<T>、IntToDoubleFunction等等。

  下表中总结了Java API中提供的最常用的函数式接口及其函数描述符， 表的右侧代表了参数类型。请记得这个只是一个起点。如果有需要，你可以自己设计一个。请记住，(T, U) -> R 的表达式展示了应当如何思考一个函数描述符，这里它代表一个函数， 具有两个参数，分别为T和U，返回类型为R。

Java8中的常用函数式接口

函数式接口	函数描述符	原始类型特换
Predicate<T>	T -> boolean	IntPredicate, LongPredicate, DoublePredicate
Consumer<T>	T->void	IntConsumer, LongConsumer,DoubleConsumer
Function<T,R>	T -> R	IntFunction<R>,IntToDoubleFunction, IntToLongFunction,LongFunction<R>, LongToDoubleFunction,LongToIntFunction, DoubleFunction<R>,ToIntFunction<T>, ToDoubleFunction<T>,ToLongFunction<T>
Supplier<T>	() ->T	BooleanSupplier,IntSupplier, LongSupplier, DoubleSupplier
UnaryOperator<T>	T -> T	IntUnaryOPerator, LongUnaryOperator, DoubleUnaryOPerator
BinaryOPerator<T>	(T, T) -> T	IntBinaryOPerator,LongBinaryOperator DoubleBinaryOperator
BiPredicate<L, R>	(L, R)->boolean
BiConsumer<T, U>	(T, U) -> void	ObjIntConsumer<T>, ObjLongConsumer<T>, ObjDoubleConsumer<T>
BiFunction<T, U, R>	(T, U) -> R	ToIntBiFunction<T, U>, ToLongBiFunction<T, U> ToDoubleBiFunction<T, U>

为了总结关于函数式接口和Lambda的讨论，下表总结了一些使用案例、Lambda的例子，以及可以使用的函数式接口

Lambda及函数式接口的例子

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

3.异常、Lambda，还有函数式接口又是怎么回事呢？

  请注意，任何函数式接口都不允许抛出受查异常(checked exception)。如果你需要Lambda表达式来抛出异常，有两种方法：定义一个自己的函数式接口，并且声明受查异常，或者把Lambda包在try/catch块中。

  比如，之前我们定义了一个函数式接口BufferedReaderProcessor，它就是现实声明了一个IOException:

1 public interface BufferedReaderProcessor {
2     String process(BufferedReader b) throws IOException;
3 }

  但是你可能是在使用一个接收函数式接口的API，比如Function<T, R>, 没有办法自己创建一个。这种情况下，你可显式捕捉受查异常：

1         Function<BufferedReader, String> f = (BufferedReader b) -> {
2             try {
3                 return b.readLine();
4             } catch (IOException e) {
5                 throw new RuntimeException();
6             }
7         };