目录
1.Lambad表达式的概念
Lambda表达式是Java 8引入的一个新特性，它允许你以简洁的方式表示一个方法的实现。Lambda表达式本质上是一个匿名函数，它可以作为参数传递给方法，或者赋值给变量。
了解Lambda和匿名内部类
例子1：无参函数的简写
// JDK7 匿名内部类写法
new Thread(new Runnable(){// 接口名
@Override
public void run(){// 方法名
System.out.println("Thread run()");
}
}).start();上述代码给Tread类传递了一个匿名的Runnable对象，重载Runnable接口的run()方法来实现相应逻辑。这是JDK7以及之前的常见写法。匿名内部类省去了为类起名字的烦恼，但还是不够简化，在Java 8中可以简化为如下形式：
// JDK8 Lambda表达式写法
new Thread(
() -> System.out.println("Thread run()")// 省略接口名和方法名
).start();上述代码跟匿名内部类的作用是一样的，但比匿名内部类更进一步。这里连接口名和函数名都一同省掉了，写起来更加神清气爽。如果函数体有多行，可以用大括号括起来，就像这样：
例子2：带参函数的简写
如果要给一个字符串列表通过自定义比较器，按照字符串长度进行排序，Java 7的书写形式如下：
// JDK7 匿名内部类写法
List<String> list = Arrays.asList("I", "love", "you", "too");
Collections.sort(list, new Comparator<String>(){// 接口名
@Override
public int compare(String s1, String s2){// 方法名
if(s1 == null)
return -1;
if(s2 == null)
return 1;
return s1.length()-s2.length();
}
});上述代码通过内部类重载了Comparator接口的compare()方法，实现比较逻辑。采用Lambda表达式可简写如下：
// JDK8 Lambda表达式写法
List<String> list = Arrays.asList("I", "love", "you", "too");
Collections.sort(list, (s1, s2) ->{// 省略参数表的类型
if(s1 == null)
return -1;
if(s2 == null)
return 1;
return s1.length()-s2.length();
});上述代码跟匿名内部类的作用是一样的。除了省略了接口名和方法名，代码中把参数表的类型也省略了。这得益于javac的类型推断机制，编译器能够根据上下文信息推断出参数的类型，当然也有推断失败的时候，这时就需要手动指明参数类型了。注意，Java是强类型语言，每个变量和对象都必需有明确的类型。
简写的依据
也许你已经想到了，能够使用Lambda的依据是必须有相应的函数接口（函数接口，是指内部只有一个抽象方法的接口）。这一点跟Java是强类型语言吻合，也就是说你并不能在代码的任何地方任性的写Lambda表达式。实际上Lambda的类型就是对应函数接口的类型。Lambda表达式另一个依据是类型推断机制，在上下文信息足够的情况下，编译器可以推断出参数表的类型，而不需要显式指名。Lambda表达更多合法的书写形式如下：
1.无参数，无返回值
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println("Hello, Lambda!");
}
};
//lambda格式写法
Runnable runnable = () -> System.out.println("Hello, Lambda!");2.一个参数，无返回值
Consumer<String> consumer = new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
};
//lambda表达式写法
Consumer<String> consumer = (s) -> System.out.println(s);3. 多个参数，有返回值
BinaryOperator<Integer> add = new BinaryOperator<Integer>() {
@Override
public Integer apply(Integer a, Integer b) {
return a + b;
}
};
//lambda写法格式
BinaryOperator<Integer> add = (a, b) -> a + b;4.大括号和return关键字（多条语句）
BinaryOperator<Integer> add = new BinaryOperator<Integer>() {
@Override
public Integer apply(Integer a, Integer b) {
int sum = a + b;
return sum;
}
};
//lambda表达格式
BinaryOperator<Integer> add = (a, b) -> {
int sum = a + b;
return sum;
};5.方法引用
Consumer<String> consumer = new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
};
//lambda表达式的写法
Consumer<String> consumer = System.out::println;
//:: 是一个双冒号操作符，它用于表示方法引用。
左侧是方法所属的对象，
右侧是方法名称.
在这个例子中，System.out 是方法所属的对象，println 是方法名称。6.构造器引用
Supplier<List<String>> supplier = new Supplier<List<String>>() {
@Override
public List<String> get() {
return new ArrayList<String>();
}
};
//lambda表达格式
Supplier<List<String>> supplier = ArrayList::new;语法
lambda 表达式的语法格式如下：
(parameters) -> expression
或
(parameters) ->{ statements; }parameters 是参数列表，expression 或 { statements; } 是Lambda 表达式的主体。如果只有一个参数，可以省略括号；如果没有参数，也需要空括号。
下面是一个简单的例子，展示了使用 Lambda 表达式计算两个数的和：
// 使用 Lambda 表达式计算两个数的和
MathOperation addition = (a, b) -> a + b;
// 调用 Lambda 表达式
int result = addition.operation(5, 3);
System.out.println("5 + 3 = " + result);在上面的例子中，MathOperation 是一个函数式接口，它包含一个抽象方法 operation，Lambda 表达式 (a, b) -> a + b 实现了这个抽象方法，表示对两个参数进行相加操作。
Lambda 表达式可以用于各种场景，包括集合操作、事件处理等，下面是一个使用 Lambda 表达式对列表进行遍历的例子：
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
// 使用 Lambda 表达式遍历列表
names.forEach(name -> System.out.println(name));Lambda 表达式在 Java 中引入了更函数式编程的风格，使得代码更加简洁和易读，它是 Java 8 中对函数式编程的一次重要改进。
Lambda 表达式实例：
// 1. 不需要参数,返回值为 5
() -> 5
// 2. 接收一个参数(数字类型),返回其2倍的值
x -> 2 * x
// 3. 接受2个参数(数字),并返回他们的差值
(x, y) -> x – y
// 4. 接收2个int型整数,返回他们的和
(int x, int y) -> x + y
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
(String s) -> System.out.print(s)public class Java8Tester {
public static void main(String args[]){
Java8Tester tester = new Java8Tester();
// 类型声明
MathOperation addition = (int a, int b) -> a + b;
// 不用类型声明
MathOperation subtraction = (a, b) -> a - b;
// 大括号中的返回语句
MathOperation multiplication = (int a, int b) -> { return a * b; };
// 没有大括号及返回语句
MathOperation division = (int a, int b) -> a / b;
System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
System.out.println("10 / 5 = " + tester.operate(10, 5, division));
// 不用括号
GreetingService greetService1 = message ->
System.out.println("Hello " + message);
// 用括号
GreetingService greetService2 = (message) ->
System.out.println("Hello " + message);
greetService1.sayMessage("Runoob");
greetService2.sayMessage("Google");
}
interface MathOperation {
int operation(int a, int b);
}
interface GreetingService {
void sayMessage(String message);
}
private int operate(int a, int b, MathOperation mathOperation){
return mathOperation.operation(a, b);
}
}执行以上脚本，输出结果为：
10 + 5 = 15
10 - 5 = 5
10 x 5 = 50
10 / 5 = 2
Hello Runoob
Hello Google使用 Lambda 表达式需要注意以下两点：
Lambda 表达式主要用来定义行内执行的方法类型接口（例如，一个简单方法接口）。在上面例子中，我们使用各种类型的 Lambda 表达式来定义 MathOperation 接口的方法，然后我们定义了 operation 的执行。
Lambda 表达式免去了使用匿名方法的麻烦，并且给予 Java 简单但是强大的函数化的编程能力。
变量作用域
lambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在 lambda 内部修改定义在域外的局部变量，否则会编译错误。
在 Java8Tester.java 文件输入以下代码：
public class Java8Tester {
final static String salutation = "Hello! ";
public static void main(String args[]){
GreetingService greetService1 = message ->
System.out.println(salutation + message);
greetService1.sayMessage("Runoob");
}
interface GreetingService {
void sayMessage(String message);
}
}本文总结：
匿名内部类与 Lambda 函数比较
public class Demo03Collections {
public static void main(String[] args) {
//创建集合
List<Student> list = new ArrayList<>();
//添加元素
list.add(new Student("嫐", 20));
list.add(new Student("嬲", 18));
list.add(new Student("挊", 22));
//使用比较器排序对集合中的学生对象根据年龄升序排序
//Collections.sort(list, new Rule());
//使用匿名内部类
Collections.sort(list, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return o1.getAge() - o2.getAge();
}
});
//使用Lambda表达式
Collections.sort(list, (Student o1, Student o2) -> {
return o1.getAge() - o2.getAge();
});
Collections.sort(list, (o1, o2) -> o1.getAge() - o2.getAge());
System.out.println(list);
}
}Lambda 格式
Lambda 表达式的标准格式：