本文共 3608 字，大约阅读时间需要 12 分钟。

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

函数式编程思想

   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案例

案例： 根据年龄进行升序排序

@SpringBootTestclass DemoApplicationTests {
   	public static void main(String[] args) {
   		Person[] persons = {
   				new Person(18, "张三"),				new Person(35, "李四"),				new Person(20, "王五")		};		/**		 * 一、原始方法		 */	/*Arrays.sort(persons, new Comparator
   
    () {
   		@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表达式的一些简单理解，使用此表达式，首先要对于其函数式编程思想有所认识，其本质其实就是一个函数式接口（有且仅有一个抽象方法的接口）的实现类的实例。

转载地址：http://xjhwi.baihongyu.com/