Java Lambda 表达式

2025 年 4 月 21 日 | 阅读 11 分钟

Lambda 表达式是 Java SE 8 中引入的一项新且重要的特性。它提供了一种清晰简洁的方式，通过表达式来表示一个方法接口。它在集合库中非常有用。它有助于迭代、过滤和提取集合中的数据。

Lambda 表达式用于为具有函数式接口的接口提供实现。它节省了大量的代码。在 Lambda 表达式的情况下，我们不需要再次定义方法来提供实现。在这里，我们编写实现代码。

Java Lambda 表达式被视为一个函数，因此编译器不会创建 .class 文件。

函数式接口

Lambda 表达式提供了函数式接口的实现。只有一个抽象方法的接口称为函数式接口。Java 提供了一个注解 @FunctionalInterface，用于将接口声明为函数式接口。

@FunctionalInterface
interface MyFunctionalInterface {
    void myMethod(String s);
}

为什么要使用 Lambda 表达式？

Java 中的 Lambda 表达式有助于更简洁、更具表现力地实现函数式接口，从而消除冗长的模板代码并增强可读性。这个新库将函数式编程风格引入 Java，并将函数视为一流公民。Lambda 表达式独特地允许以函数式风格操作流集合，语法也得到了简化。

它们的灵活性在需要容器化行为并将其作为参数以便于模块化和易于维护的情况下也很明显。Lambda 表达式有助于提供匿名类的更紧凑的替代方案，从而简化代码并减少冗余。

此外，它们促进了并行编程结构的实现，并且总的来说，通过整洁、无错误的编码实践为消除 bug 提供了空间。

Java Lambda 表达式语法

Java Lambda 表达式由以下三个部分组成：

参数列表：它可以是空的，也可以是非空的。
箭头符号：它用于链接参数列表和表达式的体。
体：它包含 Lambda 表达式的表达式和语句。

无参数语法

() -> {
//Body of no parameter lambda
}

单参数语法

(p1) -> {
//Body of single parameter lambda
}

双参数语法

(p1,p2) -> {
//Body of multiple parameter lambda
}

让我们看一个不使用 Java Lambda 表达式实现的场景。在这里，我们将在不使用 Lambda 表达式的情况下实现一个接口。

没有 Lambda 表达式的接口

示例

interface Drawable{
	public void draw();
}
public class LambdaExpressionExample {
	public static void main(String[] args) {
		int width=10;

		//without lambda, Drawable implementation using anonymous class
		Drawable d=new Drawable(){
			public void draw(){System.out.println("Drawing "+width);}
		};
		d.draw();
	}
}

编译并运行

输出

Drawing 10

Java Lambda 表达式示例

现在，我们将使用 Java Lambda 表达式来实现上述示例。

示例

import java.util.Arrays;
import java.util.List;
public class LambdaExample {
    public static void main(String[] args) {
        // Create a list of integers
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        // Example 1: Using forEach with a lambda expression
        System.out.println("Example 1: Using forEach");
        numbers.forEach(number -> System.out.print(number + " "));
        System.out.println();  // New line for better output formatting
        // Example 2: Using map and reduce to calculate the sum of squares
        System.out.println("Example 2: Using map and reduce");
        int sumOfSquares = numbers.stream()
                                  .map(x -> x * x)
                                  .reduce(0, Integer::sum);
        System.out.println("Sum of squares: " + sumOfSquares);
        // Example 3: Using filter to get even numbers
        System.out.println("Example 3: Using filter");
        List<Integer> evenNumbers = numbers.stream()
                                          .filter(x -> x % 2 == 0)
                                          .toList();  // Convert stream to list (Java 16+)
        System.out.println("Even numbers: " + evenNumbers);
    }
}

输出

Example 1: Using forEach
1 2 3 4 5 6 7 8 9 10 
Example 2: Using map and reduce
Sum of squares: 385
Example 3: Using filter
Even numbers: [2, 4, 6, 8, 10]

