本文共 4794 字，大约阅读时间需要 15 分钟。

Jdk8新特性三：jdk8之函数式编程Function

Function接口的使用

1. Lambda表达式必须先定义接口，创建相关方法后才能使用，这样弄十分不便，干脆开发者就直接内置了接口，所有标注@FunctionalInterface注解的接口都是函数式接口。
2. jdk8内置的四大核心函数式接口

Consumer：消费型接口，有入参，无返回值。

​ void accept(T t);

Supplier：供给型接口：无入参，有返回值

​ T get();

Function<T,R>：函数型接口，有入参，有返回值

​ R apply(T t);

Predicate：断言型接口，有入参，有返回值，返回值类型确定是boolean

​ boolean test(T,t);

3. Function<T,R>：传入一个值，经过函数的计算返回另一个值(T，入参类型，R：出参类型)

//这个就相当于声明了一个函数变量，和js很像，然后调用这个函数。之所以能这样写是因为Function
   
     func=p->{
       System.out.println("我是函数");    return p*100;};func.apply(5);
   

4. 如果用lambda表达式可以这样写

//也可以这样写,定义了一个函数的行为。p->p*12,因为Function本身就是一个函数式编程，可以将函数作为参数进行传递。Function
   
     func2=p->p*12;System.out.println(func2.apply(5));
   

BiFunction接口解决传入两个参数问题

1. 可以通过Ctrl+Shift+n查找BiFunction类。可以看到也是函数式编程。可以传入两个参数。用法和上面一个参数的一样。

System.out.println(opreator(1,2,(a,b)->a+b));System.out.println(opreator(1,2,(a,b)->a*b));BiFunction
   
     bin=(a,b)->a+b;System.out.println(bin.apply(5,10));BiFunction
    
      bin2=(a,b)->{
       System.out.println("我是bin2");    return a*b;};System.out.println(bin2.apply(5,10));public static Integer opreator(Integer a, Integer b, BiFunction
     
       bf){
       return bf.apply(a,b);}
     
    
   

JDK8函数式编程消费型接口Consumer<T>

1. Consumer<T> 有入参，无返回值。idea中可以通过ctrl+shift+n输入Consumer.java找到源代码。没有返回值主要的应用场景打印日志，发送短信

Consumer
   
     consumer=obj->{
           //这里面可以写很多逻辑        System.out.println(obj);        System.out.println("调用短信接口发送短信，或者打印日志");    };    //consumer.accept("88888");    sendMsg("88888",consumer);    List
    
      list= Arrays.asList("aaa","bbb","ccc");    list.forEach(obj->{
            System.out.println(obj);	});public static void sendMsg(String phone,Consumer
     
       consumer){
       consumer.accept(phone);//consumer代表一个函数，phone是接收的参数。accept()方法表示这个函数运行这个参数。类似于开启新线程中的start()}
     
    
   

Jdk8函数式编程供给型接口Supplier

1. Supplier是供给型接口，无入参，有返回值 。也就是没有入参。
2. 运用场景：如果项目中你需要一些实体类需要有默认值，而有些地方不需要默认值，我们如何处理呢？我们可以设计一个工厂模式，工厂对实体类生产两种产品，一个有默认值，一个没有默认值。

public static Student newStudent(){
       Supplier
   
     supplier=()->{
           Student student=new Student();        student.setName("默认名称");        return student;    };    return supplier.get();}
   

3. 这样我们只需要实例化这个newStudent就可以了。注意里面写的lambda表达式。是定义一个supplier的函数，然后在结尾supplier.get()方法进行调用，自己调用自己。

Student student=newStudent();System.out.println(student.getName());

Jdk8函数式编程之断言型接口：Predicate

1. Predicate:断言型接口，有入参，有返回值，返回值类型确定是boolean.T为入参类型，出参类型为Boolean
2. 用途：接收一个参数，用于判断是否满足一定的条件，过滤数据。

public static List
   
     filter(List
    
      list,Predicate
     
       predicate){
       List
      
        results=new ArrayList<>();    for(String str:list){
           if(predicate.test(str)){
               results.add(str);        }    }    return results;}
      
     
    
   

3. 调用函数

List
   
     list=Arrays.asList("difjisfj","343dfjsj","kfjsidj","34dfjs","djfsi");System.out.println(list);List
    
      a = filter(list, (obj) -> obj.startsWith("a"));List
     
       filter2 = filter(list, (obj) -> {
       return obj.startsWith("3");});System.out.println(a);
     
    
   

Jdk8方法与构造函数的引用

1. 之前调用方法操作：对象.方法，类名.方法。前面是实例方法，后面是静态方法。
2. jdk8提供了另外一种调用方式，双冒号 ::

​ 这种调用方式，用来直接访问类和实例已经存在的方法或构造方法。可以通过方法引用，赋值给另外一个变量。

语法：

​ 左边是容器（或者类名，方法名），中间是"::"，右边是相应的方法名

**静态方法：**则是ClassName::methodName

**实例方法：**则是（对象）Instance::methodName

**构造函数：**则是类名::new；

Lambda表达式的使用：

​ Function<入参1，返回类型> func= 方法引用

​ 应用：func.apply(入参);

​ BiFunction<入参1，入参2，返回类型> func=方法引用

​ 应用：func.apply(入参1，入参2);

3. 引用静态方法作为函数传递

Function
   
     fun =Integer::parseInt;Integer apply = fun.apply("1204");System.out.println(apply);
   

4. 引用非静态方法作为函数传递

//使用双冒号：：来构造非静态函数的引用String text="你好啊！美女";Function
   
     func2=text::substring;String apply1 = func2.apply(1);System.out.println(apply1);
   

5. 引用构造函数作为函数传递，含多个参数和单个参数，主要是通过Function<>里面的参数来识别调用的是哪个构造函数。

class User{
       private String name;    private int age;    public User() {
       }    public User(String name) {
           this.name = name;    }    public User(String name, int age) {
           this.name = name;        this.age = age;    }    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 "User{" +            "name='" + name + '\'' +            ", age=" + age +            '}';    }}

//构造函数引用，多个参数BiFunction
   
     biFunction=User::new;User user2 = biFunction.apply("张三", 1);System.out.println(user2);Function
    
      funct2=User::new;User user3 = funct2.apply("张三");System.out.println(user3);
    
   

6. 可以作为一个函数声明，也可以将函数做为参数传递过去

sayHello(String::toUpperCase,"abcdefg");public static void sayHello(Function
   
     func,String paramer){
       String result = func.apply(paramer);    System.out.println(result);}
   

转载地址：https://blog.csdn.net/qq_33322074/article/details/105703565 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！