Java基础：函数编程思想，Lambda表达式

函数式编程思想：

只要能获取到结果，谁去做，怎么做都不重要，重视的是结果，不重视过程

面向对象思想：
做一件事，找一个能解决这件事的对象，调用对象的方法，完成事情。

public class Demo01 {
    public static void main(String[] args) {
        //使用匿名内部类的方式，实现多线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"新线程创建了");
            }
        }).start();
        //使用Lambda表达式实现多线程
        new Thread(()-> {
                System.out.println(Thread.currentThread().getName()+"新线程创建了");
            }
        ).start();
    }
}

Lambda表达式

Lambda表达式：用来简化代码
Lambda标准格式：
由三部分组成：a.一些参数
b.一个箭头
c.一段代码
格式：(参数列表)->{一些重写的代码};
解释说明格式：
():接口中抽象方法的参数列表
->:传递的意思，把参数传递给方法体
{}:重写接口的抽象方法的方法体

使用Lambda表达式标准格式(无参数无返回)
需求：
定义一个Cook接口，内含唯一的抽象方法makeFood，无参数，无返回
使用Lambda表达式调用invokeCook方法，打印输出

public interface Cook {
    public  abstract void makeCook();
}

public class Demo02Lambda {
    //使用Lambda表达式标准格式(无参数无返回)
    /*需求：
    * 定义一个Cook接口，内含唯一的抽象方法makeFood，无参数，无返回
    * 使用Lambda表达式调用invokeCook方法，打印输出*/
    public static void main(String[] args) {
        //调用invokeCook方法，参数是cook接口，传递Cook接口的匿名内部类
        invokeCook(new Cook() {
            @Override
            public void makeCook() {
                System.out.println("吃饭了！");
            }
        });
        invokeCook(()->{
            System.out.println("吃饭啦！");
        });
    }
    //定义一个方法，参数传递Cook接口，方法内部调用Cook接口中的方法makeCook
    public static void invokeCook(Cook cook){
        cook.makeCook();
    }
}

lambda表达式有参数有返回值的练习
需求：
使用数组存储多个Person对象
对数组中的Person对象使用Arrays的sort方法通过对年龄进行升序排序

import java.util.Arrays;
import java.util.Comparator;

public class Demo03Lambda {
    public static void main(String[] args) {
        Person per1 = new Person("小魏",16);
        Person per2 = new Person("小张",19);
        Person per3 = new Person("小杨",25);
        Person[] arr = {
                new Person("小魏",16),
                new Person("小张",19),
                new Person("小杨",25)
        };
        //对数组中的Person对象使用Arrays的sort法通过对年龄进行升序排序
        Arrays.sort(arr, new Comparator<Person>() {
            @Override
            public int compare(Person t0, Person t1) {
                return t0.getAge() - t1.getAge();
            }
        });
        //遍历数组
        for (Person p : arr) {
            System.out.println(p);
        }
        //使用lambda表达式，简化匿名内部类
        Arrays.sort(arr,(Person t0, Person t1)->{
            return t0.getAge() - t1.getAge();
        });
        //遍历数组
        for (Person p : arr) {
            System.out.println(p);
        }
    }
}
package demoLambda;
public class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", 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;
    }
    public Person() {
    }
}

lambda表达式有参数有返回值的练习
需求：
给定一个计算器Calculator接口，内含抽象方法calc可以将两个int数字相加,得到和值
使用lambda的标准格式调用invokeCalc方法，完成120和130的相加计算

public interface Calculator {
    public abstract int calc(int a,int b);
}

public class Demo04Lambda {
    public static void main(String[] args) {
        //调用invokeCalc方法，方法的参数是一个接口，可以使用匿名内部类
        invokeCalc(120, 130, new Calculator() {
            @Override
            public int calc(int a, int b) {
                return a+b;
            }
        });
        //使用Lambda表达式简化
        invokeCalc(120, 130,(int a,int b)->{
            return a+b;
        });
    }
    public static void invokeCalc(int a,int b,Calculator c){
        int sum = c.calc(a,b);
        System.out.println(sum);
    }
}

Lambda表达式的省略方式

Lambda表达式：是可推导，可以省略
凡是根据上下文推导出来的内容，都可以省略不写
可以省略的内容：
1.参数列表：两个参数，括号中参数列表的数据类型，可以省略不写
2.参数列表：括号中的参数如果只有一个，那么类型和()都可以省略
3.一些代码：如果{}中的代码只有一行，无论是否有返回值，都可以省略({}，return，😉
注意：要省略{}，return，;，必须一起省略

Lambda的使用前提：
1.使用Lambda必须有接口，且接口中只有一个接口抽象方法
无论是内置的Runnable、comparator接口还是自定义接口，只有其中抽象方法唯一时，才可以使用Lambda
2.使用Lambda必须有上下文推断。
方法的参数或局部变量类型必须是Lambda对应的接口类型，才能使用Lambda作为该接口的实例

import java.util.ArrayList;

public class Demo05LambdaArrayList {
    public static void main(String[] args) {
        ArrayList<String> al = new ArrayList<>();
    }
}