Lambda 表达式可以具有零个或任意数量的参数。让我们看一些例子。

Java Lambda 表达式示例：无参数

示例

interface Sayable{
	public String say();
}
public class LambdaExpressionExample3{
public static void main(String[] args) {
	Sayable s=()->{
		return "I have nothing to say.";
	};
	System.out.println(s.say());
}
}

编译并运行

输出

I have nothing to say.

Java Lambda 表达式示例：单参数

示例

interface Sayable{
	public String say(String name);
}

public class LambdaExpressionExample4{
	public static void main(String[] args) {
	
		// Lambda expression with single parameter.
		Sayable s1=(name)->{
			return "Hello, "+name;
		};
		System.out.println(s1.say("Sonoo"));
		
		// You can omit function parentheses  
		Sayable s2= name ->{
			return "Hello, "+name;
		};
		System.out.println(s2.say("Sonoo"));
	}
}

编译并运行

输出

Hello, Sonoo
Hello, Sonoo

Java Lambda 表达式示例：多参数

示例

@FunctionalInterface
interface ThreeParametersFunctionalInterface {
    double calculateAverage(double a, double b, double c);
}
public class LambdaExample{
    public static void main(String[] args) {
        // Using lambda expression to implement the calculateAverage method
        ThreeParametersFunctionalInterface myLambda = (a, b, c) -> {
            // Code to be executed with the parameters
            return (a + b + c) / 3.0;
        };
        // Invoking the method defined in the lambda expression
        double average = myLambda.calculateAverage(10.0, 20.0, 30.0);
        System.out.println("Average: " + average);
    }
}

编译并运行

输出

Average: 20.0

Java Lambda 表达式示例：带 return 关键字

在 Java Lambda 表达式中，如果只有一个语句，你可以使用 return 关键字，也可以不使用。当 Lambda 表达式包含多个语句时，你必须使用 return 关键字。

示例

interface Addable{
	int add(int a,int b);
}

public class LambdaExpressionExample6 {
	public static void main(String[] args) {
		
		// Lambda expression without return keyword.
		Addable ad1=(a,b)->(a+b);
		System.out.println(ad1.add(10,20));
		
		// Lambda expression with return keyword.  
		Addable ad2=(int a,int b)->{
							return (a+b); 
						    };
		System.out.println(ad2.add(100,200));
	}
}

编译并运行

输出

30
300

Java Lambda 表达式示例：不带 return 关键字

示例

// Functional interface with a single abstract method
interface MyFunctionalInterface {
    int add(int a, int b);
}
public class LambdaExample {
    public static void main(String[] args) {
        // Lambda expression without using the return keyword
        MyFunctionalInterface addition = (a, b) -> a + b;
        // Using the lambda expression to perform addition
        int result = addition.add(5, 7);
        // Displaying the result
        System.out.println("Result of addition: " + result);
    }
}

编译并运行

输出

Result of addition: 12

Java Lambda 表达式示例：foreach 循环

示例

import java.util.*;
public class LambdaExpressionExample7{
	public static void main(String[] args) {
		
		List<String> list=new ArrayList<String>();
		list.add("ankit");
		list.add("mayank");
		list.add("irfan");
		list.add("jai");
		
		list.forEach(
			(n)->System.out.println(n)
		);
	}
}

编译并运行

输出

ankit
mayank
irfan
jai

Java Lambda 表达式示例：多个语句

示例

@FunctionalInterface
interface Sayable{
	String say(String message);
}

public class LambdaExpressionExample8{
	public static void main(String[] args) {
	
		// You can pass multiple statements in lambda expression
		Sayable person = (message)-> {
			String str1 = "I would like to say, ";
			String str2 = str1 + message; 
			return str2;
		};
			System.out.println(person.say("time is precious."));
	}
}

编译并运行

输出

I would like to say, time is precious.

Java Lambda 表达式示例：创建线程

你可以使用 Lambda 表达式来运行线程。在下面的示例中，我们使用 Lambda 表达式实现了 run 方法。

