java8实战 lambda表达式和函数式接口(上)

前言：

本博客对java8实战第三章的总结，也是上一篇博客行为化参数的延续，介绍一下函数式接口

Lambda表达式

?lambda的表达式的结构由：参数，箭头，主体构成。

lambda示例

函数式接口：

先看上一篇博文最后一个例子如下：，用lambda例子来筛选苹果，其中仓库inventory包含了很多苹果Apple对象list，然后再根据red条件筛选红色苹果，我们对筛选的这个行为进行行为参数化，其中Predicate<T> p，这个就是一个函数式接口。

public interface Predicate<T> {
    boolean test(T t);
}

public static <T> List<T> filter(<List<T> list, Predicate<T> p){
    List<T> result = new ArrayList<>();
    for(T e: list){
        if(p.test(e)){
            result.add(e);
        }        
    }
}


List<Apple> redAndHeavyApple = 
    filterApples(inventory, (Apple apple) -> "red".equals(apple.getColor()));

什么是函数式接口？简单来说，就是定义一个抽象方法的接口，如上面Predicate接口里面定义了一个抽象方法test，它就是函数式接口，就是这么简单。

那么函数式接口可以用来做什么？Lambda表示式允许你直接以内联形形式为函数式接口的抽象方法提供实现，并把整个表达式作为函数式接口的实例。简单来说，Lambda就是一个函数式接口的具体实现，而lambda主体部分就是函数式接口的抽象方法。

它的效果类似这样，以“等号”分割线的上下两部分一样的效果，而可以看到lambda表达式更简洁。

List<Apple> redAndHeavyApple = 
    filterApples(inventory, (Apple apple) -> "red".equals(apple.getColor()));
===============================================
public class AppleRedPredicate implements Predicate {
    public boolean test(Apple apple) {
        return "red".equals(apple.getColor();
    }
}

List<Apple> redAndHeavyApple = 
    filterApples(inventory, new AppleRedAndHeavyPredicate());

Java?API也有其他的函数式接口：

public interface Comparator<T> {
    int compare(T o1, To2);
}

public interface Runnable {
    void run();
}


public interface ActionListener extends EventListener{
    void actionPerformed(ActionEvent e);
}

public interface Callable<V>{
    V call();
}

public interface PrivilegedAction<V>{
    T run();
}

当前前面那个Predicate<T>接口也是.

如何使用lambda和函数式接口

书本举了一个"环绕执行模式"例子，环绕执行模式，在我看来就是，所有行为都是围绕执行处理过程，比如资源处理时候，打开一个资源（数据库或者文件），然后做一些处理，然后关闭操作，这过程中，中间这段处理过程就是重点。

如下，有一段代码式打开某个文件，并且读取一行并返回

public static String processFile() throws IOException{
    try (BufferdReader br = new BufferdReader(new FileReader("data.txt"))){
        return br.readLine();
    }
}

这段代码式有局限的，就如第一篇博客所说，需求式不断变化的，如果需求改为读取两行，或者返回使用最频繁的词，那上面代码无法满足，那么一种就是不断创建新函数，每种函数处理不同情况，还有一种保持一个处理函数，但是处理函数的入参是行为参数，处理函数统一处理不同行为参数，也就是说处理的行为，体现在参数上，如使用lambda表达式来体现行为参数：

String result = processFile((BufferedReader br) -> br.readLine() + br.readLine());

那么对应的，processFile入参就是函数式接口，所以还需要创建一个能匹配BufferReader->String的函数式接口：

@FunctionalInterface
public interface BufferedReaderProcessor {
    String process(BufferedReader b) throws IOException;
}

然后processFile就变成了

public static String processFile(BufferedReaderProcessor p) throws IOException{
    try (BufferdReader br = new BufferdReader(new FileReader("data.txt"))){
        return p.process(br);
    }
}

因此我们就得到一个很灵活的processFile，通过用lambda表达式来表达不同的行为：

读取一行：

String result = processFile((BufferedReader br) -> br.readLine());

读取两行：?

String result = processFile((BufferedReader br) -> br.readLine() + br.readLine());

第三章剩下的部分下一篇博客继续讲。我个人感觉这种方式很灵活，我认为它也不是完全完美，其一就是要求行为参数代码量得少，个人感觉不适宜lambda写太多行为代码，我认为如果行为太过复杂反而用不同类来实现函数式接口，将入参变为不同类对象，反而代码可读性更好些。

参考文献：

?《java8 实战》