只包含一个抽象方法的接口

Lambda表达式，匿名内部类，自定义实现类

@FunctionInterface注解作用：
   声明此接口是函数式接口，并检查接口是否满足函数式接口要求。

包java.util.function中包含内置函数式接口

Java内置四大核心函数式接口：
   消费型接口：传入T类型参数，无返回值，Consumer
   供给型接口：无传入参数，返回T类型值，Supplier
   函数型接口：传入T类型参数，返回R类型值，Function
   断定型接口：传入T类型参数，返回boolean类型值，Predicate

package com.bobo.study.jdk.lambda;


import java.util.Arrays;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;


import org.junit.Test;


/**
 * - 测试java内置四大函数式接口
 * @author bobo
 *
 */
public class LambdaUtilFunctionInterface {


  /**
   * - 供给型函数式接口Supplier<T>
   * - 返回数组的最大值
   */
  @Test
  public void testSupplier() {
    System.out.println("==== 供给型函数式接口Supplier<T> 示例 ---- begin ====");
    
    System.out.println(
      getMaxValue(() -> {
        Integer[] nums = {2,3,4,1,0,6,8};
        System.out.println(Arrays.toString(nums));
        Arrays.sort(nums);
        System.out.println(Arrays.toString(nums));
        return nums[nums.length - 1];
      })
    );
    
    System.out.println("==== 供给型函数式接口Supplier<T> 示例 ---- end ====\n");
  }
  
  private Integer getMaxValue(Supplier<Integer> sup) {
    return sup.get();
  }
  
  
  /**
   * - 消费型函数式接口Consumer<T>
   * - 先将字符串转为大写在转为小写
   */
  @Test
  public void testConsumer() {
    System.out.println("==== 消费型函数式接口Consumer<T> 示例 ---- begin ====");
    convertStr("aBc", 
      s -> System.out.println(s.toUpperCase()), 
      s -> System.out.println(s.toLowerCase())
    );
    System.out.println("==== 消费型函数式接口Consumer<T> 示例 ---- end ====\n");
  }
  
  private void convertStr(String orgStr, Consumer<String> cr1, 
      Consumer<String> cr2) {
    cr1.andThen(cr2).accept(orgStr);
  }
  
  
  /**
   * - 函数型函数式接口Function<T,R>
   * - 将字符串转为数字，再乘以5，在乘以3
   */
  @Test
  public void testFunction() {
    System.out.println("==== 函数型函数式接口Function<T,R> 示例 ---- begin ====");
    
    System.out.println(
      converStrToInt("2", 
        s -> Integer.parseInt(s), 
        n -> n * 5, 
        n -> n * 3
      )
    );
    
    System.out.println("==== 函数型函数式接口Function<T,R> 示例 ---- end ====\n");
  }
  
  private Integer converStrToInt(String intStr, Function<String, Integer> f1, 
      Function<Integer, Integer> f2, Function<Integer, Integer> f3) {
    // f1最先执行，之后执行f2，之后在执行f3
    // compose先执行参数内容，在执行自己的内容
    // andThen先执行自己的内容，在执行参数的内容
    // 一下内容翻译之后 => f3.apply(f2.apply(f1.apply()))
    return f2.compose(f1).andThen(f3).apply(intStr);
  }
  
  /**
   * - 断定型函数式接口Predicate<T>
   * - 判断字符串即包含W也包含H
   * - 判断字符串包含W或H
   * - 判断字符串不包含W
   */
  @Test
  public void testPredicate() {
    System.out.println("==== 断定型函数式接口Predicate<T> 示例 ---- begin ====");
    
    System.out.println(testWAndH("Hello World", 
      s -> s.contains("W"),
      s -> s.contains("H"))
    );
    System.out.println(testWOrH("Hello orld", 
      s -> s.contains("W"),
      s -> s.contains("H"))
    );
    System.out.println(testNotW("Hello World", 
      s -> s.contains("W"))
    );
    
    System.out.println("==== 断定型函数式接口Predicate<T> 示例 ---- end ====\n");
  }
  
  private boolean testWAndH(String str, 
    Predicate<String> p1, Predicate<String> p2) {
    return p1.and(p2).test(str);
  }
  
  private boolean testWOrH(String str, 
    Predicate<String> p1, Predicate<String> p2) {
    return p1.or(p2).test(str);
  }
  
  private boolean testNotW(String str,
    Predicate<String> p) {
    return p.negate().test(str);
  }
  
}

==== 供给型函数式接口Supplier<T> 示例 ---- begin ====
[2, 3, 4, 1, 0, 6, 8]
[0, 1, 2, 3, 4, 6, 8]
8
==== 供给型函数式接口Supplier<T> 示例 ---- end ====


==== 断定型函数式接口Predicate<T> 示例 ---- begin ====
true
true
false
==== 断定型函数式接口Predicate<T> 示例 ---- end ====


==== 消费型函数式接口Consumer<T> 示例 ---- begin ====
ABC
abc
==== 消费型函数式接口Consumer<T> 示例 ---- end ====


==== 函数型函数式接口Function<T,R> 示例 ---- begin ====
30
==== 函数型函数式接口Function<T,R> 示例 ---- end ====