Java中内置的四种类型的接口

一、什么是函数型接口？
1.只有一个抽象方法的接口，叫做函数式接口
2.你可以使用Lambda表达式来创建该接口对象，若lambda抛出一受检异常（非运行时异常），那么该异常需要在目标接口的抽象上进行声明。
3.我们可以在一个接口上使用@FunctionalInterface注解，这样可以做一个检查他的函数式接口，同时javadoc也会声明，这个接口是一个函数式接口
4.在java.util.function包下定义了丰富的函数式接口

二、Java中常见的函数型接口

@FunctionalInterface 检测是否是函数式接口
java.lang.Runnable
java.util.Comparator

@FunctionalInterface 注解起校验作用，函数式接口只能有一个方法
@author enbo
@date 2020年6月30日

@FunctionInterface
public  interface User{
void service();
}

public class Dem{
     public static void main(String[] args){
       User u=new User(){
        public void service(){
            System.out.Println("hello");
      }  
     };
      User s=()->System.out.println("hello");
      run(u);
      run(s);
      public static void run(User user){
       user.service();
     }
  }
}

1.消费型接口(有参数，没有返回值)

• 消费型接口 Consumer void accept(T t)

import java.util.function.Consumer;

public class day2 {
        public static void main(String[] args) {
            //匿名内部类方式
            Consumer<Double> consumer = new Consumer<Double>() {
                @Override
                public void accept(Double t) {
                    System.out.println("聚餐消费：" + t);
                }
            };
            //Lambda表达式方式
            Consumer<Double> consumer2 = t->System.out.println("聚餐消费："+t);
            happy(consumer2,1000);

            //更简化的写法
            happy(t->System.out.println("聚餐消费："+t),2000);
            happy(t->System.out.println("唱歌消费："+t),1500);
            happy(t->System.out.println("按摩消费："+t),3000);
        }

    public static void happy(Consumer<Double> consumer,double money){
        consumer.accept(money);
    }
}

2.供给型接口（没有参数，有返回值）

• 供给型接口 Supplier T get()

import java.util.Arrays;
import java.util.Random;
import java.util.function.Supplier;

public class day3 {

        public static void main(String[] args) {
            //匿名内部类方式
            Supplier<Integer> supplier = new Supplier<Integer>(){
                @Override
                public Integer get() {
                    return new Random().nextInt(100);//产生指定长度的随机数数组
                }
            };

            int [] arr = getNums(supplier,5);
            System.out.println(Arrays.toString(arr));
            //Lambda表达式方式
            int [] arr2 = getNums(()->new Random().nextInt(100),10);
            System.out.println(Arrays.toString(arr2));
        }

        public static int[] getNums(Supplier<Integer> supplier,int count){
            int [] arr = new int[count];
            for (int i = 0; i < count; i++) {
                arr[i] = supplier.get();
            }
            return arr;
        }
}

3.函数型接口（有参数，有返回值）

• 函数型接口 Function<T,R> R apply(T t)

import java.util.function.Function;

public class Demo6 {
    public static void main(String[] args) {
        //匿名内部类方式   
        Function<String,String> functionn = new Function<String,String>(){
            @Override
            public String apply(String str) {
                return str.toUpperCase();
            }
        };

        String str = handlerString(functionn,"abc");
        System.out.println(str);

        //Lambda表达式方式
        String str2 = handlerString(s->s.toUpperCase(),"abcefg");
        String str3 = handlerString(s->s.toLowerCase(),"ZXCVBN");
        System.out.println(str2);
        System.out.println(str3);
    }
    //
    public static String handlerString(Function<String,String> functionn,String str){
        return functionn.apply(str);
    }
}

4.断言型接口（有参数，有返回值）

• 断定型接口 Predicate boolean test(T t)

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;

public class Demo7 {
    public static void main(String[] args) {
        //准备数据   
        List<String> list = new ArrayList<String>();
        list.add("张三丰");
        list.add("张学友");
        list.add("张无忌");
        list.add("迪丽热巴");
        list.add("刘亦菲");
        //匿名内部类方式   
        Predicate<String> predicate = new Predicate<String>(){
            @Override
            public boolean test(String t) {
                //业务逻辑，把姓为张的名字过滤出来  或者名字长度大于7的
                if(t.startsWith("张")){
                    return true;
                }
                return false;
            }
        };

        List<String> resultList = filterNames(predicate,list);
        System.out.println(resultList.toString());

        //Lambda表达式方式
        //姓张的
        List<String> resultList2 = filterNames(s->s.startsWith("张"),list);
        System.out.println(resultList2.toString());

        //名字长度大于3
        List<String> resultList3 = filterNames(s->s.length()>3,list);
        System.out.println(resultList3.toString());
    }
    //
    public static List<String> filterNames(Predicate<String> predicate,List<String> list){
        List<String> resultList = new ArrayList<String>();
        for (String string : list) {
            if(predicate.test(string)){
                resultList.add(string);
            }
        }
        return resultList;
    }
}