1. 什么是Lambda表达式
Java Lambda表达式是Java编程语言中的一个功能，它允许您将代码块作为参数传递给方法或作为返回值从方法中返回。Lambda表达式是一个匿名函数，它没有名称，但它可以像普通方法一样传递参数并执行代码。
Lambda表达式的语法类似于函数式编程语言中的函数定义，使用箭头符号"->"来将参数列表和函数体分开。Lambda表达式通常用于简化代码，特别是在使用函数接口（Functional Interface）时，它允许您使用更少的代码来定义方法。
2. 函数接口（Functional Interface）
函数式接口是Java 8中引入的一个概念，它是指只有一个抽象方法的接口。由于只有一个抽象方法，因此函数式接口可以看作是一个函数类型，可以用Lambda表达式来表示。函数式接口的特点是允许使用Lambda表达式来创建该接口的实例。
由于函数式接口只有一个抽象方法，因此可以用@FunctionalInterface注解来标识它们。这个注解可以帮助开发人员检查接口是否符合函数式接口的要求。这个注解不是必须标注的注解！
例如，以下代码定义了函数式接口，并在其中定义一个抽象方法：
@FunctionalInterface
public interface MyFunction {
int apply(int x, int y);
}
使用Lambda表达式作为函数式接口的实现：
MyFunction add = (a, b)-> a + b;
int result = add.apply(2,3);
System.out.println(result); // 结果为5
3. Lambda的基本使用
测试Lambda表达式的使用，代码示意如下：
@FunctionalInterface
public interface MyFunction {
int apply(int x, int y);
}
public class LamdbaDemo {
public static void main(String[] args) {
MyFunction add = (a,b)-> a + b;
int result = add.apply(2, 3);
System.out.println(result);
}
}
上述代码中，Lambda表达式被赋值给一个函数式接口类型的变量add；然后可以像一个方法一样被调用：将参数2和3传递给Lambda表达式，它将返回这两个数字的和5。
这个Lambda表达式的返回类型是int，与MyFunction接口中定义的apply方法的返回类型相匹配。
4. Lambda完整语法
Lambda的使用示例如下：
MyFunction add = (x, y) -> x + y;语法形如：
(参数) -> {主体}Lambda表达式有以下组成部分：
1、参数列表：(x, y)
Lambda表达式的参数列表可以为空，或包含一个或多个参数，参数类型可以显式指定，也可以由编译器根据上下文推断得出。如果只有一个参数时候，可以省略括号 ()。
2、箭头：->
箭头符号将参数列表和Lambda表达式的主体分开。箭头左侧表示参数列表，箭头右侧表示Lambda表达式的主体。
3、主体：x + y
Lambda表达式的主体可以是一个表达式，也可以是一段代码块。如果主体是一个表达式，则不需要使用return关键字返回结果。如果主体是一段代码块，则需要使用{}囊括代码块，并且使用return语句返回结果。
4、返回值
Lambda表达式的返回值类型，和函数式接口的apply方法的返回类型一致，否则会出现编译错误。
例如，对于只有一个参数的函数式接口：
public interface MyFunction1 {
int apply(int x);
}
可以使用Lambda表达式来计算任何整数的平方。由于Lambda表达式只有一个参数，因此我们不需要使用括号将参数括起来，例如：
public class LambdaDemo1 {
public static void main(String[] args) {
//只有一个参数时候，可以省略参数 ()
MyFunction1 square = x -> x*x;
int result = square.apply(3);
System.out.println(result); // 输出 9
}
}
下面是一个多行语句实现的Lambda表达式的例子：
public class LambdaDemo2 {
public static void main(String[] args) {
MyFunction1 factorial = x -> {
int result = 1;
for (int i = 1; i <= x; i++) {
result *= i;
}
return result;
};
int result = factorial.apply(5);
System.out.println(result); // 输出 120
}
}
这个Lambda表达式实现了函数式接口MyFunction，其中apply方法接受一个整数参数并返回一个整数。这个Lambda表达式有一个参数x，它的主体包含了多个语句，用于计算参数的阶乘。
在Lambda表达式的主体中，我们首先声明一个变量result，并将其初始化为1。然后，我们使用for循环计算参数x的阶乘，并将结果存储在result变量中。最后，我们使用return语句返回结果。
我们可以使用这个Lambda表达式来计算任何整数的阶乘，例如我们传入整数5给Lambda表达式，它返回5的阶乘值120，并将结果打印到控制台。由于Lambda表达式包含多个语句，因此我们需要使用花括号将语句块括起来，并使用return语句返回结果。
5. 使用Lambda过滤文件夹内容
本案例需要实现：过滤文件夹中以“M”为开头的文件。
Java中的FileFilter是功能性接口，其接口声明为：
@FunctionalInterface
public interface FileFilter {
boolean accept(File pathname);
}
方式一：用内部类实现
import java.io.File;
import java.io.FileFilter;
public class FilterFiles1 {
public static void main(String[] args) {
File folder = new File("./src/jaf_07");
// 使用内部类实现文件过滤器
FileFilter fileFilter = new FileFilter() {
@Override
public boolean accept(File file) {
return file.isFile() && file.getName().startsWith("M");
}
};
// 获取过滤后的文件列表
File[] filteredFiles = folder.listFiles(fileFilter);
// 输出过滤后的文件列表
for (File file : filteredFiles) {
System.out.println(file.getName());
}
}
}
方式二：用 Lambda 表达式实现
import java.io.File;
public class FilterFiles2 {
public static void main(String[] args) {
File folder = new File("./src/jaf_07");
// 使用 Lambda 表达式实现文件过滤器
File[] filteredFiles = folder.listFiles(file -> file.isFile() &&
file.getName().startsWith("M"));
// 输出过滤后的文件列表
for (File file : filteredFiles) {
System.out.println(file.getName());
}
}
}
两种写法的功能都是一样的，都是过滤文件夹中以 "M" 为开头的文件。但是，Lambda 写法相比内部类写法更加简洁和易读。Lambda 表达式可以将代码压缩到一行中，避免了冗长的内部类语法。此外，Lambda 表达式具有更高的可读性，因为它们强调了操作的目的而不是实现。Lambda 表达式还可以使代码更加函数式，这使得它们更容易与其他函数式编程技术和库进行交互。
Java Lambda表达式有以下好处：
- 简化代码：Lambda表达式可以让代码更简洁，减少了样板代码，使代码更易读
- 增加可读性：Lambda表达式可以使代码更易读和易懂，通过Lambda表达式可以将方法的逻辑和关键代码部分更加清晰地表达出来
- 提高可维护性：使用Lambda表达式可以减少代码中的重复性，使代码更易于维护
- 支持函数式编程：Lambda表达式支持函数式编程，可以方便地使用函数式接口进行函数组合，从而更加简洁地表达程序逻辑
- 并行编程支持：Lambda表达式可以支持并行编程，可以使用Java Stream API来处理大规模数据集合
- 提高性能：Lambda表达式的执行效率比传统的匿名内部类更高
总之，Lambda表达式是Java 8中最受欢迎和强大的新特性之一。它们使Java编程语言更具现代化，更加灵活，并提供了更强大的编程工具，以更好地支持现代应用程序开发。
6. 函数引用
Java 8 引入了函数引用（Method references）的概念，使得我们可以更方便地使用已有的方法或构造函数作为 Lambda 表达式。函数引用可以简化代码，使得代码更加简洁易懂。
Java 函数引用的语法形式为：
持有者::方法名其中，“持有者”可以是类或对象，“方法名”则根据具体情况分为4种。
函数引用可以分为以下四种类型：
- 静态方法引用：引用一个已有的静态方法，例如：Math::abs
- 实例方法引用：引用一个已有的实例类型方法，例如：String::length
- 对象方法引用：引用一个已有的实例对象方法，例如：out::println
- 构造函数引用：引用一个已有的构造函数（使用较少），例如：ArrayList::new
7. 函数引用类型
1、Object::instanceMethod
实例方法引用，使用一个对象的实例方法作为函数接口的实现。代码示意如下：
import java.util.function.Function;
public class MethodRefDemo1 {
public static void main(String[] args) {
//使用字符串对象 str 的 charAt 方法作为 Function 接口的实现，返回第 6 个字符。
String str = "Hello World";
Function<Integer, Character> function = str::charAt;
char c = function.apply(6);
}
}
上述代码中，使用字符串对象 str 的 charAt 方法作为 Function 接口的实现，返回第 6 个字符。
2、Class::instanceMethod
类方法引用，使用一个类的实例方法作为函数接口的实现。代码示意如下：
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class MethodRefDemo3 {
public static void main(String[] args) {
//使用 String 类的 compareToIgnoreCase 方法作为
//Collections.sort 方法的比较器，实现对列表的忽略大小写排序。
List<String> list = Arrays.asList("one", "two", "three");
Collections.sort(list, String::compareToIgnoreCase);
System.out.println(list);
}
}
上述代码中，使用 String 类的 compareToIgnoreCase 方法作为 Collections.sort 方法的比较器，实现对列表的忽略大小写排序。
3、Class::staticMethod
静态方法引用，使用一个类的静态方法作为函数接口的实现。代码示意如下：
import java.util.function.Function;
public class MethodRefDemo2 {
public static void main(String[] args) {
//使用 Integer 类的 parseInt 方法作为 Function 接口的实现，将字符串 "123" 转换为整数。
Function<String, Integer> function = Integer::parseInt;
int num = function.apply("123");
System.out.println(num);
}
}
上述代码中，使用 Integer 类的 parseInt 方法作为 Function 接口的实现，将字符串 "123" 转换为整数。
4、Class::new
构造器引用，使用一个类的构造器作为函数接口的实现。代码示意如下：
//使用ArrayList的构造器函数引用作为Lambda表达式
Supplier<ArrayList<String>> supplier = ArrayList::new;
ArrayList<String> arrayList = supplier.get();
arrayList.add("Tom");
System.out.println(arrayList);
我们定义了一个 Supplier 函数接口的实例，它引用了 ArrayList的默认构造函数。最后我们使用 supplier.get() 方法创建了一个新的 ArrayList对象。
需要注意的是，函数引用只是 Lambda 表达式的一种语法简写形式，本质上还是使用 Lambda 表达式来实现函数接口的实现。在实际使用中，需要根据具体情况选择使用 Lambda 表达式还是函数引用，以实现代码的最佳简洁性和可读性。
函数作为只是 Lambda 表达式的一种语法简写形式，Java 函数引用可以替代 Lambda 表达式的一些场景，特别是当 Lambda 表达式只包含单一方法调用时。
8. Lambda应用
1、遍历一个 List 中的每个元素，打印出它们的值：
import java.util.Arrays;
import java.util.List;
public class MethodRefDemo4 {
public static void main(String[] args) {
List<String> names = Arrays.asList("Tom", "Jerry", "Andy");
//使用Lambda输出集合内容, Lambda 中只有一个方法调用
names.forEach(name -> System.out.println(name));
//使用函数引用输出集合内容
names.forEach(System.out::println);
}
}
上述代码使用了对象方法引用，将 println 方法引用传递给了 forEach 方法，实现了对每个元素的输出。
2、将一个字符串转换为大写形式：
import java.util.function.Function;
public class MethodRefDemo5 {
public static void main(String[] args) {
//使用Lambda表达式将字符串转化为大些
Function<String, String> upperCase1 = (str) -> str.toUpperCase();
String s = upperCase1.apply("Tom");
System.out.println(s);
//使用函数引用将字符串转化为大写
Function<String, String> upperCase2 = String::toUpperCase;
String ss = upperCase2.apply("Tom");
System.out.println(ss);
}
}
上述代码使用了实例方法引用，将 toUpperCase 方法引用传递给了 Function 函数式接口，实现了字符串的大写转换。
3、集合元素排序
import jaf.day03.cases.Student;
import java.util.Arrays;
import java.util.List;
public class MethodRefDemo6 {
public static void main(String[] args) {
Student s1 = new Student("Tom", 18, 88.5);
Student s2 = new Student("Jerry", 16, 95);
Student s3 = new Student("Lucy", 17, 100);
List<Student> list = Arrays.asList(s1,s2,s3);
// 使用Lambda表达式提供Comparator接口实现
list.sort((o1,o2)->o1.age-o2.age);
list.forEach(System.out::println);
}
}