转载

深入探寻JAVA8 part2：浅谈几个内置的函数式接口

前情提要

深入探寻JAVA8 part1：函数式编程与Lambda表达式

看此文前，不熟悉函数式编程和Lambda表达式的可以先看一下上文回忆一下。

本文将会简单介绍Java8中内置的一些函数式接口

回顾函数式接口

函数式接口就是只定义一个抽象方法的接口。在JAVA8以前，就有很多符合函数式接口定义的接口。

//比较器
public interface Comparator<T> {
    int compare(T o1, T o2);
}

//多线程接口
public interface Runnable{
    void run();
}

因为JAVA8中还引入了默认方法的概念，所以即使接口中有多个默认方法，只要接口之定义了一个抽象方法，就满足函数式接口的定义。

JAVA8中对这些可以定义为函数式接口的接口加了一个 @FuncationalInterface 注解。如果一个接口中定义了多个抽象方法，又添加了这个注解，则会在编译时抛出错误提示。

Consumer

package java.util.function;

import java.util.Objects;

@FunctionalInterface
public interface Consumer<T> {
   
    void accept(T var1);

    default Consumer<T> andThen(Consumer<? super T> var1) {
        Objects.requireNonNull(var1);
        return (var2) -> {
            this.accept(var2);
            var1.accept(var2);
        };
    }
}

这是JAVA8中对Consumer的定义，该函数式接口可以接收一个T类型的数据，并对该数据进行操作。JDK中一个典型的例子是forEach中对Consumer的使用，下面给出了ArrayList中的forEach源码。

@Override
  public void forEach(Consumer<? super E> consumer) {
    checkNotNull(consumer);
    for (E e : array) {
      consumer.accept(e);
    }
  }

forEach的接口定义中传入了一个Consumer接口，并且调用Consumer的accept方法对数组中的每个元素进行处理。加入这是一个String数组，则可以使用如下的方式进行调用

list.forEach((String s) -> System.out::println);

在Consumer的接口定义中，还有一个andThen的默认方法，后面会再介绍一下这个默认方法。

因为Consumer这个接口使用了泛型，因此只能使用基础类型的封箱类型，如Integer，Long等。如果是对基础类型的元素进行处理，可能会出现大量的封箱拆箱的操作，造成性能损耗。为了解决这个问题，JAVA也提供了基础类型的对应的Consumer接口，如IntConsumer：

@FunctionalInterface
public interface IntConsumer {

    void accept(int value);

    
    default IntConsumer andThen(IntConsumer after) {
        Objects.requireNonNull(after);
        return (int t) -> { accept(t); after.accept(t); };
    }
}

Predicate

@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);
    }

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

Predicate函数式接口定义了test抽象方法，它会对T对象执行判断逻辑，并返回布尔类型的判断接口。

还是以ArrayList中的一个使用场景为例。ArrayList中提供了一个removeIf方法，该方法传入了Predicate接口，并利用该接口判断是否要删除这个对象：

public boolean removeIf(Predicate<? super E> filter) {
    checkNotNull(filter);

    E[] newArray = null;
    int newIndex = 0;
    for (int index = 0; index < array.length; ++index) {
      E e = array[index];

      //使用Predicate的test方法判断是否要删除该对象
      if (filter.test(e)) {
        if (newArray == null) {
          newArray = ArrayHelper.clone(array, 0, index);
          newIndex = index;
        }
      } else if (newArray != null) {
        newArray[newIndex++] = e;
      }
    }

    if (newArray == null) {
      return false;
    }
    array = newArray;
    return true;
  }

当然了，同Consumer一样，它也提供了很多可以传入基础类型的Predicate接口，如IntPredicate，DoublePredicate等

Function

@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;
    }
}

Function中定义了apply抽象方法，该抽象方法会接受一个T类型的对象，并转化为R类型的对象返回。使用方法和上面也没啥区别，这里就不具体赘述了。当然了，Function也为基础类型做了很多扩展，比如IntToDoubleFunction就可以将int转化为double型，还有ToDoubleFunction<T>则支持将T对象转化为double基础型。

复合Lambda表达式

复合Lambda表达式是指将多个同类型的Lambda表达式按照一定语法进行组合，生成新的Lambda表达式。以比较基础的Predicate作为例子。Predicate中有以下几个默认方法： and,negate,or ，分别对应与，否定和或。

举个例子，现在有两个Predicate分别是判断订单的状态是否为已支付以及订单的实付金额是否大于100。两个Predicate如下：

Predicate<Order> p1 = (Order o) -> o.isPaid;
Predicate<Order> p2 = (Order o) -> o.actualFee > 100;

假如现在想要判断是已支付且实付金额大于100的订单，则新的Predicate可以通过上面两个Predicate组合生成，利用and默认方法：

Predicate<Order> p3 = p1.and(p2);

原文 https://segmentfault.com/a/1190000020686252

正文到此结束

所属分类：编程技术 Java

本文标签： tar value IO App 函数式编程 https 多线程 ACE 源码 IDE 删除编译数据 http lambda java UI entity equals cat consumer ArrayList 线程 list id
版权声明： 本文为互联网转载文章，出处已在文章中说明(部分除外)。如果侵权，请联系本站长删除，谢谢。
本文海报： 生成海报一生成海报二

其他链接

关于本站

本站定位：个人技术类博客

本站作用：写博客、记日志、闲聊扯淡鼓捣技术。

问题交流

深入探寻JAVA8 part2：浅谈几个内置的函数式接口

前情提要

回顾函数式接口

Consumer

Predicate

Function

复合Lambda表达式

热门推荐

相关文章

说给你听

本文目录

随机标签

书籍教程

近期评论

网站信息

其他链接

关于本站

问题交流