Java8中怎么利用Stream实现函数式接口

这期内容当中小编将会给大家带来有关Java8中怎么利用Stream实现函数式接口，文章内容丰富且以专业的角度为大家分析和叙述，阅读完这篇文章希望大家可以有所收获。

创新互联公司是一家专注于做网站、成都网站制作与策划设计,南城网站建设哪家好?创新互联公司做网站,专注于网站建设10多年,网设计领域的专业建站公司;建站业务涵盖:南城等地区。南城做网站价格咨询:028-86922220

函数式接口

什么是函数式接口？简单来说就是只有一个抽象函数的接口。为了使得函数式接口的定义更加规范，java8 提供了@FunctionalInterface 注解告诉编译器在编译器去检查函数式接口的合法性，以便在编译器在编译出错时给出提示。为了更加规范定义函数接口，给出如下函数式接口定义规则：

•  有且仅有一个抽象函数

•  必须要有@FunctionalInterface 注解

•  可以有默认方法

可以看出函数式接口的编写定义非常简单，不知道大家有没有注意到，其实我们经常会用到函数式接口，如Runnable 接口，它就是一个函数式接口：

@FunctionalInterface  public interface Runnable {      /**       * When an object implementing interface Runnable is used       * to create a thread, starting the thread causes the object's       * run method to be called in that separately executing       * thread.       * 
       * The general contract of the method run is that it may       * take any action whatsoever.       *       * @see     java.lang.Thread#run()       */      public abstract void run();  }

过去我们会使用匿名内部类来实现线程的执行体：

new Thread(new Runnable() {              @Override              public void run() {                  System.out.println("Hello FunctionalInterface");              }          }).start();

现在我们使用Lambda 表达式，这里函数式接口的使用没有体现函数式编程思想，这里输出字符到标准输出流中，产生了副作用，起到了简化代码的作用，当然还有装B。

new Thread(()->{             System.out.println("Hello FunctionalInterface");         }).start();

Java8 util.function 包下自带了43个函数式接口，大体分为以下几类：

•  Consumer 消费接口

•  Function 功能接口

•  Operator 操作接口

•  Predicate 断言接口

•  Supplier 生产接口

其他接口都是在此基础上变形定制化罢了。

函数式接口详细介绍

这里只介绍最基础的函数式接口，至于它的变体只要明白了基础自然就能够明白。前篇：玩转Java8中的 Stream 之从零认识 Stream

Consumer

消费者接口，就是用来消费数据的。

@FunctionalInterface  public interface Consumer {      /**       * Performs this operation on the given argument.       *       * @param t the input argument       */      void accept(T t);      /**       * Returns a composed {@code Consumer} that performs, in sequence, this       * operation followed by the {@code after} operation. If performing either       * operation throws an exception, it is relayed to the caller of the       * composed operation.  If performing this operation throws an exception,       * the {@code after} operation will not be performed.       *       * @param after the operation to perform after this operation       * @return a composed {@code Consumer} that performs in sequence this       * operation followed by the {@code after} operation       * @throws NullPointerException if {@code after} is null       */      default Consumer andThen(Consumer after) {          Objects.requireNonNull(after);          return (T t) -> { accept(t); after.accept(t); };      }  }

Consumer 接口中有accept 抽象方法，accept接受一个变量，也就是说你在使用这个函数式接口的时候，给你提供了数据，你只要接收使用就可以了；andThen 是一个默认方法，接受一个Consumer 类型，当你对一个数据使用一次还不够爽的时候，你还能再使用一次，当然你其实可以爽无数次，只要一直使用andThan方法。

Function

何为Function呢？比如电视机，给你带来精神上的愉悦，但是它需要用电啊，电视它把电转换成了你荷尔蒙，这就是Function，简单电说，Function 提供一种转换功能。

@FunctionalInterface  public interface Function {      /**       * Applies this function to the given argument.       *       * @param t the function argument       * @return the function result       */      R apply(T t);      /**       * Returns a composed function that first applies the {@code before}       * function to its input, and then applies this function to the result.       * If evaluation of either function throws an exception, it is relayed to       * the caller of the composed function.       *       * @param  the type of input to the {@code before} function, and to the       *           composed function       * @param before the function to apply before this function is applied       * @return a composed function that first applies the {@code before}       * function and then applies this function       * @throws NullPointerException if before is null       *       * @see #andThen(Function)       */      default  Function compose(Function before) {          Objects.requireNonNull(before);          return (V v) -> apply(before.apply(v));      }      /**       * Returns a composed function that first applies this function to       * its input, and then applies the {@code after} function to the result.       * If evaluation of either function throws an exception, it is relayed to       * the caller of the composed function.       *       * @param  the type of output of the {@code after} function, and of the       *           composed function       * @param after the function to apply after this function is applied       * @return a composed function that first applies this function and then       * applies the {@code after} function       * @throws NullPointerException if after is null       *       * @see #compose(Function)       */      default  Function andThen(Function after) {          Objects.requireNonNull(after);          return (T t) -> after.apply(apply(t));      }      /**       * Returns a function that always returns its input argument.       *       * @param  the type of the input and output objects to the function       * @return a function that always returns its input argument       */      static  Function identity() {          return t -> t;      }  }

