Java8新特性（内置的核心函数式接口）

迷南。 2022-06-05 08:27 282阅读 0赞

\#\#\#前言：

1.我们知道只要使用Lambda表达式，那么一定要有函数式接口的支持；但是如果我们没使用一个Lambda表达式都要自己创建一个接口，
    这样很造成很大的不便。于是java8的工程师们已经帮我们把常用的函数式接口都帮我们定义好，拿来直接使用即可。
    如果不能满足你的需求，那么这时你才需要自己定义函数式接口。
    
    
    下面是我们常用的函数式接口：

\#\#\#知识点一：消费性函数式接口  
\#\#\#\#特点：  
1.接受一个或者多个参数，没有返回值  
\#\#\#\#典型函数式接口（常用）：

1.Consumer<T>  
    		void accept(T t);//接受一个泛型类型参数无返回
    	2.BiConsumer<T, U>
    		void accept(T t, U u);//接受两个泛型类型参数无返回
    	3.DoubleConsumer	
    		void accept(double value);//接收double类型，无返回
    	4.IntConsumer
    		void accept(int value);//接收int类型，无返回
    	5.LongConsumer
    		void accept(long value);//接收long类型，无返回
    	6.ObjDoubleConsumer<T>
    		void accept(T t, double value);//接收两个参数，一个泛型，一个double
    	7.ObjIntConsumer<T> 
    		void accept(T t, int value);//接收两个参数，一个泛型，一个int
    	8.ObjLongConsumer<T>
    		void accept(T t, long value);//接收两个参数，一个泛型，一个long

\#\#\#\#举例：这里使用Consumer举例，接收一个参数无返回值，其他的用法基本相同

//需求：消费给定的monkey,但是消费方式没有给定，需要具体消费的时候指定
    
        @org.junit.Test
        public void test1(){
            //消费100，洗澡
            consumerMonkey(100,(m) -> System.out.println("洗澡花费了100元"));
            //消费200，吃饭
            consumerMonkey(200,(m) -> System.out.println("洗澡花费了200元"));
        }
    
        /**
         *  消费monkey，但是没有指定出使用什么方式消费
         * */
         * 
        public static void consumerMonkey(double money, Consumer<Double> policy){
            policy.accept(money);
        }

\#\#\#知识点二：供给型函数式接口

\#\#\#\#特点：

1.没有参数（无参），提供返回值

\#\#\#\#典型函数式接口（常用）:

1. Supplier<T>
    	 T get(); //无参，返回泛型
    2. BooleanSupplier	 
    	 boolean getAsBoolean(); //无参，返回boolean
    3. DoubleSupplier
    	double getAsDouble(); //无参，返回double
    4. LongSupplier
    	long getAsLong();	//无参，返回long

\#\#\#\#举例：以 Supplier 接收泛型类型为例，其他都基本一致

@org.junit.Test
        public void test2(){
            // 返回给定的String类型
            String s = get(() -> "Hello world !");
            System.out.println(s); //打印hello world !
    
            // 返回给定类型的 int 数据
            int i = get(() -> 123);
            System.out.println(i); //打印123
        }
    
        /**
         *  获取给定类型的对象，在调用的时候指定类型
         * */
        public static <T> T get(Supplier<T> supplier){
            return supplier.get();
        }

\#\#\#知识点三：函数型函数式接口  
\#\#\#\#特点：

1.接收一个或者多个参数，有返回值

\#\#\#\#典型函数式接口（常用）:

1. Function<T, R> 
    	    R apply(T t); //接收一个泛型参数，返回一个泛型参数
      2. BiFunction<T, U, R>
            R apply(T t, U u);	 //接收两个泛型参数，返回泛型参数
      3. DoubleFunction<R>
    		R apply(double value);//接收一个double类型，返回一个泛型
      4. DoubleToIntFunction
    	    int applyAsInt(double value);
      5. DoubleToLongFunction
    	    long applyAsLong(double value);	    
      6. IntFunction<R> 
    	    R apply(int value);
      7. IntToDoubleFunction
    	    double applyAsDouble(int value);
      8. IntToLongFunction
    	    long applyAsLong(int value);	 
      9. LongFunction<R>	
    		 R apply(long value);
      10.LongToDoubleFunction      
    		 double applyAsDouble(long value);  
      11.LongToIntFunction
    	     int applyAsInt(long value);		
      12.ToDoubleBiFunction<T, U>
    	     double applyAsDouble(T t, U u);	 
      13.ToDoubleFunction<T>
    	     double applyAsDouble(T value);
      14.ToIntBiFunction<T, U>
    	     int applyAsInt(T t, U u);	  	
      15.ToIntFunction<T>
    	     int applyAsInt(T value);	
      16.ToLongBiFunction<T, U> 
    	     long applyAsLong(T t, U u);
      17.ToLongFunction<T>
    	     long applyAsLong(T value);

\#\#\#\#举例：以 Function接收一个泛型类型，返回一个泛型类型为例，其他都基本一致

@org.junit.Test
        public void test3(){
            //需求1：接收一个String，返回一个name等于给定String的Student对象
    
            Student student = handleOperator("XiangYang", (t) -> new Student(t));
            System.out.println(student); //打印：Student{name='XiangYang', age=0}
    
            //需求二：就收一个String，返回List，并且list中包含传入的String
            List list1 = handleOperator("XiangYang", (t) -> {
                List list = new ArrayList<>();
                list.add(t);
                return list;
            });
            System.out.println(list1); //打印：[XiangYang]
        }
    
    
    class Student{
        private String name;
        private int age;
    
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public Student(String name) {
            this.name = name;
        }
    
        public Student(int age) {
            this.age = age;
        }
    
        public Student() {
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
    
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

\#\#\#知识点四：断定性函数式接口

\#\#\#\#特点：

1.接收一个或者多个参数，返回一个boolean类型

\#\#\#\#常用的函数式接口：

1. Predicate<T>
    	  boolean test(T t);
    2. BiPredicate<T, U>
    	  boolean test(T t, U u);	
    3. DoublePredicate
    	  boolean test(double value);
    4. IntPredicate
    	  boolean test(int value);
    5. LongPredicate	
    	  boolean test(long value);

\#\#\#\#举例：以 Predicate 为例

@org.junit.Test
        public void test4(){
            //判断给定的整数是否大于50
            boolean b = is(80, (n) -> n > 50);
            System.out.println(b); //打印：true
        }
    
        public static <T>  boolean is(T t,Predicate<T> predicate){
            return predicate.test(t);
        }

\#\#\#总结：

1.每一中类型都给出了泛型情况，可以传入任何类型；而对于常用的类型，都单独定义了接口；例如： int 、 long 、double

本人博客：[https://elfgirl.top/][https_elfgirl.top]

[https_elfgirl.top]: https://elfgirl.top/