Java如何支持函数式编程？，带你彻底弄明白

最新推荐文章于 2024-07-23 15:58:39 发布

前端漫画书

最新推荐文章于 2024-07-23 15:58:39 发布

阅读量674

点赞数 12

分类专栏： Java程序员面试文章标签： java python 开发语言

本文链接：https://blog.csdn.net/m0_61549353/article/details/136696034

版权

Java程序员面试专栏收录该内容

7 篇文章 0 订阅

订阅专栏

@Override

public Integer apply(String s) {

return s.length();

}

})

.filter(new Predicate() {

@Override

public boolean test(Integer l) {

return l <= 3;

}

})

.max(new Comparator() {

@Override

public int compare(Integer o1, Integer o2) {

return o1 - o2;

}

});

Lambda表达式与匿名类的异同集中体现在以下三点上：

Lambda就是为了优化匿名内部类而生，Lambda要比匿名类简洁的多得多。
Lambda仅适用于函数式接口，匿名类不受限。
即匿名类中的this是“匿名类对象”本身;Lambda表达式中的this是指“调用Lambda表达式的对象”。

函数接口

实际上，上面一段代码中的Function、Predicate、Comparator都是函数接口。我们知道，C语言支持函数指针，它可以把函数直接当变量来使用。

但是，Java没有函数指针这样的语法。所以它通过函数接口，将函数包裹在接口中，当作变量来使用。实际上，函数接口就是接口。不过，它也有自己特别的地方，那就是要求只包含一个未实现的方法。因为只有这样，Lambda表达式才能明确知道匹配的是哪个方法。如果有两个未实现的方法，并且接口入参、返回值都一样，那Java在翻译Lambda表达式的时候，就不知道表达式对应哪个方法了。

函数式接口也是Java interface的一种，但还需要满足：

一个函数式接口只有一个抽象方法(single abstract method);
Object类中的public abstract method不会被视为单一的抽象方法;
函数式接口可以有默认方法和静态方法;
函数式接口可以用@FunctionalInterface注解进行修饰。

满足这些条件的interface，就可以被视为函数式接口。例如Java 8中的Comparator接口：

@FunctionalInterface

public interface Comparator {

/**

* single abstract method

* @since 1.8

int compare(T o1, T o2);

/**

* Object类中的public abstract method

* @since 1.8

boolean equals(Object obj);

/**

* 默认方法

* @since 1.8

default Comparator reversed() {

return Collections.reverseOrder(this);

}

/**

* 静态方法

* @since 1.8

public static <T extends Comparable<? super T>> Comparator reverseOrder() {

return Collections.reverseOrder();

}

//省略…

}

函数式接口有什么用呢?一句话，函数式接口带给我们最大的好处就是：可以使用极简的lambda表达式实例化接口。为什么这么说呢?我们或多或少使用过一些只有一个抽象方法的接口，比如Runnable、ActionListener、Comparator等等，比如我们要用Comparator实现排序算法，我们的处理方式通常无外乎两种：

规规矩矩的写一个实现了Comparator接口的Java类去封装排序逻辑。若业务需要多种排序方式，那就得写多个类提供多种实现，而这些实现往往只需使用一次。
另外一种聪明一些的做法无外乎就是在需要的地方搞个匿名内部类，比如：

public class Test {

public static void main(String args[]) {

List persons = new ArrayList();

Collections.sort(persons, new Comparator(){

@Override

public int compare(Person o1, Person o2) {

return Integer.compareTo(o1.getAge(), o2.getAge());

}

});

}

匿名内部类实现的代码量没有多到哪里去，结构也还算清晰。Comparator接口在Jdk 1.8的实现增加了FunctionalInterface注解，代表Comparator是一个函数式接口，使用者可放心的通过lambda表达式来实例化。那我们来看看使用lambda表达式来快速new一个自定义比较器所需要编写的代码：

Comparator comparator = (p1, p2) -> Integer.compareTo(p1.getAge(), p2.getAge());

-> 前面的 () 是Comparator接口中compare方法的参数列表，-> 后面则是compare方法的方法体。

下面将Java提供的Function、Predicate这两个函数接口的源码，摘抄如下：

@FunctionalInterface

public interface Function<T, R> {

R apply(T t); // 只有这一个未实现的方法

default Function<V, R> compose(Function<? super V, ? extends T> before) {

Objects.requireNonNull(before);

return (V v) -> apply(before.apply(v));

}

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

Objects.requireNonNull(after);

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

}

static Function<T, T> identity() {

return t -> t;

}

@FunctionalInterface

public interface Predicate {

boolean test(T t); // 只有这一个未实现的方法

default Predicate and(Predicate<? super T> other) {

Objec 需要zi料+ 绿色徽【vip1024b】

ts.requireNonNull(other);

return (t) -> test(t) && other.test(t);

}

default Predicate negate() {

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

}

default Predicate or(Predicate<? super T> other) {

Objects.requireNonNull(other);

return (t) -> test(t) || other.test(t);

}

static Predicate isEqual(Object targetRef) {

return (null == targetRef)

? Objects::isNull

: object -> targetRef.equals(object);

}

@FunctionalInterface注解使用场景

我们知道，一个接口只要满足只有一个抽象方法的条件，即可以当成函数式接口使用，有没有 @FunctionalInterface 都无所谓。但是jdk定义了这个注解肯定是有原因的，对于开发者，该注解的使用一定要三思而后续行。

如果使用了此注解，再往接口中新增抽象方法，编译器就会报错，编译不通过。换句话说，@FunctionalInterface 就是一个承诺，承诺该接口世世代代都只会存在这一个抽象方法。因此，凡是使用了这个注解的接口，开发者可放心大胆的使用Lambda来实例化。当然误用 @FunctionalInterface 带来的后果也是极其惨重的：如果哪天你把这个注解去掉，再加一个抽象方法，则所有使用Lambda实例化该接口的客户端代码将全部编译错误。
特别地，当某接口只有一个抽象方法，但没有用 @FunctionalInterface 注解修饰时，则代表别人没有承诺该接口未来不增加抽象方法，所以建议不要用Lambda来实例化，还是老老实实的用以前的方式比较稳妥。
小结