△Lambda表达式，接口中的方法，Stream流

Lambda表达式

面向对象关心的是对象行为，函数表达式关心的是具体要做的事情

例题1

这个表达式的（）内指的是重写的抽象方法的形式参数，箭头指向的方法体内相当于重写的方法执行的内容。匿名内部类相当于实现类接口，重写接口内的内容

/* 使用Lambda表达式：必须有一个接口，
   接口内有且仅有一个抽象方法*/
interface Flyable{
    void fly(String s);
}
class FlyableDemo implements Flyable{
    @Override
    public void fly(String s) {
        System.out.println(s+"学会飞翔了");
    }
}
public class Lambda {
    public static void main(String[] args) {
        //1.多态调用
        Flyable f1=new FlyableDemo();
        f1.fly("老鹰");
        System.out.println("---------");
        //2.匿名内部类
        useFlyable(new Flyable() {
            @Override
            public void fly(String s) {
                System.out.println(s+"学会飞翔了");
            }
        });
        System.out.println("-------------");
        //3.Lambda表达式
        useFlyable((String s)->{
            System.out.println(s+"学会飞翔了");
        });
    }
    private static void useFlyable(Flyable f){
        f.fly("老鹰");
    }
}

例题2（把两个传入的参数相加）

import java.util.Scanner;

/* 定义一个接口内的抽象方法，
   使传入的两个参数相加，输出结果*/
interface Addable{
    int add(int a,int b);
}
public class Lamdba_Add {
    public static void main(String[] args) {
        //1.匿名内部类
        useAddable(new Addable() {
            @Override
            public int add(int a, int b) {
                int sum=a+b;
                return sum;
            }
        });
        System.out.println("----------");
        //2.Lamdba
        useAddable((int a, int b) ->{
            int sum=a+b;
            return sum;
        });
    }
    private static void useAddable(Addable a){
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入要相加的两个数：");
        int x=sc.nextInt();
        int y=sc.nextInt();
        int sum=a.add(x,y);//调用抽象方法，并且返回这个值，并没有做什么具体的操作
        System.out.println("相加结果为："+sum);
    }
}

Lamdba的省略模式 、注意事项

 与匿名内部类的区别

接口中的方法

默认方法

 静态方法

 私有方法

 方法引用（方法引用符：::）

 引用类方法

 引用对象的实例方法

 引用类的实例方法

 

引用构造器

函数式接口

我是这样记的：括号=new  箭头=重写方法  最后的是给方法加具体内容

eg. MyInterface my=() - > System.out.println();

函数式接口作为方法的参数

函数式接口做方法参数，可以传递一个 Lambda ，而我们之前是把 Lambda 也看做一种匿名实现，说法不同而已

 函数式接口作为方法的返回值

 Supplier接口

 例题（获取数组中的最大值）

 

Consumer接口

 Predicate接口

 Function接口

 Stream流

 Stream流的生成方式（三种）

   Comparator接口可以使用lambda表达式。Comparator接口中equals是Object类中的方法，重写超类Object类中任意一个public方法并不算接口中的抽象方法。

Stream流的中间操作

 Stream流的终结操作

 Stream流的收集操作