JDK1.8新特性(四)：函数式接口

new Thread(() -> System.out.println(Thread.currentThread().getName())).start();

其中，Lambda表达式代替了new Runnable()，这里的Runable接口就属于函数式接口，最直观的体现是使用了@FunctionalInterface注解，而且使用了一个抽象方法(有且仅有一个)，如下：

package java.lang;
/*** The <code>Runnable</code> interface should be implemented by any* class whose instances are intended to be executed by a thread. The* class must define a method of no arguments called <code>run</code>.* <p>* This interface is designed to provide a common protocol for objects that* wish to execute code while they are active. For example,* <code>Runnable</code> is implemented by class <code>Thread</code>.* Being active simply means that a thread has been started and has not* yet been stopped.* <p>* In addition, <code>Runnable</code> provides the means for a class to be* active while not subclassing <code>Thread</code>. A class that implements* <code>Runnable</code> can run without subclassing <code>Thread</code>* by instantiating a <code>Thread</code> instance and passing itself in* as the target. In most cases, the <code>Runnable</code> interface should* be used if you are only planning to override the <code>run()</code>* method and no other <code>Thread</code> methods.* This is important because classes should not be subclassed* unless the programmer intends on modifying or enhancing the fundamental* behavior of the class.** @author Arthur van Hoff* @see     java.lang.Thread* @see     java.util.concurrent.Callable* @since   JDK1.0*/@FunctionalInterfacepublic interface Runnable {  /**    * When an object implementing interface <code>Runnable</code> is used    * to create a thread, starting the thread causes the object's    * <code>run</code> method to be called in that separately executing    * thread.    * <p>    * The general contract of the method <code>run</code> is that it may    * take any action whatsoever.    *    * @see     java.lang.Thread#run()    */  public abstract void run();}

public interface MyFunctionalInterface {  public abstract void method();}

