为什么使用 Lambda 表达式

lLambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。

Lambda 表达式

Lambda 表达式语法

Lambda 表达式：在Java 8 语言中引入的一种新的语法元素和操作符。这个操作符为 “->” ， 该操作符被称为 Lambda 操作符或箭头操作符。它将 Lambda 分为两个部分：

左侧：指定了 Lambda 表达式需要的参数列表

右侧：指定了 Lambda 体，是抽象方法的实现逻辑，也即 Lambda 表达式要执行的功能。

package day26_1;import org.junit.Test;//写一个接口 B , 其中有一个抽象方法 String upper(String string);//使用匿名内部类的方式实现这个接口, 方法中把参数里的字符串变成大写并返回//使用lambda表达式方式实现这个接口, 方法中把参数里的字符串变成大写并返回interface B {	String upper(String string);}// 最常规的做法class B2 implements B {	@Override	public String upper(String string) {		return string.toUpperCase();	}}/*interface C {	Integer max(Integer n1, Integer n2); // 取最大值}*/interface C
    
      { // X在这里就是泛型， 表示某种类型	X max(X n1, X n2); // 取两个对象中的最大值}/* * 写一个接口 C ， 定义抽象方法 Integer max(Integer n1, Integer n2); *在测试方法中， 使用匿名内部类对象的方式完成这个接口的实现， 并调用方法， 打印输出 *使用lambda表达式的方式来完成相同的功能  * */public class LambdaExer {		@Test	public void test2() {		C
     
       c = new C
      
       () {			@Override			public Integer max(Integer n1, Integer n2) {				return n1 > n2 ? n1 : n2;			}		};		Integer max = c.max(10, 50);		System.out.println(max);				// lambda表达式 ： 关注参数列表 -> 方法体 		//C c2 = (Integer n1, Integer n2) -> {return n1 > n2 ? n1 : n2;};		C
       
         c2 = (n1, n2) -> n1.compareTo(n2) > 0 ? n1 : n2; // 通用性最好		String max2 = c2.max("asfj", "ASFJ");		System.out.println(max2);	}		@Test	public void test1() {		B b1 = new B2();		String string1 = b1.upper("abcdefg");		System.out.println(string1);				// 匿名内部类		B b2 = new B() {// 类体 			@Override			public String upper(String string) {				return string.toUpperCase();			}		};		String string2 = b2.upper("abcdefg");		System.out.println(string2);		// lambda表达式, 只关注 抽象方法参数列表 -> 方法体		B b3 = string -> string.toUpperCase();		String string3 = b3.upper("abcdefg");		System.out.println(string3);	}}package day26_1;import java.util.Collections;import java.util.Comparator;import java.util.List;import org.junit.Test;/** * lambda表达式 : 需要接口, 接口中必须只有一个抽象方法, 并且方法实现的方法体中只有一行语句. * 	语法 : 参数列表 -> 方法体  * lambda表达式本质上就是一个匿名内部类的对象， 并且类型只能是接口类型 *  * 	主要用于代替匿名内部类对象 */@FunctionalInterfaceinterface A {	public String test(Integer num);	//public Integer test2(String num);}public class LambdaTest {		@Test	public void test3() {		A a1 = new A() {			@Override			public String test(Integer num) {				return String.valueOf(num);			}		};		// 参数类型可以省略, 并且, 如果参数列表中只有一个参数时, ()也省略		A a2 = num -> String.valueOf(num);		String string = a2.test(200);		System.out.println(string);	}		@Test	public void test2() {		List
        
          list = StudentData.getList();		// 比较器用于完成某两个学生对象的比较		Comparator
         
           comparator = new Comparator
          
           () { // 类体相当于接口的实现子类 @Override public int compare(Student s1, Student s2) { return (int)(s1.getScore() - s2.getScore()); } }; Collections.sort(list,comparator); for (Student student : list) { System.out.println(student); } System.out.println("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&"); // lambda表达式来做这个事情, 要求分数降序 // 如果我们的方法体中, 只有一行语句, 可以省略{}, 如果有return 也可以省略 //Comparator
           
             comparator2 = (Student s1, Student s2) -> {return (int)(s2.getScore() - s1.getScore());}; // 因为左边的类型中已经有了泛型, 所有右面的表达式中的类型是可以推断的, 那么可以省略 //Comparator
            
              comparator2 = (Student s1, Student s2) -> (int)(s2.getScore() - s1.getScore()); Comparator
             
               comparator2 = (s1, s2) -> (int)(s2.getScore() - s1.getScore()); Collections.sort(list, comparator2); for (Student student : list) { System.out.println(student); } } @Test public void test1() { Runnable r1 = new Runnable() { @Override public void run() { System.out.println(Thread.currentThread().getName() + " : hello"); } }; new Thread(r1).start(); // lambda表达式 : 省略父类或接口, 省略方法修饰符和返回值, 方法名, 只保留参数列表, 和 方法体 // lambda表达式本质上就是一个匿名内部类的对象 Runnable r2 = () -> System.out.println(Thread.currentThread().getName() + " : Hello2 "); new Thread(r2).start(); }}