示例

public class LambdaExpressionExample9{
	public static void main(String[] args) {
	
		//Thread Example without lambda
		Runnable r1=new Runnable(){
			public void run(){
				System.out.println("Thread1 is running...");
			}
		};
		Thread t1=new Thread(r1);
		t1.start();
		//Thread Example with lambda
		Runnable r2=()->{
				System.out.println("Thread2 is running...");
		};
		Thread t2=new Thread(r2);
		t2.start();
	}
}

编译并运行

输出

Thread1 is running...
Thread2 is running...

Java Lambda 表达式可用于集合框架。它提供了一种高效且简洁的方式来迭代、过滤和获取数据。以下是一些 Lambda 和集合示例。

Java Lambda 表达式示例：比较器

示例

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
class Product{
	int id;
	String name;
	float price;
	public Product(int id, String name, float price) {
		super();
		this.id = id;
		this.name = name;
		this.price = price;
	}
}
public class LambdaExpressionExample10{
	public static void main(String[] args) {
		List<Product> list=new ArrayList<Product>();
		
		//Adding Products
		list.add(new Product(1,"HP Laptop",25000f));
		list.add(new Product(3,"Keyboard",300f));
		list.add(new Product(2,"Dell Mouse",150f));
		
		System.out.println("Sorting on the basis of name...");

		// implementing lambda expression
		Collections.sort(list,(p1,p2)->{
		return p1.name.compareTo(p2.name);
		});
		for(Product p:list){
			System.out.println(p.id+" "+p.name+" "+p.price);
		}

	}
}

编译并运行

输出

Sorting on the basis of name...
2 Dell Mouse 150.0
1 HP Laptop 25000.0
3 Keyboard 300.0

Java Lambda 表达式示例：过滤集合数据

示例

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream; 
class Product{
	int id;
	String name;
	float price;
	public Product(int id, String name, float price) {
		super();
		this.id = id;
		this.name = name;
		this.price = price;
	}
}
public class LambdaExpressionExample11{
	public static void main(String[] args) {
		List<Product> list=new ArrayList<Product>();
		list.add(new Product(1,"Samsung A5",17000f));
		list.add(new Product(3,"Iphone 6S",65000f));
		list.add(new Product(2,"Sony Xperia",25000f));
		list.add(new Product(4,"Nokia Lumia",15000f));
		list.add(new Product(5,"Redmi4 ",26000f));
		list.add(new Product(6,"Lenevo Vibe",19000f));
		
		// using lambda to filter data
		Stream<Product> filtered_data = list.stream().filter(p -> p.price > 20000);
		
		// using lambda to iterate through collection
		filtered_data.forEach(
				product -> System.out.println(product.name+": "+product.price)
		);
	}
}

编译并运行

输出

Iphone 6S: 65000.0
Sony Xperia: 25000.0
Redmi4 : 26000.0

Java Lambda 表达式示例：事件监听器

示例

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JTextField;
public class LambdaEventListenerExample {
	public static void main(String[] args) {
		JTextField tf=new JTextField();
		tf.setBounds(50, 50,150,20);
		JButton b=new JButton("click");
		b.setBounds(80,100,70,30);
		
		// lambda expression implementing here.
		b.addActionListener(e-> {tf.setText("hello swing");});
		
		JFrame f=new JFrame();
		f.add(tf);f.add(b);
		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		f.setLayout(null);
		f.setSize(300, 200);
		f.setVisible(true);

	}

}

输出

Lambda 表达式的优点

1. 可读性和简洁性

Lambda 表达式提供的更简洁的语法使编写匿名函数更加容易。这会产生更易于阅读和维护的代码，尤其是在使用函数式接口时。

// Without Lambda Expression
Runnable runnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("Without Lambda Expression");
    }
};

// With Lambda Expression
Runnable lambdaRunnable = () -> System.out.println("With Lambda Expression");

2. 支持函数式编程

