函数式编程_lambda

“一切皆对象”，这种面向对象过分强调“必须通过对象的形式来做事情”的思想有时会使得代码变得非常冗杂；而函数式思想则尽量忽略面向对象的复杂语法——强调做什么{}，而不是以什么形式做。

用下面四个案例介绍一下lambda表达式

public class Test01 {
    public static void main(String[] args) {
        //new Thread(new Runnable() {
        //    @Override
        //    public void run() {
        //        System.out.println(666);
        //    }
        //}).start();
        new Thread(() -> {
            System.out.println(666);   //原本的匿名内部类换成lambda表达式。
            // lambda表达式标准格式()->{}，相当于接口的子类对象，重写方法。()是函数的()。函数式编程
        }).start();
        new Thread(() -> System.out.println(777)).start(); //lambda表达式省略格式()->，即{} ;都省去
        //省略格式是如果参数可以推导类型可以省略,如果小括号只有一个参数,小括号可以省略,如果大括号里面只有一句话,
        // 大括号和return和分号可以一起省略
        // 函数式接口：有且仅有一个抽象方法的接口
    }
}

public class Test02 {
    public static void main(String[] args) {
        //System.out.println(new Calculator() {
        //    @Override
        //    public int calc(int a, int b) {
        //        return a+b;
        //    }
        //}.calc(3, 5));
        invokeCook(()->
            System.out.println("蛋炒饭"));
    }
    public static void invokeCook(Cook cook) {  //Cook cook 多态，假设该接口有子类，那子类必然实现了其抽象方法，这是子类对象，那子类对象必然可以使用该方法
            cook.makefood();
        }
}

interface Cook{
    void makefood() ;
}

//含参数的lambda表达式
//给定一个计算器 Calculator 接口，内含抽象方法 calc 可以将两个int数字相加得到和值：
public class Test03 {
    public static void main(String[] args) {

        //System.out.println(invokeCalculator(3, 5,(int a, int b) -> {
        //    return (a + b);
        //}));
        System.out.println(invokeCalculator(3, 5, (a, b) ->
                (a + b)));  //有返回值的话，省略的话， {} ; 及 return 都需省略。小括号内参数类型也可以省略，同样省略的话需所有参数类型一起省
    }

    public static int invokeCalculator(int a, int b, Calculator calculator) {
        return calculator.calc(a, b);
    }
}

interface Calculator {
    int calc(int a, int b);
}
/**
 * 省略情况总结
 * 1. 小括号内参数的类型可以省略；
 * 2. 如果小括号内有且仅有一个参数，则小括号可以省略；
 * 3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。
 */

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

public class Test04 {
    public static void main(String[] args) {

        Student[] arr = {
                new Student("zs", 23),
                new Student("ls", 24),
                new Student("fbb", 18)
        };
        //面向对象做法
        //Comparator<Student> comparator = new Comparator<Student>() {
        //
        //    @Override
        //    public int compare(Student o1, Student o2) {
        //        return o1.getAge()-o2.getAge();
        //    }
        //};
        //Arrays.sort(arr,comparator ); //第二个参数为比较器的实现类

        //lambda表达式做法
        //Arrays.sort(arr, (Student o1, Student o2)->{return o1.getAge()-o2.getAge();});
        Arrays.sort(arr, (o1, o2) -> o1.getAge() - o2.getAge());
        for (Student student : arr) {
            System.out.println(student);
        }
    }
}

class Student {
    private String name;
    private int age;
　　//省略构造方法，get set方法，重写to string方法 
}