Java8已经用了这么长的时间了，其新特性之一的Lambda表达式在自己这里却一直处于搁置状态。由于个人的习惯原因，在实际的项目开发中，自己还是使用的是以前的传统写法，但是不可否认的是，使用lambda表达式确实能够简化我们的代码。更要命的是，周围的同事都时不时的来上一段Lambda代码，自己看着老是面生，今天趁着不忙，就来炒一炒剩饭。
Java8新特性----Lambda表达式_java

函数式编程思想
   Lambda表达式实际上是一种函数式编程的思想，java语言强调的是面向对象，必须是`通过某个对象来做某件事`（栗子：你想获取一个随机数，那你需要使用Math对象，调用它的random()方法），而函数式编程注重的是`“做什么事”`（栗子：你想去三亚晒个日光浴，可以选择汽车、自行车、走路。几种方式都可以到达目的地，你最终想要的只要能到达三亚就ok，怎么到达三亚并不是你关心的），也就是说：函数式编程弱化了面向对象的复杂语法。
Lambda案例演化

  还是举个简单的栗子来感受一下Lambda的威力吧：
我们在写多线程的时候，经常会在Thread类中传入一个Runnable接口的实现类：

/**
	 * Runnable的实现类
	 */
	public static class RunnableImpl implements Runnable{
		@Override
		public void run() {
			System.out.println("线程" + Thread.currentThread().getName() + "被创建了");
		}
	}

	public static void main(String[] args) {
		//new 一个Runnable接口的实现类对象
		RunnableImpl runnable = new RunnableImpl();
		
		//将Runnable的实现类对象作为参数传入到Thread类中
		Thread thread = new Thread(runnable);

		thread.start();

	}

  后面我们逐渐发现，上面的方式实在是有点操儿八蛋了，我只是想要将Runnable接口中的run方法传递到Thread中，但是现在又是创建实现类，又是new对象的。太麻烦！于是我们开始使用匿名内部类的方式来简化一下：

	public static void main(String[] args) {

		new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("线程" + Thread.currentThread().getName() + "被创建了");
			}
		})start();
	}

  这种方式用的挺爽，但是还是不够简洁，对于面向对象的思想还是不够弱化，我们再进行简化一下：

	public static void main(String[] args) {

		new Thread(() -> {
			System.out.println("线程" + Thread.currentThread().getName() + "被创建了");
		}).start();
	}

  上面第三种方式最终实现的效果一样，但是代码量的减少却是非常直观。
  分析一下：上面的Lambda表达式中() -> {……}直接就代替了Runnable接口中的run()方法，分析run()方法是一个无参无返回值的方法。
  

Lambda标准语法

必须要明白，并不是所有的接口都可以使用Lambda表达式来实现!!!

Lambda使用条件：
   1.必须要有接口,而且接口中必须只定义了一个抽象方法。否则在使用Lambda进行简化的时候，它不知道到底实现的是哪个方法。
   2.方法的参数或者局部变量类型必须为Lambda表达式对应的接口类型，才能使用Lambda来作为该接口的实例。

  Lambda表达式的标准语法可以分为三个部分来组成

（参数）-> {逻辑代码}

一、参数部分

  • （）就是我们需要传递的参数，如果有参数，就将参数写到此括号中，如果没有参数，就括号内就不写任何东西，如果有多个参数，则使用,分割开。例如：(参数1,参数2)。

二、箭头符号

  • ->代表的是将括号内的参数传递到后面的{}中，也就是将前面的参数传递给后面的代码。

三、方法体

  • {}代表的是方法体，里面写的是逻辑代码的具体实现，我们在上面的案例中，方法体中就是system.out.println() 打印了一句话出来。
Lambda案例
案例： 根据年龄进行升序排序 
@SpringBootTest
class DemoApplicationTests {

	public static void main(String[] args) {
		Person[] persons = {
				new Person(18, "张三"),
				new Person(35, "李四"),
				new Person(20, "王五")
		};

		/**
		 * 一、原始方法
		 */
	/*Arrays.sort(persons, new Comparator<Person>() {
		@Override
		public int compare(Person o1, Person o2) {
			return o1.getAge()-o2.getAge();
		}
	});*/

	System.out.println();
	
		/**
		 * 二、Lambda写法
		 */
		Arrays.sort(persons,(Person o1, Person o2)->{
			return o1.getAge()-o2.getAge();
		});

		/**
		 * 打印输出person数组
		 */
		for (Person person : persons) {
			System.out.println(person);
		}

	}




	/**
	 * 定义一个实体类
	 */
	public static class Person {

		private int age;
		private String name;

		public Person(int age, String name) {
			this.age = age;
			this.name = name;
		}

		@Override
		public String toString() {
			return "Person{" +
					"age=" + age +
					", name='" + name + '\'' +
					'}';
		}

		public int getAge() {
			return age;
		}

		public void setAge(int age) {
			this.age = age;
		}

		public String getName() {
			return name;
		}

		public void setName(String name) {
			this.name = name;
		}
	}


}

  在上面的案例中，我们分别通过方式一和方式二都可以对person按照年龄升序排序，但是使用Lambda书写发现代码更加简洁。其实上面书写的Lambda还不是最简化的形式。下面说一下Lambda的简化省略规则。

Lambda省略规则
  1. 参数列表：
    1）小括号内的参数类型可以省略（Lambda表达式可以根据上下文来推断参数的类型）
    2）小括号内如果只有一个参数，可以省略()和参数类型。注意：如果小括号内一个参数都没有的时候，不能省略()。
  2. 方法体：
    1）方法体中如果只有一行代码（一个;就是一行代码），可以省略{}和return和;。注意：此三种要省略则一起省略，否则报错。

所以上面的案例中的方式二我们还可以进行再次简化：

		/**
		 * 二、Lambda写法（再次简化）
		 */
		Arrays.sort(persons, (o1, o2) -> o1.getAge() - o2.getAge());

  上面就是对Lambda表达式的一些简单理解，使用此表达式，首先要对于其函数式编程思想有所认识，其本质其实就是一个函数式接口（有且仅有一个抽象方法的接口）的实现类的实例。