小白学习Java第十天，Lambda表达式

一、Lambda表达式有什么作用？
lambda是一个代码段，以及必须传入代码的变量规范。主要用来简化代码。最直观的作用就是使得代码变得异常简洁。
二、 Lambda表达式的标准格式
Lambda表达式由三部分组成：a一些参数，b一个箭头，c一段代码。
格式：

(参数列表) -> {一些重写方法的代码}；

解释说明格式：
()：接口中抽象方法的参数列表,没有参数,就空着;有参数就写出参数,多个参数使用逗号分隔。
->：传递的意思,把参数传递给方法体{}。
{}：重写接口的抽象方法的方法体。

下面以一个线程案例为例进行说明。
要启动一个线程，需要创建一个Thread类的对象并调用start方法。而为了指定线程执行的内容，需要调用Thread类的构造方法：public Thread(Runnable target)。

public class DemoThread {
	public static void main(String[] args) {
		Runnable task = new RunnableImpl();
		new Thread(task).start();
	}
	public class RunnableImpl implements Runnable {
	@Override
	public void run() {
		System.out.println("多线程任务执行！");
		}
	}
}

使用匿名内部类实现多线程。
这个RunnableImpl类只是为了实现Runnable接口而存在的，而且仅被使用了唯一一次，所以使用匿名内部类的语法即可省去该类的单独定义，即匿名内部类：

public class DemoThread {
	public static void main(String[] args) {
		new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("多线程任务执行！");
			}
		}).start();
	}
}

匿名内部类的好处与弊端：
一方面，匿名内部类可以帮我们省去实现类的定义；另一方面，匿名内部类的语法——确实太复杂了！
使用Lambda实现多线程。

public class DemoThread {
	public static void main(String[] args) {
		new Thread(
			() -> System.out.println("多线程任务执行！")
		).start();
	}
}

三、使用Lambda标准格式（无参无返回）
需求：给定一个厨子Cook接口，内含唯一的抽象方法makeFood，且无参数、无返回值。使用Lambda的标准格式调用invokeCook方法，打印输出“吃饭啦！”字样。

public class Demo01Cook {
    public static void main(String[] args) {
        //调用invokeCook方法,参数是Cook接口,传递Cook接口的匿名内部类对象
        invokeCook(new Cook() {
            @Override
            public void makeFood() {
                System.out.println("吃饭了");
            }
        });
        //使用Lambda表达式,简化匿名内部类的书写
        invokeCook(()->{
            System.out.println("吃饭了");
        });
        //优化省略Lambda
        invokeCook(()-> System.out.println("吃饭了"));
    }
    //定义一个方法,参数传递Cook接口,方法内部调用Cook接口中的方法makeFood
    public static void invokeCook(Cook cook){
        cook.makeFood();
    }
    public interface Cook {
    //定义无参数无返回值的方法makeFood
    public abstract void makeFood();
	}
}

需求：使用数组存储多个Person对象，对数组中的Person对象使用Arrays的sort方法通过年龄进行升序排序。

public class DemoArrays {
    public static void main(String[] args) {
        //使用数组存储多个Person对象
        Person[] arr = {
                new Person("aa",18),
                new Person("bb",19),
                new Person("cc",16)
        };
        //对数组中的Person对象使用Arrays的sort方法通过年龄进行升序(前边-后边)排序
        /*Arrays.sort(arr, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge()-o2.getAge();
            }
        });*/
        //使用Lambda表达式,简化匿名内部类
        Arrays.sort(arr,(Person o1, Person o2)->{
            return o1.getAge()-o2.getAge();
        });
        //优化省略Lambda
        Arrays.sort(arr,(o1, o2)->o1.getAge()-o2.getAge());
        //遍历数组
        for (Person p : arr) {
            System.out.println(p);
        }
    }
    public class Person {
    private String name;
    private int age;

    public Person() {
    }
    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;
    	}
	}
}

四、使用Lambda标准格式（有参有返回）
给定一个计算器Calculator接口，内含抽象方法calc可以将两个int数字相加得到和值，使用Lambda的标准格式调用invokeCalc方法，完成120和130的相加计算。

public class Demo01Calculator {
    public static void main(String[] args) {
        //调用invokeCalc方法,方法的参数是一个接口,可以使用匿名内部类
        invokeCalc(10, 20, new Calculator() {
            @Override
            public int calc(int a, int b) {
                return a+b;
            }
        });
        //使用Lambda表达式简化匿名内部类的书写
        invokeCalc(120,130,(int a,int b)->{
            return a + b;
        });
        //优化省略Lambda
        invokeCalc(120,130,(a,b)-> a + b);
    }
    /*
        定义一个方法
        参数传递两个int类型的整数
        参数传递Calculator接口
        方法内部调用Calculator中的方法calc计算两个整数的和
     */
    public static void invokeCalc(int a,int b,Calculator c){
        int sum = c.calc(a,b);
        System.out.println(sum);
    }
    public interface Calculator {
    //定义一个计算两个int整数和的方法并返回结果
    public abstract int calc(int a,int b);
	}
}

五、 Lambda省略格式
Lambda表达式：是可推导，可以省略。
凡是根据上下文推导出来的内容，都可以省略书写。
可以省略的内容：
1、(参数列表):括号中参数列表的数据类型，可以省略不写。
2、(参数列表):括号中的参数如果只有一个，那么类型和()都可以省略。
3、{一些代码}:如果{}中的代码只有一行，无论是否有返回值，都可以省略({}，return。分号)。
注意：要省略{}，return，分号必须一起省略。
六、Lambda的使用前提
Lambda的语法非常简洁，完全没有面向对象复杂的束缚。但是使用时有几个问题需要特别注意：
1、使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。
无论是JDK内置的Runnable、Comparator接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用Lambda。
2、使用Lambda必须具有上下文推断。
也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。

备注：有且仅有一个抽象方法的接口，称为“函数式接口”。