共计 7204 个字符，预计需要花费 19 分钟才能阅读完成。
首先，Lambda 表达式是 Java 8 中引入的一种匿名函数语法。它容许咱们以更简洁和灵便的形式传递代码块作为参数或将其赋值给变量。Lambda 表达式能够用于代替应用匿名类实现接口的传统形式。
老手从头看，有教训者间接看文章最初两个示例
Lambda 表达式的语法如下：
(parameters) -> {body}
其中，(parameters)指定了办法的参数列表，能够为空或蕴含一个或多个参数；-> 是 Lambda 运算符，用于将参数列表与表达式的主体分隔开；{body}是办法的主体，能够是单个表达式或一系列语句。
上面是一些常见的 Lambda 表达式的应用示例：
无参 Lambda 表达式：
Runnable runnable = () -> System.out.println("Hello Lambda!");在这个示例中，咱们创立了一个 Runnable 接口的实例，应用 Lambda 表达式定义了其 run()办法的实现。
单个参数 Lambda 表达式：
Consumer<String> consumer = (String message) -> System.out.println(message);
consumer.accept("Hello Lambda!");在这个示例中，咱们创立了一个 Consumer 接口的实例，应用 Lambda 表达式定义了其 accept()办法的实现。
多参数 Lambda 表达式：
Comparator<Integer> comparator = (Integer a, Integer b) -> a.compareTo(b);
int result = comparator.compare(5, 10);在这个示例中，咱们创立了一个 Comparator 接口的实例，应用 Lambda 表达式定义了其 compare()办法的实现。
Lambda 表达式块：
Supplier<String> supplier = () -> {
String message = "Hello";
return message + "Lambda!";
};
String result = supplier.get();在这个示例中，咱们创立了一个 Supplier 接口的实例，应用 Lambda 表达式块定义了其 get()办法的实现。
Lambda 表达式的劣势在于简化代码、进步可读性和灵活性。它让咱们可能更专一地编写外围逻辑，而不用过多关注简单的语法和匿名类的实现。
在 Java 中，函数式接口（Functional Interface）是指只蕴含一个形象办法的接口。函数式接口是 Lambda 表达式的根底，在 Java 8 之后引入，用于反对函数式编程的个性。
以下是函数式接口的特点：
只蕴含一个形象办法：函数式接口只能有一个未实现的形象办法。这个形象办法定义了 Lambda 表达式要执行的行为。
能够有默认办法和静态方法：函数式接口能够蕴含默认办法（default method）和静态方法（static method）。默认办法提供了接口的默认实现，静态方法提供了与接口相关联的工具办法。
能够通过 @FunctionalInterface 注解标记：尽管不是强制要求，但倡议应用 @FunctionalInterface 注解来明确标记一个接口是函数式接口。这样做能够确保接口只蕴含一个形象办法，同时还能让编译器进行额定的查看。
函数式接口在 Java 中的应用场景宽泛，特地是与 Lambda 表达式一起应用。Lambda 表达式能够实现函数式接口的形象办法，从而提供了一种更简洁、灵便的形式来定义行为。
Java 中有一些内置的函数式接口，例如：
Runnable：示意能够在独自的线程中运行的代码块。Supplier<T>：示意提供一个特定类型的后果。Consumer<T>：示意承受一个参数并执行操作，但没有返回值。Function<T, R>：示意承受一个参数并返回后果。Predicate<T>：示意承受一个参数并返回一个布尔值后果。除了这些内置的函数式接口，你也能够自定义本人的函数式接口，满足特定的需要。
总结一下，函数式接口是指只蕴含一个形象办法的接口，用于反对 Lambda 表达式和函数式编程。Java 中提供了一些内置的函数式接口，同时你也能够自定义函数式接口。应用函数式接口能够简化代码，实现更灵便的行为定义。
- 首先回顾一下什么是形象办法？
在 Java 中，形象办法（Abstract Method）是指只有办法申明而没有具体实现的办法。形象办法必须在抽象类或接口中申明，而不能间接在一般类中申明。
以下是形象办法的特点：
没有办法体：形象办法只有办法签名，没有具体的实现代码。它以分号完结，而没有花括号和办法体。
用于定义接口：在接口中申明的办法默认为形象办法。接口只能蕴含形象办法，而不能蕴含具体实现的办法。实现该接口的类必须提供对这些形象办法的具体实现。
用于定义抽象类：在抽象类中能够蕴含形象办法，这些形象办法也没有具体实现。抽象类是不能被实例化的，只能用作其余类的基类。具体子类必须提供对形象办法的实现能力被实例化。
形象办法次要用于定义接口和抽象类的行为束缚，而具体的实现则由实现类提供。子类必须实现抽象类中的所有形象办法，否则子类也必须申明为抽象类。
上面是一个示例，演示如何在抽象类和接口中申明形象办法：
// 定义抽象类
abstract class Animal {
// 申明形象办法
public abstract void makeSound();}
// 定义接口
interface Shape {
// 申明形象办法
void draw();}
// 实现抽象类和接口
class Dog extends Animal implements Shape {
// 实现形象办法
@Override
public void makeSound() {System.out.println("汪汪汪！");
}
// 实现接口办法
@Override
public void draw() {System.out.println("绘制一个狗形态");
}
}
public class AbstractMethodExample {public static void main(String[] args) {Dog dog = new Dog();
dog.makeSound(); // 输入：汪汪汪！dog.draw(); // 输入：绘制一个狗形态}
}在下面的示例中，咱们定义了抽象类 Animal 和接口 Shape。它们都蕴含了一个形象办法，别离是 makeSound()和 draw()。而后，咱们创立了一个 Dog 类来实现 Animal 类和 Shape 接口，并提供了对形象办法的具体实现。
当咱们实例化 Dog 类时，就能够调用形象办法 makeSound()和 draw()，别离输入 ” 汪汪汪！” 和 ” 绘制一个狗形态 ”。
总结一下，形象办法是只有办法签名而没有具体实现的办法，用于定义接口和抽象类的行为束缚。子类必须提供对形象办法的具体实现。通过应用形象办法，能够实现多态性和行为的对立定义。
- 什么是应用 Lambda 表达式作为参数传递给办法？
应用 Lambda 表达式作为参数传递给办法是指将 Lambda 表达式作为一个办法的参数进行传递。这种传递形式能够在办法外部执行 Lambda 表达式所代表的逻辑。
在 Java 中，Lambda 表达式能够被视为一个函数对象，因而能够将其作为参数传递给承受函数对象的办法。这使得办法调用更加灵便，能够依据须要传递不同的行为。
上面是一个简略的示例，演示如何应用 Lambda 表达式作为参数传递给办法：
public class LambdaExample {public static void main(String[] args) {
// 应用 Lambda 表达式作为参数传递给办法
greet(() -> System.out.println("Hello, Lambda!"));
}
public static void greet(Greeting greeting) {greeting.sayHello();
}
}
// 定义一个函数式接口
@FunctionalInterface
interface Greeting {void sayHello();
}在下面的示例中，咱们定义了一个函数式接口 Greeting，该接口只有一个形象办法 sayHello()。而后，咱们编写了一个 greet()办法，该办法承受一个 Greeting 类型的参数，并调用参数的 sayHello()办法。
在 main()办法中，咱们应用 Lambda 表达式 () -> System.out.println(“Hello, Lambda!”) 来创立一个实现 Greeting 接口的对象，并将其作为参数传递给 greet()办法。
当程序运行时，greet()办法会执行 Lambda 表达式中定义的逻辑，输入 ”Hello, Lambda!”。
通过将 Lambda 表达式作为参数传递给办法，咱们能够在调用办法时动静地定义方法的行为。这种形式使得代码更加灵便和可扩大，让咱们可能更不便地实现回调机制、处理事件等。
- 什么是应用 Lambda 表达式作为函数接口的实现？
在 Java 中，Lambda 表达式能够用作函数接口的实现。函数接口（Functional Interface）是指只有一个形象办法的接口。
应用 Lambda 表达式作为函数接口的实现，能够通过更简洁的语法来定义接口办法的实现。这种形式使得代码更加紧凑、易读，并且可能以函数式编程的形式解决数据。
上面是一个示例，演示如何应用 Lambda 表达式作为函数接口的实现：
// 定义一个函数接口
interface Calculator {int calculate(int a, int b);
}
public class LambdaExample {public static void main(String[] args) {
// 应用 Lambda 表达式实现函数接口
Calculator add = (a, b) -> a + b;
Calculator subtract = (a, b) -> a - b;
// 调用函数接口办法
int result1 = add.calculate(10, 5); // 输入：15
int result2 = subtract.calculate(10, 5); // 输入：5
System.out.println("Result 1:" + result1);
System.out.println("Result 2:" + result2);
}
}在下面的示例中，咱们定义了一个函数接口 Calculator，其中蕴含一个形象办法 calculate。而后，咱们应用 Lambda 表达式别离实现了 add 和 subtract 对象，别离示意求和和减法操作。
通过 Lambda 表达式的简洁语法，咱们无需再创立匿名外部类或实现具体的类来实现函数接口。只需提供 Lambda 表达式的参数列表和办法体，即可定义函数接口的实现。
最初，咱们调用函数接口的办法 calculate，传入不同的参数，别离计算加法和减法的后果，并将后果打印进去。
应用 Lambda 表达式作为函数接口的实现，能够使代码更加简洁、易读，并且反对函数式编程的个性。
上面是一些简略示例，展现了如何在 Java 8 中应用 Lambda 表达式：
- 示例一：
public class LambdaExample {public static void main(String[] args) {
// 1. 应用 Lambda 表达式作为参数传递给办法
greet("John", () -> System.out.println("Hello," + "John!"));
// 2. 应用 Lambda 表达式作为函数接口的实现
MathOperation addition = (a, b) -> a + b;
System.out.println("10 + 5 =" + operate(10, 5, addition));
MathOperation subtraction = (a, b) -> a - b;
System.out.println("10 - 5 =" + operate(10, 5, subtraction));
MathOperation multiplication = (a, b) -> a * b;
System.out.println("10 * 5 =" + operate(10, 5, multiplication));
MathOperation division = (a, b) -> a / b;
System.out.println("10 / 5 =" + operate(10, 5, division));
}
// 定义一个函数接口
interface MathOperation {int operation(int a, int b);
}
// 定义一个办法，承受一个函数接口作为参数
public static void greet(String name, Greeting greeting) {greeting.perform();
}
// 定义一个函数接口
interface Greeting {void perform();
}
// 执行指定的数学操作
public static int operate(int a, int b, MathOperation mathOperation) {return mathOperation.operation(a, b);
}
}在下面的示例中，咱们首先定义了两个函数接口：MathOperation 和 Greeting。而后，在 main 办法中，咱们展现了 Lambda 表达式的两种用法：
应用 Lambda 表达式作为参数传递给办法：咱们调用了 greet 办法，并将一个 Lambda 表达式作为参数传递进去。Lambda 表达式 () -> System.out.println(“Hello, ” + “John!”) 定义了一个没有参数的匿名函数，它在执行时打印出一条问候音讯。
应用 Lambda 表达式作为函数接口的实现：咱们定义了四个不同的 Lambda 表达式，别离实现了加法、减法、乘法和除法运算。这些 Lambda 表达式都实现了 MathOperation 接口的 operation 办法，并在执行时返回相应的数学运算后果。
输入后果将是：
Hello, John!
10 + 5 = 15
10 - 5 = 5
10 * 5 = 50
10 / 5 = 2通过这个示例，你能够理解到 Lambda 表达式的根本语法和用法。你能够尝试在本人的代码中应用 Lambda 表达式，以简化和优化你的代码。
- 示例二：
public class LambdaExample {public static void main(String[] args) {
// 1. 无参数的 Lambda 表达式
Runnable runnable = () -> {System.out.println("Hello, Lambda!");
};
new Thread(runnable).start();
// 2. 带参数的 Lambda 表达式
Calculator add = (a, b) -> a + b;
Calculator subtract = (a, b) -> a - b;
int result1 = calculate(10, 5, add); // 输入：15
int result2 = calculate(10, 5, subtract); // 输入：5
System.out.println("Result 1:" + result1);
System.out.println("Result 2:" + result2);
// 3. 遍历汇合的 Lambda 表达式
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(name -> {System.out.println("Hello," + name);
});
// 4. 应用 Predicate 进行条件过滤
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> evenNumbers = filter(numbers, n -> n % 2 == 0);
System.out.println(evenNumbers); // 输入：[2, 4]
}
// 定义一个函数式接口
interface Calculator {int calculate(int a, int b);
}
// 应用 Lambda 表达式调用函数式接口
public static int calculate(int a, int b, Calculator calculator) {return calculator.calculate(a, b);
}
// 应用 Lambda 表达式进行过滤
public static List<Integer> filter(List<Integer> numbers, Predicate<Integer> predicate) {List<Integer> result = new ArrayList<>();
for (Integer number : numbers) {if (predicate.test(number)) {result.add(number);
}
}
return result;
}
}下面的示例展现了几个常见的 Lambda 表达式用法：
无参数的 Lambda 表达式：应用 Lambda 表达式创立一个 Runnable 接口实例，而后启动一个新线程来执行。
带参数的 Lambda 表达式：定义了一个函数式接口 Calculator，其中蕴含一个形象办法 calculate，而后通过 Lambda 表达式创立了两个 Calculator 对象，并在调用 calculate 办法时传入不同的 Lambda 表达式。
遍历汇合的 Lambda 表达式：应用 Lambda 表达式遍历 names 列表，并对每个元素进行自定义的操作。
应用 Predicate 进行条件过滤：应用 Lambda 表达式传递给 filter 办法，筛选出符合条件的元素。
通过这个示例，你能够学会如何应用 Lambda 表达式来简化代码、进步可读性，并使程序更具表达力。