java中有4种内置的核心函数式接口

1.消费型接口  Consumer<T> T表示的是参数类型  void accept(T t); 该抽象方法 有参数 T表示参数类型 该方法无返回值
2.共给型接口  Supplier<T> T表示的是参数类型   T get();  该抽象方法 无参数 有返回值（T表示的是返回类型）
3.函数型接口  Function<T, R> T表示的是输入参数 R表示输出参数 R apply(T t); 该抽象方法 有参数（T表示的是参数类型） 有返回值（R表示的是返回值）
4.断定型接口  Predicate<T> T表示的是参数类型    boolean test(T t); 有参数 有返回值  T表示参数类型

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

public class FunctionDemo {
    public static void main(String[] args) {
       // 1.消费型接口  Consumer<T> T表示的是参数类型  void accept(T t); 该抽象方法 有参数 T表示参数类型 该方法无返回值
        //案列1 : 消费学生信息并打印到控制台
        //匿名内部类的方法实现
//        Consumer c=     new Consumer<Student>() {
//            @Override
//            public void accept(Student student) {
//                System.out.println(student);
//            }
//        };
//        c.accept(new Student("张三",18));
        //使用lambda表达式实现
//        Consumer c1=a-> System.out.println(a);
//        c1.accept(new Student("李四",19));

        //2.共给型接口  Supplier<T> T表示的是参数类型   T get();  该抽象方法 无参数 有返回值（T表示的是返回类型）
        //案列2: 返回一个学生对象
        //匿名内部类的方法实现

//        Supplier<Student> s = new Supplier<Student>() {
//            @Override
//            public Student get() {
//                Student s = new Student("王五", 20);
//                return s;
//            }
//        };
//        Student student = s.get();
//        System.out.println(student);
//        //使用lambda表达式实现
//        Supplier<Student> s1=()->new Student("a",19);
//        Student student1 = s1.get();
//        System.out.println(student1);
    //3.函数型接口  Function<T, R> T表示的是输入参数 R表示输出参数 R apply(T t); 该抽象方法 有参数（T表示的是参数类型） 有返回值（R表示的是返回值）
        //案列3:通过学生id查询对应学生信息
        //匿名内部类的方法实现
//        Function<Integer, Student> f = new Function<Integer, Student>() {
//            @Override
//            public Student apply(Integer id) {
//                Student s = Student.getByIdStudent(id);
//                return s;
//            }
//        };
//        Student a = f.apply(3);
//        System.out.println(a);
//        //使用lambda表达式实现
//        Function<Integer, Student> ss=id->Student.getByIdStudent(id);
//        Student apply = ss.apply(2);
//        System.out.println(apply);

        //4.断定型接口  Predicate<T> T表示的是参数类型    boolean test(T t); 有参数 有返回值  T表示参数类型
        //案列:判断两个学生是否是同龄人  也就是年龄是否相同
//        Predicate<Student> z = new Predicate<Student>() {
//            @Override
//            public boolean test(Student student) {
//                Student s = new Student(4, "zl", 18);
//                return student.age == s.age;
//            }
//        };
//        Student s1 = Student.getByIdStudent(2);
//        System.out.println(s1);
//        boolean test = z.test(s1);
//        System.out.println(test);
        //使用lambda表达式实现
//        Student s = new Student(4, "zl", 18);
//        Predicate<Student> z1=a->a.age==s.age;
//        Student s11 = new Student(5, "xx", 18);
//        boolean test1 = z1.test(s11);
//        System.out.println(test1);

    }
}