1. Consumer：消费型接口

void accept(T t);

  1. Supplier：供给型接口

T get();

  1. Function：函数型接口

R apply(T t);

  1. Predicate：断言型接口

boolean test(T t);

  1. Comparator: 比较器接口

int compare(T o1,T o2);

Consumer：消费型接口

该接口为消费型接口，通过调用内部的accept(T t)方法，对t进行消费（操作）
抽象方法：

  1. void accept(T t);

示例代码：

  1. package cn.unuuc.java.stream;
  3. import java.util.function.Consumer;
  5. public class Test04 {
  6.     public static void main(String[] args) {
  7.         happy(1000,(m)-> System.out.println(m));
  8.     }
  10.     public static void happy(double money, Consumer<Double> consumer){
  11.         consumer.accept(money);
  12.     }
  13. }

image.png

Supplier：供给型接口

用于创建对象（数据），可以看成是一个生产间，但是需要的生产材料不给你，但是生产出来的产品需要指定。该接口用于生产数据供给使用。
抽象方法：

  1. T get();

代码示例：

  1. package cn.unuuc.java.stream;
  2. import java.util.ArrayList;
  3. import java.util.function.Supplier;
  5. public class Test04 {
  6.     public static void main(String[] args) {
  8.         ArrayList<Integer> numList = getNumList(10, () -> (int) (Math.random() * 100));
  9.         numList.stream().forEach(e -> System.out.println(e));
  10.     }
  12.     // Supplier 示例
  13.     // 生产指定个数的数，并放入集合中
  14.     public static ArrayList<Integer> getNumList(int num, Supplier<Integer> supplier){
  15.         ArrayList<Integer> list = new ArrayList<>();
  16.         for (int i=0;i<num;i++){
  17.             Integer integer = supplier.get();
  18.             list.add(integer);
  19.         }
  20.         return list;
  21.     }
  23. }

Function：函数型接口

用于对数据进行处理，处理完毕后将需要的接口返回出去。可以看作是加工厂，给你数据加工成我想要的数据。
抽象方法:

  1. R apply(T t);

代码示例：

  1. public class Test04 {
  2.     public static void main(String[] args) {
  3.         String newStr = strHandler("abcdefg", str -> str.toUpperCase());
  4.         System.out.println(newStr);
  5.     }
  7.     // Function<T,R> 函数型接口,T表示传入类型，R表示返回类型
  8.     // 需求，处理字符串
  9.     public static String strHandler(String str, Function<String,String> function){
  10.         return function.apply(str);
  11.     }
  12. }

Predicate：断言型接口

对于数据进行判断
抽象方法：

  1. boolean test(T t);

代码示例：

  1. public class Test04 {
  2.     public static void main(String[] args) {
  4.         List<String> list = Arrays.asList("hello","world","!");
  5.         ArrayList<String> fifterList = fifterStr(list, s -> {
  6.            return s.length()>=5;
  7.         });
  8.         fifterList.forEach(s -> System.out.println(s));
  9.     }
  11.     // 需求:将满足条件的字符串添加到集合中
  12.     public static ArrayList<String> fifterStr(List<String> list, Predicate<String> pre){
  13.         ArrayList<String> strList = new ArrayList<>();
  14.         list.stream().forEach(s->{
  15.             if (pre.test(s))
  16.                 strList.add(s);
  17.         });
  18.         return strList;
  19.     }
  20. }

Comparator: 比较器接口

用于对数组，集合进行比较，通常在集合实现类中存在一个sort()方法，sort()方法传入一个Comparator类型的对象。
抽象方法：

  1. int compare(T o1, T o2);

该方法是根据放回来判断o1和o2的大小：

  • 返回值小于0：o1<o2
  • 返回值大于0：o1>o2
  • 返回值等于0：o1=o2

代码示例：

  1.     @Test
  2.     public void test08(){
  3.         ArrayList<UserEntity> userEntities = new ArrayList<>();
  4.         userEntities.add(new UserEntity("小明",12));
  5.         userEntities.add(new UserEntity("小红",22));
  6.         userEntities.add(new UserEntity("小蓝",13));
  7.         userEntities.add(new UserEntity("小绿",16));
  8.         userEntities.add(new UserEntity("小紫",21));
  10.         userEntities.sort(new Comparator<UserEntity>() {
  11.             @Override
  12.             public int compare(UserEntity o1, UserEntity o2) {
  13.                 return o1.getAge()- o2.getAge();
  14.             }
  15.         });
  16.         userEntities.forEach((u)-> System.out.println(u.toString()));
  17.     }

这几个是基本的函数式接口，在java.util.function包下还有更多的函数式接口，以满足使用
image.png