1f Lambda表达式.txt

1 函数式编程思想
	面向对象的思想：做一件事，找一个能解决这个事情的对象，调用对象方法来完成
	函数式编程思想：只要能获取结果，谁去做怎么做都不重要，重要的是结果，不重视过程
	
	jdk1.8提供了lambda新特性
		// 使用匿名内部类实现线程
		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();

2.标准格式
	( 参数列表 )  ->  { 一些重写方法的代码 };
	说明：
		()：接口中抽象方法的参数列表，没有参数就空着，有就写，逗号分隔多参数
		->：传递
		{ }：重写接口的抽象方法方法体
	2.1 无参实现
			/**接口**/
			public interface Cook {
			
				public void makeFood();
			
			}
			/**Lambda实现**/
			public class Demo01 {
				public static void main(String[] args) {
					invokeCook(() -> {
						System.out.println("吃饭了");
					});
				}
			
				public static void invokeCook(Cook cook) {
					cook.makeFood();
				}
			}
	2.2 有参实现
			/**Person类 实现按年龄升序排列**/
			public class Person {
				private String name;
				private int age;
				
				//省略构造方法，get set 以及toString
			}
			/**实现**/
			public class Demo01 {
				public static void main(String[] args) {
			
					Person[] arr = { new Person("AA", 11), new Person("BB", 20), new Person("CC", 19) };//创建数组
			
					Arrays.sort(arr, new Comparator<Person>() {		//使用匿名内部类来定义排序
			
						@Override
						public int  compare(Person o1, Person o2) {
							// TODO Auto-generated method stub
							return o1.getAge() - o2.getAge();// 年龄升序
						}
			
					});
			
					Arrays.sort(arr, (Person o1, Person o2) -> {		//使用Lambda传递参数实现
						return o1.getAge() - o2.getAge();// 年龄升序
					});
			
					for (Person p : arr) {
						System.out.println(p);
					}
				}
			}
	2.3 带返回值实现
			/**计算接口**/
			public interface Calculator {
			
				public int cal(int a, int b);
			
			}
			/**实现**/
			public class Demo01 {
				public static void main(String[] args) {
			
					invokeCal(10, 20, new Calculator() {		//匿名内部类
			
						@Override
						public int cal(int a, int b) {
							// TODO Auto-generated method stub
							return a + b;
						}
					});
			
					invokeCal(10, 20, (int a, int b) -> {			//Lambda
						return a + b;
					});
				}
			
				public static void invokeCal(int a, int b, Calculator c) {
					int sum = c.cal(a, b);
					System.out.println(sum);
				}
			
			}

3.省略
   Lambda表达式：可推导，可省略
   可省略的内容：
	1.(参数列表)：括号中参数列表的数据类型可不写
	2.(参数列表)：括号中参数如果只有一个，那么类型和()都可以省略
	3.{一些代码}：如果{}中代码只有一行，无论是否有返回值，都可以省略{},return,分号	（注意三者必须一起省略）
   之前的几个例子都可以对应省略为：
	new Thread(() -> System.out.println(Thread.currentThread().getName() + "线程创建了")).start();
	invokeCook(() -> System.out.println("吃饭了"));
	Arrays.sort(arr, (o1, o2) -> o1.getAge() - o2.getAge()
	invokeCal(10, 20, (a, b) -> a + b);

4.适用前提
   1.必须具有接口，且接口只有一个抽象方法
   2.必须具有上下文推断
	有且仅有一个抽象方法的接口称为函数式接口