为什么使用 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 {@Overridepublic String upper(String string) {return string.toUpperCase();}
}
/*
interface C {Integer max(Integer n1, Integer n2); // 取最大值
}
*/
interface C<X extends Comparable> { // X在这里就是泛型， 表示某种类型X max(X n1, X n2); // 取两个对象中的最大值
}
/** 写一个接口 C ， 定义抽象方法 Integer max(Integer n1, Integer n2);*在测试方法中， 使用匿名内部类对象的方式完成这个接口的实现， 并调用方法， 打印输出*使用lambda表达式的方式来完成相同的功能 * */
public class LambdaExer {@Testpublic void test2() {C<Integer> c = new C<Integer>() {@Overridepublic 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<String> c2 = (n1, n2) -> n1.compareTo(n2) > 0 ? n1 : n2; // 通用性最好String max2 = c2.max("asfj", "ASFJ");System.out.println(max2);}@Testpublic void test1() {B b1 = new B2();String string1 = b1.upper("abcdefg");System.out.println(string1);// 匿名内部类B b2 = new B() {// 类体 @Overridepublic 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表达式本质上就是一个匿名内部类的对象， 并且类型只能是接口类型* *   主要用于代替匿名内部类对象*/@FunctionalInterface
interface A {public String test(Integer num);//public Integer test2(String num);
}public class LambdaTest {@Testpublic void test3() {A a1 = new A() {@Overridepublic String test(Integer num) {return String.valueOf(num);}};// 参数类型可以省略, 并且, 如果参数列表中只有一个参数时, ()也省略A a2 = num -> String.valueOf(num);String string = a2.test(200);System.out.println(string);}@Testpublic void test2() {List<Student> list = StudentData.getList();// 比较器用于完成某两个学生对象的比较Comparator<Student> comparator = new Comparator<Student>() {// 类体相当于接口的实现子类@Overridepublic 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<Student> comparator2 = (Student s1, Student s2) -> {return (int)(s2.getScore() - s1.getScore());};// 因为左边的类型中已经有了泛型, 所有右面的表达式中的类型是可以推断的, 那么可以省略//Comparator<Student> comparator2 = (Student s1, Student s2) -> (int)(s2.getScore() - s1.getScore());Comparator<Student> comparator2 = (s1, s2) -> (int)(s2.getScore() - s1.getScore());Collections.sort(list, comparator2);for (Student student : list) {System.out.println(student);}}@Testpublic void test1() {Runnable r1 = new Runnable() {@Overridepublic 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();}}