Java函数式编程原理以及应用

一. 函数式编程

Java8所有的新特性基本基于函数式编程的思想,函数式编程的带来,给Java注入了新鲜的活力。

下面来近距离观察一下函数式编程的几个特点:

函数可以作为变量、参数、返回值和数据类型。

基于表达式来替代方法的调用

函数无状态,可以并发和独立使用

函数无副作用,不会修改外部的变量

函数结果确定性;同样的输入,必然会有同样的结果。

下面jdk1.8里面对函数式编程的定义。只是一个  FunctionalInterface 接口特别的简单。

1 @Documented 2 @Retention(RetentionPolicy.RUNTIME) 3 @Target(ElementType.TYPE) 4 public @interface FunctionalInterface {}

这个函数式接口有几点以下的限制:

唯一的抽象方法,有且仅有一个 (即所有的函数式接口,有且只能有一个抽象方法)

加上标注,则会触发JavaCompiler的检查。对于符合函数接口的接口,加不加都无关紧要,但是加上则会提供一层编译检查的保障。如果不符合,则会报错。 

不能被覆盖之后,再声明为抽象方法,则不算抽象方法。例如接口实现了Object中的方法。 

可用于lambda类型的使用方式 

二. Java8新增函数式接口

Stream的操作是建立在函数式接口的组合之上的。Java8中新增的函数式接口都在java.util.function包下。这些函数式接口可以有多种分类方式。

2.1 Function

Function是从T到R的一元映射函数。将参数T传递给一个函数,返回R。即R = Function(T)

Function最常用的应该是  <R> Stream<R> map(Function<? super T, ? extends R> mapper);

比如List<Person> person里面有age,name.... 我传入age,他就会返回age的集合给我。

@FunctionalInterface
public interface Function<T, R> {

R apply(T t);

default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

static <T> Function<T, T> identity() {
        return t -> t;
    }
}

2.2 Predicate

Predicate是一个谓词函数,主要作为一个谓词演算推导真假值存在,返回布尔值的函数。Predicate等价于一个Function的boolean型返回值的子集。

predicate最常用的莫过于  Stream<T> filter(Predicate<? super T> predicate); 

比如我要过滤年龄 > 18 的人,我传入age,判断是否为true。为true则保留,false丢弃。

@FunctionalInterface
public interface Predicate<T> {

boolean test(T t);

default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

default Predicate<T> negate() {
        return (t) -> !test(t);
    }

default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }

static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

2.3 Consumer

Consumer是从T到void的一元函数,接受一个入参但不返回任何结果的操作。

Consumer最常用的肯定是   default void forEach(Consumer<? super T> action) {}

这是一段forEach循环的代码,传入实现的方法,并不返回任何值。只是循环。

@FunctionalInterface
public interface Consumer<T> {

void accept(T t);

default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

三. Lambda表达式 3.1 基本语法

Lambda 的基本结构为 (arguments) -> body,有如下几种情况:

参数类型可推导时,不需要指定类型,如 (a) -> System.out.println(a)

当只有一个参数且类型可推导时,不强制写 (), 如 a -> System.out.println(a)

参数指定类型时,必须有括号,如 (int a) -> System.out.println(a)

参数可以为空,如 () -> System.out.println(“hello”)

body 需要用 {} 包含语句,当只有一条语句时 {} 可省略

3.2 Lambda原理

比如如下代码:

List<Integer> list = new ArrayList<>();

list.stream().filter((x) -> x >= 18)

Stream<T> filter(Predicate<? super T> predicate);

@FunctionalInterface
public interface Predicate<T> {

boolean test(T t);

}

比如List里面存个个人的年龄,现在筛选出年龄大于等于18的人。

此时我们就可以用  list.stream().filter((x) -> x >= 18)   这就是一个典型的lambda表达式

(x) -> x >= 18 传给  Predicate 函数式接口。

原理其实是:

JVM帮我们动态生成了一个内部类,然后这个内部类实现了 Predicate 这个函数式接口。

重写了里面的test方法。生成的类似如下:

static final class Main$$Lambda$1 implements Predicate<Integer> {
    private Main$$Lambda$1() {
    }

@Override
    public boolean test(Integer x) {
        return x >= 18;
    }
}

3.3 Lambda用法

public class Main {
    public static void main(String[] args) {

内容版权声明:除非注明,否则皆为本站原创文章。

转载注明出处:https://www.heiqu.com/2b4f380f42940681eb2650263aa79e4b.html