目录

1、函数表现形式

分类

lambda表达式

• 参数类型可以全写，也可以全不写，但不能一部分写，一部分不写
• lambda 的省略策略：凡是可推导，都可以省略

方法引用

练习-判断语法正确性

练习-写出与方法引用等价的lambda表达式

实体类

Student 类有一个属性 name

public class Student {
    private String name;

    public Student (String name){
        this.name = name;
    }

    public Student(){
    }

    public String getName(){
        return name;
    }

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

    @Override
    public String toString(){
        return "Student: name='" + name + "'";
    }

    @Override
    public boolean equals(Object obj){
        if (this == obj){
            return true;
        }
        if (obj == null || getClass() != obj.getClass()){
            return false;
        }
        Student student = (Student) obj;
        return name.equals(student.name);
    }

    @Override
    public int hashCode(){
        return name.hashCode();
    }
}

1.Math::random
 ()-> Math.random()
2.Math::sqrt 
(double number) -> Math.sqrt(number)
3. Student::getName 
(Student student)-> student.getName()
4. Student::setName
(Student student,String name) -> student.setName(name)
5. Student::hashCode
(Student student) -> student.hashCode()
6. Student::equals
(Student student,Object obj) -> student.equals(o) 

假设已经有了对象 Student stu = new Student(“张三”)

• 对象已知的情况下，stu就不必要作为参数进行传递了
• new 构造方法，在对象未知的情况下，调用的是无参构造；对象已知的情况下，调用的是有参构造

1. stu::getName
()->stu.getName()
2. stu::setName
(String name)-> stu.setName(name)
3. Student::new
(String name) -> new Student(name)
 

函数对象分类

如何分类

以下情况可以归为一类：

• 参数个数和类型相同
• 返回值类型相同

归类之后统一的函数对象可以抽象为 函数式接口

• 只包含一个抽象方法（可以有很多其他方法）
• 可以使用注解@FunctionalInterface 来检查

练习

// 判断是是否是偶数
MyInterface1 type1 = (int a) -> (a & 1) == 0;
// 可能是质数
MyInterface1 type2 = (int a) -> BigInteger.valueOf(a).isProbablePrime(100);

// 函数式接口 有且仅有一个抽象方法
@FunctionalInterface
interface MyInterface1{
    boolean   op(int arg1);
}

   MyInterface2 type3 = (int a, int b, int c) -> a + b + c;

    @FunctionalInterface
    interface MyInterface2{
        int op(int num1, int num2, int num3);
    }

MyInterface3 type4 = (int a, int b) -> a + b;
MyInterface3 type5 = (int a, int b) -> a * b;

@FunctionalInterface
interface MyInterface3{
    int op(int num1, int num2);
}

// 即使函数式接口中的方法没有携带参数，你也可以在方法体中携带参数
MyInterface4 type6 = () -> new Student("张三", 18);
MyInterface5 type7 = () -> {
    List<Student> list = new ArrayList<>();
    list.add(new Student("张三", 18));
    list.add(new Student("李四", 19));
    return list;
};
// MyInterface5和MyInterface4是可以使用泛型合并的
MyInterface5_1<Student> type6_1 = () -> new Student("张三", 18);
MyInterface5_1<List> type7_1 = () -> {
    List<Student> list = new ArrayList<>();
    list.add(new Student("张三", 18));
    list.add(new Student("李四", 19));
    return list;
};

@FunctionalInterface
interface MyInterface4{
    Student op();
}

@FunctionalInterface
interface MyInterface5{
    List<Student> op();
}

// MyInterface5和MyInterface4是可以使用泛型合并的
@FunctionalInterface
interface MyInterface5_1<T>{
       

MyInterface6 type8 = (Student student) -> student.getName();
MyInterface7 type9 = (Student student) -> student.getage();
// MyInterface6和MyInterface7是可以使用泛型合并的
MyInterface8<Student,String> type8_1 = (Student student) -> student.getName();
MyInterface8<Student,Integer> type9_1 = (Student student) -> student.getage();

@FunctionalInterface
interface MyInterface6{
    String op(Student student) ;
}

@FunctionalInterface
interface MyInterface7{
    int op(Student student) ;
}

//MyInterface6和MyInterface7是可以使用泛型合并的
// O是返回值类型，I是入参类型
@FunctionalInterface
interface MyInterface8<I,O>{
    O op(I inObj) ;
}