内置函数式接口

最新推荐文章于 2024-02-02 10:04:59 发布

尘乂不落蒂

最新推荐文章于 2024-02-02 10:04:59 发布

阅读量64

点赞数 1

文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_64353239/article/details/131207582

版权

文章介绍了Java中Lambda表达式的基础，强调其依赖于函数式接口。文中详细讲解了四种内置函数式接口：Consumer（消费型接口）适合处理无返回值的参数；Supplier（供给型接口）用于无参数但需要返回值的情况；Function（函数型接口）处理带有泛型参数和返回值的方法；Predicate（断言型接口）用于进行条件判断，接收一个参数并返回一个布尔值。

摘要由CSDN通过智能技术生成

1. 内置函数式接口

要想使用lambda表达式它的前提就是必须是函数式接口。

1.1 内置函数式接口的由来

package demo05;


public class Test {

    public static void main(String[] args) {
           Operation o=arr->{
               int sum=0;
               for(int s:arr){
                   sum+=s;
               }
               return sum;
           };
            fun(o);
    }
    public static void fun(Operation operation){
        int[] arr={1,2,3,4};
        int s = operation.getSum(arr);
        System.out.println("数组的和:"+s);
    }
}
@FunctionalInterface
interface Operation{
     public int getSum(int[] arr);
}

分析:

我们知道使用Lambda表达式的前提是需要有函数式接口，而Lambda表达式使用时不关心接口名，抽象方法名。只关心抽象方法的参数列表和返回值类型。因此为了让我们使用Lambda表达式更加的方便，在JDK中提供了大量常用的函数式接口. 大多数无需自己再定义函数式接口，而可以直接使用jdk内置的函数式接口。分成四类。

1.2 消费型函数式接口Consumer

适合有参数，但是没有返回值的。

public class Test06 {
    public static void main(String[] args) {
        Consumer<Double> c=t->{
            System.out.println("今天洗脚花费:"+t+"元");
        };
        fun(c,200.0);
    }
    public static void fun(Consumer<Double> consumer,Double money){
          consumer.accept(money);
    }
}

1.3 供给型函数式接口---Supplier

无参，需要返回值的接口类。

package demo06;

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


public class Test06 {
    public static void main(String[] args) {
//        Consumer<Double> c=t->{
//            System.out.println("今天洗脚花费:"+t+"元");
//        };
//        fun(c,200.0);
         Supplier<Integer> s=()-> new Random().nextInt(10);
         fun2(s);
    }
    public static void fun2(Supplier<Integer> supplier){
        Integer a = supplier.get();
        System.out.println("结果:"+a);
    }


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

1.4 函数型函数式接口---Function<T,R>

T: 参数的泛型

R:返回值的泛型。

package demo05;

import java.util.function.Function;

public class Test {

    public static void main(String[] args) {
           Function<int[],Integer> o=arr->{
               int sum=0;
               for(int s:arr){
                   sum+=s;
               }
               return sum;
           };
            fun(o);
    }
    public static void fun(Function<int[],Integer> fun){
        int[] arr={1,2,3,4};
        int s = fun.apply(arr);
        System.out.println("数组的和:"+s);
    }
}

1.5 断言型函数式接口--Predicate

T: 参数

boolean:返回值类型。

package demo06;

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

public class Test06 {
    public static void main(String[] args) {
//        Consumer<Double> c=t->{
//            System.out.println("今天洗脚花费:"+t+"元");
//        };
//        fun(c,200.0);
//         Supplier<Integer> s=()-> new Random().nextInt(10);
//         fun2(s);
//          Function<String,String> fun=t->t.toUpperCase();
//          fun3(fun,"hello world");
          Predicate<String> p=t->t.length()>3;
          fun4(p,"欧阳锋"); //4
    }

    public static void fun4(Predicate<String> predicate,String name){
        boolean test = predicate.test(name);
        System.out.println("是否成年:"+test);
    }

    public static void fun3(Function<String,String> f,String str){
        String apply = f.apply(str);
        System.out.println("结果:"+apply);
    }
    public static void fun2(Supplier<Integer> supplier){
        Integer a = supplier.get();
        System.out.println("结果:"+a);
    }

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