Lambda 表达式促进了 Java 中函数式编程范式的采用。它们通过允许使用函数式接口以及集成 reduce、filter 和 map 等函数式工具，使代码更具表现力和函数性。

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
// Without Lambda Expression
names.forEach(new Consumer<String>() {
    @Override
    public void accept(String name) {
        System.out.println(name);
    }
});
// With Lambda Expression
names.forEach(name -> System.out.println(name));

3. 并行性和并发性

Lambda 表达式在处理这两个概念时尤其有用。它们可以轻松地使用 Streams API 在集合上执行并发操作。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
// Without Lambda Expression
int sumWithoutLambda = numbers.parallelStream().reduce(0, new BinaryOperator<Integer>() {
    @Override
    public Integer apply(Integer x, Integer y) {
        return x + y;
    }
});
// With Lambda Expression
int sumWithLambda = numbers.parallelStream().reduce(0, (x, y) -> x + y);

4. 行为封装

Lambda 表达式提供了一种便携且简洁的方式来表示行为。它们通过允许将行为作为参数传递给方法，提高了编程的模块化和灵活性。

// Without Lambda Expression
List<String> namesUpperCase = transformList(names, new StringTransformer() {
    @Override
    public String transform(String input) {
        return input.toUpperCase();
    }
});
// With Lambda Expression
List<String> namesUpperCaseLambda = transformList(names, input -> input.toUpperCase());   

5. 更好的集合迭代

通过消除模板代码并简化集合的迭代，Lambda 表达式提高了代码的可读性。

List<String> fruits = Arrays.asList("Apple", "Banana", "Orange");
// Without Lambda Expression
for (String fruit : fruits) {
    System.out.println(fruit);
}
// With Lambda Expression
fruits.forEach(fruit -> System.out.println(fruit));

Lambda 表达式的缺点

1. 仅限于函数式接口

Lambda 表达式仅适用于函数式接口，后者仅包含一个抽象方法。此限制使其仅适用于特定场景，如果您需要与包含多个抽象方法的接口进行交互，这可能会有问题。

// Example of an interface with more than one abstract method
interface MultiAbstractMethodInterface {
    void method1();
    void method2();
}
// Lambda expression cannot be used with MultiAbstractMethodInterface
// as it violates the "Functional Interface" requirement

2. 复杂推理的可读性问题

Lambda 表达式对于简短、简单的过程很有用，但当应用于更复杂的推理时，它们可能会变得不那么易读。在某些情况下，使用其他类或更传统的方法可能更合适。

// Lambda expression with complex logic
Function<Integer, Integer> complexLambda = x -> {
    // Complex logic here
    return x * x + 2 * x + 1;
};

3. 调试

Lambda 表达式可能难以调试，特别是当它们很复杂或包含多个抽象级别时。堆栈跟踪有时无法精确定位 Lambda 表达式中问题的确切位置。

// Debugging lambda expressions
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(name -> {
    System.out.println(name);
    int length = name.length(); // Debugging this line might not clearly indicate issues
});

4. 状态管理困难

Lambda 表达式没有状态，是无状态的。因此，处理可变状态和捕获封闭范围的变量可能会很困难，尤其是在处理并发或并行流时。

// Managing state in lambda expressions
AtomicInteger count = new AtomicInteger(0);
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
numbers.forEach(n -> {
    count.incrementAndGet(); // Manipulating shared mutable state within lambda expressions
});

5. 特定情况下的性能开销

尽管 Lambda 表达式已针对现代 Java 运行时系统进行了优化，但在某些情况下，使用 Lambda 表达式可能会导致轻微的性能开销。虽然这通常对大多数应用程序无关紧要，但在性能至关重要的情况下应予以考虑。

// Example of a performance overhead (negligible in most cases)
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

// Without Lambda Expression
int sumWithoutLambda = numbers.parallelStream().reduce(0, new BinaryOperator<Integer>() {
    @Override
    public Integer apply(Integer x, Integer y) {
        return x + y;
    }
});

