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

2023-12-18 06:22:03

前言:

本博客对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 实战》

文章来源:https://blog.csdn.net/u012895183/article/details/135052209
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。