package com.xcbeyond.study.jdk8.functional;
/*** 函数式接口* @Auther: xcbeyond* @Date: 2020/5/17 0017 0:26*/@FunctionalInterfacepublic interface MyFunctionalInterface {  public abstract void method();
  // 如果存在多个抽象方法，则编译失败，即：@FunctionalInterface飘红//   public abstract void method1();}

package com.xcbeyond.study.jdk8.functional;
/*** 函数式接口* @Auther: xcbeyond* @Date: 2020/5/17 0017 0:26*/@FunctionalInterfacepublic interface MyFunctionalInterface {  public abstract void method();
  // 如果存在多个抽象方法，则编译失败，即：@FunctionalInterface飘红//   public abstract void method1();}

package com.xcbeyond.study.jdk8.functional;
/*** 测试函数式接口* @Auther: xcbeyond* @Date: 2020/5/17 0017 0:47*/public class MyFunctionalInterfaceTest {
  public static void main(String[] args) {      // 调用show方法，参数中有函数式接口MyFunctionalInterface，所以可以使用Lambda表达式，来完成接口的实现      show("hello xcbeyond!", msg -> System.out.printf(msg));  }
  /**    * 定义一个方法，参数使用函数式接口MyFunctionalInterface    * @param myFunctionalInterface    */  public static void show(String message, MyFunctionalInterface myFunctionalInterface) {      myFunctionalInterface.method(message);  }}

package java.util.function;
import java.util.Objects;
/*** Represents an operation that accepts a single input argument and returns no* result. Unlike most other functional interfaces, {@code Consumer} is expected* to operate via side-effects.** <p>This is a <a href="package-summary.html">functional interface</a>* whose functional method is {@link #accept(Object)}.** @param <T> the type of the input to the operation** @since 1.8*/@FunctionalInterfacepublic interface Consumer<T> {
  /**    * 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<T> andThen(Consumer<? super T> after) {      Objects.requireNonNull(after);      return (T t) -> { accept(t); after.accept(t); };  }}

/*** 测试void accept(T t)*/@Testpublic void acceptMethodTest() {  acceptMethod("xcbeyond", message -> {      // 完成字符串的处理，即：通过Consumer接口的accept方法进行对应数据类型(泛型)的消费      String reverse = new StringBuffer(message).reverse().toString();      System.out.printf(reverse);  });}
/*** 定义一个方法，用于消费message字符串* @param message* @param consumer*/public void acceptMethod(String message, Consumer<String> consumer) {  consumer.accept(message);}

/*** 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<T> andThen(Consumer<? super T> after) {  Objects.requireNonNull(after);  return (T t) -> { accept(t); after.accept(t); };}

/*** 测试Consumer<T> andThen(Consumer<? super T> after)* 输出结果：* XCBEYOND* xcbeyond*/@Testpublic void andThenMethodTest() {  andThenMethod("XCbeyond", t -> {      // 转换为大小输出      System.out.println(t.toUpperCase());  }, t -> {      // 转换为小写输出      System.out.println(t.toLowerCase());  });}
/*** 定义一个方法，将两个Consumer接口连接到一起，进行消费* @param message* @param consumer1* @param consumer2*/public void andThenMethod(String message, Consumer<String> consumer1, Consumer<String> consumer2) {  consumer1.andThen(consumer2).accept(message);}

package java.util.function;
/*** Represents a supplier of results.** <p>There is no requirement that a new or distinct result be returned each* time the supplier is invoked.** <p>This is a <a href="package-summary.html">functional interface</a>* whose functional method is {@link #get()}.** @param <T> the type of results supplied by this supplier** @since 1.8*/@FunctionalInterfacepublic interface Supplier<T> {
  /**    * Gets a result.    *    * @return a result    */  T get();}

@Testpublic void test() {  String str = getMethod(() -> "hello world!");  System.out.println(str);}
public String getMethod(Supplier<String> supplier) {  return supplier.get();}

package java.util.function;
import java.util.Objects;
/*** Represents a predicate (boolean-valued function) of one argument.** <p>This is a <a href="package-summary.html">functional interface</a>* whose functional method is {@link #test(Object)}.** @param <T> the type of the input to the predicate** @since 1.8*/@FunctionalInterfacepublic interface Predicate<T> {
  /**    * 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.    *    * <p>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<T> and(Predicate<? super T> 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<T> 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.    *    * <p>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<T> or(Predicate<? super T> 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 <T> 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 <T> Predicate<T> isEqual(Object targetRef) {      return (null == targetRef)              ? Objects::isNull              : object -> targetRef.equals(object);  }}

/*** 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);

/*** 测试boolean test(T t);*/@Testpublic void testMethodTest() {  String str = "xcbey0nd";  boolean result = testMethod(str, s -> s.equals("xcbeyond"));  System.out.println(result);}
/*** 定义一个方法，用于字符串的判断。* @param str* @param predicate* @return*/public boolean testMethod(String str, Predicate predicate) {  return predicate.test(str);}

/*** 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.** <p>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<T> and(Predicate<? super T> 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<T> 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.** <p>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<T> or(Predicate<? super T> other) {  Objects.requireNonNull(other);  return (t) -> test(t) || other.test(t);}

package java.util.function;
import java.util.Objects;
/*** Represents a function that accepts one argument and produces a result.** <p>This is a <a href="package-summary.html">functional interface</a>* whose functional method is {@link #apply(Object)}.** @param <T> the type of the input to the function* @param <R> the type of the result of the function** @since 1.8*/@FunctionalInterfacepublic interface Function<T, R> {
  /**    * 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 <V> 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 <V> Function<V, R> compose(Function<? super V, ? extends T> 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 <V> 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 <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {      Objects.requireNonNull(after);      return (T t) -> after.apply(apply(t));  }
  /**    * Returns a function that always returns its input argument.    *    * @param <T> the type of the input and output objects to the function    * @return a function that always returns its input argument    */  static <T> Function<T, T> identity() {      return t -> t;  }}

/*** Applies this function to the given argument.** @param t the function argument* @return the function result*/R apply(T t);

/*** 测试R apply(T t)，完成字符串整数的转换*/@Testpublic void applyMethodTest() {  // 字符串类型的整数  String numStr = "123456";  Integer num = applyMethod(numStr, n -> Integer.parseInt(n));  System.out.println(num);}
public Integer applyMethod(String str, Function<String, Integer> function) {  return function.apply(str);}

/*** 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 <V> 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 <V> Function<V, R> compose(Function<? super V, ? extends T> 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 <V> 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 <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {  Objects.requireNonNull(after);  return (T t) -> after.apply(apply(t));}