// With Lambda Expression
int sumWithLambda = numbers.parallelStream().reduce(0, (x, y) -> x + y);

Java Lambda 表达式选择题

1. Lambda 表达式在 Java 中的一个关键特性是什么？

它们主要用于异常处理。
它们通过允许将函数作为参数传递来实现函数式编程。
它们用于对象序列化。
它们取代了所有匿名内部类。

答案：B

解释： Lambda 表达式通过允许将函数作为参数传递，使 Java 代码更简洁、更具可读性，从而实现函数式编程。

2. Lambda 表达式必须实现哪个接口？

Serializable
Runnable
FunctionalInterface
Cloneable

答案：C

解释： Lambda 表达式必须实现一个函数式接口，即只有一个抽象方法的接口。

3. 如何在 Java 中表示 Lambda 表达式 (int x, int y) -> x + y？

作为方法引用
作为匿名类
作为函数式接口实现
作为 Lambda 表达式

答案：D

解释： 表达式 (int x, int y) -> x + y 是一个 Lambda 表达式，它接受两个整数参数并返回它们的和。

4. 哪个 Java 包包含与 Lambda 表达式一起使用的 Function 接口？

java.lang
java.util
java.util.function
java.io

答案：C

解释： Function 接口以及与其他 Lambda 表达式一起使用的功能性接口都包含在 java.util.function 包中。

5. 以下 Lambda 表达式的作用是什么：() -> System.out.println("Hello")？

它定义了一个 Runnable 接口。
它创建了一个线程。
调用时会打印 "Hello"。
它返回字符串 "Hello"。

答案：C

解释： Lambda 表达式 () -> System.out.println("Hello") 是一个无参数表达式，调用时会打印 "Hello"。

下一主题Java 8 方法引用

Java Lambda 表达式

函数式接口

为什么要使用 Lambda 表达式？

Java Lambda 表达式语法

没有 Lambda 表达式的接口

示例

Java Lambda 表达式示例

示例

Java Lambda 表达式示例：无参数

示例

Java Lambda 表达式示例：单参数

示例

Java Lambda 表达式示例：多参数

示例

Java Lambda 表达式示例：带 return 关键字

示例

Java Lambda 表达式示例：不带 return 关键字

示例

Java Lambda 表达式示例：foreach 循环

示例

Java Lambda 表达式示例：多个语句

示例

Java Lambda 表达式示例：创建线程

示例

Java Lambda 表达式示例：比较器

示例

Java Lambda 表达式示例：过滤集合数据

示例

Java Lambda 表达式示例：事件监听器

示例

Lambda 表达式的优点

Lambda 表达式的缺点

Java Lambda 表达式选择题

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java 教程

控制语句

Java Object 类

Java 继承

Java 多态

Java 抽象

Java 封装

Java 数组

Java OOPs 杂项

Java 字符串

Java 正则表达式

异常处理

Java 内部类

Java 多线程

Java 同步

Java I/O

Java 文件处理

Java 序列化

Java 网络

Java 反射

Java 集合

Java 5 特性

Java 8 特性

Java JDBC

RMI

国际化

Java 项目

Java Lambda 表达式

函数式接口

为什么要使用 Lambda 表达式？

Java Lambda 表达式语法

没有 Lambda 表达式的接口

示例

Java Lambda 表达式示例

示例

Java Lambda 表达式示例：无参数

示例

Java Lambda 表达式示例：单参数

示例

Java Lambda 表达式示例：多参数

示例

Java Lambda 表达式示例：带 return 关键字

示例

Java Lambda 表达式示例：不带 return 关键字

示例

Java Lambda 表达式示例：foreach 循环

示例

Java Lambda 表达式示例：多个语句

示例

Java Lambda 表达式示例：创建线程

示例

Java Lambda 表达式示例：比较器

示例

Java Lambda 表达式示例：过滤集合数据

示例

Java Lambda 表达式示例：事件监听器

示例

Lambda 表达式的优点

Lambda 表达式的缺点

Java Lambda 表达式选择题