JAVA函数式编程

目录

• 背景和价值
  • 好处1：行为参数化
• 方法引用
  • 类：：非静态方法
  • 对象：：非静态方法
  • 类名::new 构造函数的函数对象
• 参考资料

背景和价值

JAVA函数式编程解决什么问题？
将普通函数转化为对象（函数），作为对象后的好处就是，可以作为函数的入参，在函数内部调用，提高代码的复用率。

• 函数对象还可以跨网络传输，因为对象是可序列化和反序列化。

好处1：行为参数化

package com.example.order.lambdatest.student;

import java.util.ArrayList;
import java.util.List;

public class Student {
    private String name;
    private int age;
    private String sex;

    public Student(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

     public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getSex() {
        return sex;
    }


    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    static List<Student>  filter(List<Student> students,Lambda lambda) {
        List<Student> result = new ArrayList<>();
        for (Student student : students) {
            if (lambda.match(student)) {
                result.add(student);
            }
        }
        return result;
    }

    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student("张三",18,"男"));
        students.add(new Student("李四",19,"男"));
        students.add(new Student("王五",20,"男"));
        students.add(new Student("赵六",21,"女"));
        students.add(new Student("钱七",22,"男"));

        Lambda lambda = student -> student.getAge() > 20;
        List<Student> result = filter(students,lambda);
        System.out.println(result);

        lambda = student -> student.getSex().equals("男");
        result = filter(students,lambda);
        System.out.println(result);
    }
}

案例

package com.example.order;

public class LambdaTest1 {
    interface Lambda {
        int calculate(int a,int b);
    }

    static Lambda add = (a,b) ->  a+b;
    public static void main(String[] args) {
        int result = add.calculate(1,2);
        System.out.println(result);

    }
}

函数对象语法
参数 --> 逻辑部分
(a,b) -> a+b ;

方法引用

需要清楚方法引用推导出函数对象，以及函数对象推导出方法引用，这样才能用好这个技术

• 方法引用的参数，有些场景下跟函数对象的参数一致，有些不一致

以下是从图中提取的代码相关内容：

 `Math::abs`     `(n) -> Math.abs(n)`

 `Math::max`     `(a,b) -> Math.max(a,b)`

类：：非静态方法

实例方法的方法引用有特殊的语法规则：当使用类名引用实例方法时（如Student::getName），Java 会自动将流中的元素作为该方法的隐式参数（即方法的调用者this）。
Student::getName 转换为 student - > student.getName()

因为Student::getName是不知道调用哪个对象的，Java语言必须隐私传递一个对象。

对象：：非静态方法

跟类：：非静态方法对比， 因为已经知道是哪个对象调用。

Util util = new Util();
list.stream().filter(util::isMale).collect(Collectors.toUnmodifiableList());

util::isMale 转换为lambda    （util）-> util.isMale()



### this::非静态方法
### super::非静态方法

跟对象：：非静态方法区别：在类的内部使用

类名::new 构造函数的函数对象

Student::new -> new Student() () -> new Student()
Student::new -> new Student(name) (name) -> new Student(name)

参考资料