Function 接口 最主要的就是apply 函数，apply 接受T类型数据并返回R类型数据，就是将T类型的数据转换成R类型的数据，它还提供了compose、andThen、identity 三个默认方法，compose 接受一个Function，andThen也同样接受一个Function，这里的andThen 与Consumer 的andThen 类似，在apply之后在apply一遍，compose 则与之相反，在apply之前先apply（这两个apply具体处理内容一般是不同的），identity 起到了类似海关的作用，外国人想要运货进来，总得交点税吧，然后货物才能安全进入中国市场，当然了想不想收税还是你说了算的:。

Operator

可以简单理解成算术中的各种运算操作，当然不仅仅是运算这么简单，因为它只定义了运算这个定义，但至于运算成什么样你说了算。由于没有最基础的Operator，这里将通过 BinaryOperator、IntBinaryOperator来理解Operator 函数式接口，先从简单的IntBinaryOperator开始。

IntBinaryOperator

从名字可以知道，这是一个二元操作，并且是Int 类型的二元操作，那么这个接口可以做什么呢，除了加减乘除，还可以可以实现平方（两个相同int 数操作起来不就是平方吗），还是先看看它的定义吧：

@FunctionalInterface  public interface IntBinaryOperator {      /**       * Applies this operator to the given operands.      *       * @param left the first operand      * @param right the second operand       * @return the operator result       */      int applyAsInt(int left, int right);  }

IntBinaryOperator 接口内只有一个applyAsInt 方法，其接收两个int 类型的参数，并返回一个int 类型的结果，其实这个跟Function 接口的apply 有点像，但是这里限定了，只能是int类型。

BinaryOperator

BinaryOperator 二元操作，看起来它和IntBinaryOperator 是父子关系，实际上这两者没有半点关系，但他们在功能上还是有相似之处的：

@FunctionalInterface  public interface BinaryOperator extends BiFunction {      /**       * Returns a {@link BinaryOperator} which returns the lesser of two elements       * according to the specified {@code Comparator}.      *       * @param  the type of the input arguments of the comparator       * @param comparator a {@code Comparator} for comparing the two values       * @return a {@code BinaryOperator} which returns the lesser of its operands,       *         according to the supplied {@code Comparator}       * @throws NullPointerException if the argument is null       */      public static  BinaryOperator minBy(Comparator comparator) {          Objects.requireNonNull(comparator);          return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;      }      /**       * Returns a {@link BinaryOperator} which returns the greater of two elements       * according to the specified {@code Comparator}.       *       * @param  the type of the input arguments of the comparator       * @param comparator a {@code Comparator} for comparing the two values       * @return a {@code BinaryOperator} which returns the greater of its operands,       *         according to the supplied {@code Comparator}       * @throws NullPointerException if the argument is null       */      public static  BinaryOperator maxBy(Comparator comparator) {          Objects.requireNonNull(comparator);          return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;      }  }

BinaryOperator 是 BiFunction 生的，而IntBinaryOperator 是从石头里蹦出来的，BinaryOperator 自身定义了minBy、maxBy默认方法，并且参数都是Comparator，就是根据传入的比较器的比较规则找出最小最大的数据。

Predicate

断言、判断，对输入的数据根据某种标准进行评判，最终返回boolean值：

