函数式接口

一 、Java内置四大核心函数式接口

1.1 Consumer<T> (消费型接口)

• 参数类型：T

• 返回类型：void

• 用途：对类型为T的对象应用操作，包含方法：void accept(T, t)

• public void test1(){
  
          //匿名内部类写法
          happyTime(500, new Consumer<Double>() {
  
              @Override
              public void accept(Double aDouble) {
  
                  System.out.println("学习太累了，花" + aDouble + "元买瓶水");
  
              }
  
          });
  
          //Lambda表达式写法
          happyTime(500, money -> System.out.println("学习太累了，花" + money + "元买瓶水"));
  
      }
  public void happyTime(double money, Consumer<Double> con){
  
          con.accept(money);
  
      }
  

1.2 Supplier<T> (供给型接口)

• 参数类型：无

• 返回类型：T

• 用途：返回为T的对象，包含方法：T get()

• public void test2(){
       
          Employee emp = new Employee("1001","Tom",23,5600);
  
          //匿名内部类写法
          Supplier<String> sup2 = new Supplier<String>() {
              @Override
              public String get() {
  
                  return emp.getName();
  
              }
  
          }
          //Lambda表达式写法
          System.out.println(sup1.get());
  
          Supplier<String> sup2 = () -> emp.getName();
  
          System.out.println(sup2.get());
  
      }
  

1.3 Function<T,R> (函数型接口)

• 参数类型：T

• 返回类型：R

• 用途：对类型为T的对象应用操作，并返回结果。结果是R类型的对象。包含方法：R apply(T t)

• 
  public void test3(){
  
          //匿名内部类写法
          Function<String, Employee> func1 = new Function<String, Employee>() {
              @Override
              public Employee apply(String s) {
  
                  return new Employee(s);
  
              }
  
          }
          System.out.println(func1.apply("2211"));
  
          //Lambda表达式写法
          Function<String, Employee> func1 = (s) -> new Employee(s);
  
          System.out.println(func1.apply("2211"));
  
      }
  

1.4 Predicate<T> (判定型接口)

• 参数类型：T

• 返回类型：boolean

• 用途：确定类型为T的对象是否满足某约束，并返回boolean值。包含方法 boolean test(T t)

•  public void test4(){
  
          //匿名内部类方法
          List<String> list = Arrays.asList("北京", "南京", "天津", "东京");
  
          List<String> list1 = filterString(list, new Predicate<String>() {
              @Override
              public boolean test(String s) {
  
                  return s.contains("京");
  
              }
          });
  
          System.out.println(list1);
  
          //lambda表达式方法
          List<String> list2 = filterString(list, s -> s.contains("京"));
  
          System.out.println(list2);
  
      }
   //根据给定的规则，过滤集合中的字符串。此规则由Predicate的方法决定
   public List<String> filterString(List<String> list, Predicate<String> pre){
  
          ArrayList<String> filter = new ArrayList<>();
  
          for(String s : list){
  
              if(pre.test(s)){
  
                  filter.add(s);
  
              }
  
          }
  
          return filter;
  
      }