@FunctionalInterface  public interface Predicate {      /**       * Evaluates this predicate on the given argument.       *      * @param t the input argument       * @return {@code true} if the input argument matches the predicate,       * otherwise {@code false}       */      boolean test(T t);      /**       * Returns a composed predicate that represents a short-circuiting logical       * AND of this predicate and another.  When evaluating the composed       * predicate, if this predicate is {@code false}, then the {@code other}       * predicate is not evaluated.       *       * 
Any exceptions thrown during evaluation of either predicate are relayed       * to the caller; if evaluation of this predicate throws an exception, the       * {@code other} predicate will not be evaluated.       *       * @param other a predicate that will be logically-ANDed with this       *              predicate       * @return a composed predicate that represents the short-circuiting logical       * AND of this predicate and the {@code other} predicate       * @throws NullPointerException if other is null       */      default Predicate and(Predicate other) {          Objects.requireNonNull(other);          return (t) -> test(t) && other.test(t);      }      /**       * Returns a predicate that represents the logical negation of this       * predicate.       *       * @return a predicate that represents the logical negation of this       * predicate       */      default Predicate negate() {          return (t) -> !test(t);      }      /**       * Returns a composed predicate that represents a short-circuiting logical       * OR of this predicate and another.  When evaluating the composed       * predicate, if this predicate is {@code true}, then the {@code other}       * predicate is not evaluated.       *       * 
Any exceptions thrown during evaluation of either predicate are relayed       * to the caller; if evaluation of this predicate throws an exception, the       * {@code other} predicate will not be evaluated.       *       * @param other a predicate that will be logically-ORed with this       *              predicate       * @return a composed predicate that represents the short-circuiting logical       * OR of this predicate and the {@code other} predicate       * @throws NullPointerException if other is null       */      default Predicate or(Predicate other) {          Objects.requireNonNull(other);          return (t) -> test(t) || other.test(t);      }      /**       * Returns a predicate that tests if two arguments are equal according       * to {@link Objects#equals(Object, Object)}.       *       * @param  the type of arguments to the predicate       * @param targetRef the object reference with which to compare for equality,       *               which may be {@code null}       * @return a predicate that tests if two arguments are equal according       * to {@link Objects#equals(Object, Object)}       */      static  Predicate isEqual(Object targetRef) {          return (null == targetRef)                  ? Objects::isNull                  : object -> targetRef.equals(object);      }  }

Predicate的test 接收T类型的数据，返回 boolean 类型，即对数据进行某种规则的评判，如果符合则返回true，否则返回false；Predicate接口还提供了 and、negate、or，与 取反 或等，isEqual 判断两个参数是否相等等默认函数。

Supplier

生产、提供数据：

@FunctionalInterface  public interface Supplier {      /**       * Gets a result.       *       * @return a result       */      T get();  }

非常easy，get方法返回一个T类数据，可以提供重复的数据，或者随机种子都可以，就这么简单。

函数式接口实战

Consumer

Consumer 用的太多了，不想说太多，如下：

public class Main {      public static void main(String[] args) {        Stream.of(1,2,3,4,5,6)                  .forEach(integer -> System.out.println(integer)); //输出1，2，3，4，5，6      }  }

这里使用标准输出，还是产生了副作用，但是这种程度是可以允许的

Function

1.转换，将字符串转成长度

public class Main {      public static void main(String[] args) {         Stream.of("hello","FunctionalInterface")                  .map(e->e.length())                  .forEach(System.out::println);      }  }

2.运算

public class FunctionTest {      public static void main(String[] args) {           public static void main(String[] args) {          Function square = integer -> integer * integer; //定义平方运算          List list = new ArrayList<>();          list.add(1);          list.add(2);          list.add(3);          list.add(4);         list.stream()                  .map(square.andThen(square)) //四次方                  .forEach(System.out::println);         System.out.println("------");          list.stream()                  .map(square.compose(e -> e - 1)) //减一再平方                  .forEach(System.out::println);          System.out.println("------");          list.stream().map(square.andThen(square.compose(e->e/2))) //先平方然后除2再平方                  .forEach(System.out::println);      }  }

结果如图：

Operator

1.BinaryOperator

这里实现找最大值：

public class BinaryOperatorTest {      public static void main(String[] args) {          Stream.of(2,4,5,6,7,1)                  .reduce(BinaryOperator.maxBy(Comparator.comparingInt(Integer::intValue))).ifPresent(System.out::println);      }  }

Comparator 后期会讲到

2.IntOperator

这里实现累加功能：

public class BinaryOperatorTest {      public static void main(String[] args) {          IntBinaryOperator intBinaryOperator = (e1, e2)->e1+e2; //定义求和二元操作          IntStream.of(2,4,5,6,7,1)                  .reduce(intBinaryOperator).ifPresent(System.out::println);      }  }

Predicate

筛选出大于0最小的两个数

public class Main {      public static void main(String[] args) {          IntStream.of(200,45,89,10,-200,78,94)                  .filter(e->e>0) //过滤小于0的数                  .sorted() //自然顺序排序                  .limit(2) //取前两个                  .forEach(System.out::println);      }  }

Supplier

这里一直生产2这个数字，为了能停下来，使用limit

public class Main {      public static void main(String[] args) {          Stream.generate(()->2)                  .limit(10)                  .forEach(System.out::println);      }  }

如图：

上述就是小编为大家分享的Java8中怎么利用Stream实现函数式接口了，如果刚好有类似的疑惑，不妨参照上述分析进行理解。如果想知道更多相关知识，欢迎关注创新互联行业资讯频道。