请教Java中的Lambda表达式有什么用？

最新推荐文章于 2025-06-05 22:48:03 发布
原创 最新推荐文章于 2025-06-05 22:48:03 发布 · 2.4k 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Java #Lambda

本文通过实测对比了Java中使用Lambda表达式与其他传统循环、迭代器及多线程处理方式在性能上的表现。实验涉及随机数过滤、最大值查找等场景，结果显示Lambda及其流操作并未带来显著的性能提升。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1、问题

不明白Java为什么要引入Lambda表达式。只有在很少的情况下用它来替换匿名类可能会少那么三、四行代码，可是，我们成千上万的代码都写了，谁会在乎这么一点呢？并且，Lambda表达式限制条件比匿名类多，匿名类它是类，类是面向对象语言的核心，它比Lambda表达式功能强多了。

Lambda与性能也没有什么关系。想提高性能要优化算法、充分利用计算资源，与Lambda表达式有什么关系呢？

还有说引入面向函数式编程思想，这个也没看出来。

2、测试结果

首先做个测试。用随机数填充集合，然后遍历集合，取出能被2整除的数字并保存在中间结果中，再从中间结果取出最大的数。分别用了迭代器、外循环、内循环、集合普通流、集合并行流、自定义多线程，结果如下：

使用lambda表达式后，代码没变少、没更可读、性能也没更高。最后一种方式因为要自己处理多线程问题，代码量变多。但自已实现的话好像更加灵活。

3、代码

第一种迭代器：

package com.xxxxxx.test;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.Random;

public class Lambda0 {

	private ArrayList<Integer> srcArray = new ArrayList<Integer>();

	public static void main(String[] args) {
		// 初始化srcArray数组
		Lambda0 lam0 = new Lambda0();
		Random rand = new Random();
		for (int i = 0; i < 100000; i++) {
			lam0.srcArray.add(rand.nextInt(100000));
		}
		// 开始计时
		long start = System.currentTimeMillis();
		// midArray用来保存中间结果
		ArrayList<Integer> midArray = new ArrayList<Integer>();
		Iterator<Integer> iter = lam0.srcArray.iterator();
		// 使用迭代器
		while (iter.hasNext()) {
			// 这个循环用来消耗时间
			for (int l = 0; l < 1000000; l++) {
				if ((l % 2) == 0) {
					l = l * 2;
					l = l / 2;
				}
			}
			// 将srcArray中能被2整除的数放在midArray数组中
			Integer value = iter.next();
			if ((value % 2) == 0) {
				midArray.add(value);
			}
		}
		// 从midArray中找出最大的整数
		class Max {
			public int value = 0;
		}
		Max max = new Max();
		// 使用迭代器
		iter = midArray.iterator();
		while (iter.hasNext()) {
			Integer value = iter.next();
			if (value > max.value) {
				max.value = value;
			}
		}
		// 计时结束
		long end = System.currentTimeMillis();
		// 输出结果
		System.out.println("[Max]" + max.value + ",[time]" + (end - start));
	}
}

第二种外循环：

package com.xxxxxx.test;

import java.util.ArrayList;
import java.util.Random;

public class Lambda1 {

	private ArrayList<Integer> srcArray = new ArrayList<Integer>();

	public static void main(String[] args) {
		// 初始化srcArray数组
		Lambda1 lam1 = new Lambda1();
		Random rand = new Random();
		for (int i = 0; i < 100000; i++) {
			lam1.srcArray.add(rand.nextInt(100000));
		}
		// 开始计时
		long start = System.currentTimeMillis();
		// midArray用来保存中间结果
		ArrayList<Integer> midArray = new ArrayList<Integer>();
		for (Integer i : lam1.srcArray) {
			// 这个循环用来消耗时间
			for (int l = 0; l < 1000000; l++) {
				if ((l % 2) == 0) {
					l = l * 2;
					l = l / 2;
				}
			}
			// 将srcArray中能被2整除的数放在midArray数组中
			if ((i % 2) == 0) {
				midArray.add(i);
			}
		}
		// 从midArray中找出最大的整数
		Integer max = 0;
		for (Integer i : midArray) {
			if (i > max) {
				max = i;
			}
		}
		// 计时结束
		long end = System.currentTimeMillis();
		// 输出结果
		System.out.println("[Max]" + max + ",[time]" + (end - start));
	}
}

第三种内循环：

package com.xxxxxx.test;

import java.util.ArrayList;
import java.util.Random;

public class Lambda2 {

	private ArrayList<Integer> srcArray = new ArrayList<Integer>();

	public static void main(String[] args) {
		// 初始化srcArray数组
		Lambda2 lam2 = new Lambda2();
		Random rand = new Random();
		for (int i = 0; i < 100000; i++) {
			lam2.srcArray.add(rand.nextInt(100000));
		}
		// 开始计时
		long start = System.currentTimeMillis();
		// midArray用来保存中间结果
		ArrayList<Integer> midArray = new ArrayList<Integer>();
		lam2.srcArray.forEach((i) -> {
			// 这个循环用来消耗时间
			for (int l = 0; l < 1000000; l++) {
				if ((l % 2) == 0) {
					l = l * 2;
					l = l / 2;
				}
			}
			// 将srcArray中能被2整除的数放在midArray数组中
			if ((i % 2) == 0) {
				midArray.add(i);
			}
		});
		// 从midArray中找出最大的整数
		class Max {
			public int value = 0;
		}
		Max max = new Max();
		// 直接使用Integer max = 0不行
		midArray.forEach((i) -> {
			if (i > max.value) {
				max.value = i;
			}
		});
		// 计时结束
		long end = System.currentTimeMillis();
		// 输出结果
		System.out.println("[Max]" + max.value + ",[time]" + (end - start));
	}
}

第四种集合stream：

package com.xxxxxx.test;

import java.util.ArrayList;
import java.util.Random;

public class Lambda3 {

	private ArrayList<Integer> srcArray = new ArrayList<Integer>();

	public static void main(String[] args) {
		// 初始化srcArray数组
		Lambda3 lam3 = new Lambda3();
		Random rand = new Random();
		for (int i = 0; i < 100000; i++) {
			lam3.srcArray.add(rand.nextInt(100000));
		}
		// 开始计时
		long start = System.currentTimeMillis();
		// midArray用来保存中间结果，流处理不需要
		// ArrayList<Integer> midArray = new ArrayList<Integer>();
		class Max {
			public int value = 0;
		}
		Max max = new Max();
		// 普通流
		lam3.srcArray.stream().filter((i) -> {
			// 这个循环用来消耗时间
			for (int l = 0; l < 1000000; l++) {
				if ((l % 2) == 0) {
					l = l * 2;
					l = l / 2;
				}
			}
			if ((i % 2) == 0) {
				return true;
			} else {
				return false;
			}
		}).forEach((i) -> {
			// 从流中找出最大的整数
			if (i > max.value) {
				max.value = i;
			}
		});
		// 计时结束
		long end = System.currentTimeMillis();
		// 输出结果
		System.out.println("[Max]" + max.value + ",[time]" + (end - start));
	}
}

第五种集合并行stream：

package com.xxxxxx.test;

import java.util.ArrayList;
import java.util.Random;

public class Lambda4 {

	private ArrayList<Integer> srcArray = new ArrayList<Integer>();

	public static void main(String[] args) {
		// 初始化srcArray数组
		Lambda4 lam4 = new Lambda4();
		Random rand = new Random();
		for (int i = 0; i < 100000; i++) {
			lam4.srcArray.add(rand.nextInt(100000));
		}
		// 开始计时
		long start = System.currentTimeMillis();
		// midArray用来保存中间结果，流处理不需要
		// ArrayList<Integer> midArray = new ArrayList<Integer>();
		class Max {
			public int value = 0;
		}
		Max max = new Max();
		// 并发流
		lam4.srcArray.parallelStream().filter((i) -> {
			// 这个循环用来消耗时间
			for (int l = 0; l < 1000000; l++) {
				if ((l % 2) == 0) {
					l = l * 2;
					l = l / 2;
				}
			}
			if ((i % 2) == 0) {
				return true;
			} else {
				return false;
			}
		}).forEach((i) -> {
			// 从流中找出最大的整数
			if (i > max.value) {
				max.value = i;
			}
		});
		// 计时结束
		long end = System.currentTimeMillis();
		// 输出结果
		System.out.println("[Max]" + max.value + ",[time]" + (end - start));
	}
}

第六种自定义多线程：

package com.xxxxxx.test;

import java.util.ArrayList;
import java.util.Random;
import java.util.concurrent.CountDownLatch;

public class Lambda5 {

	private ArrayList<Integer> srcArray = new ArrayList<Integer>();

	public static void main(String[] args) {
		// 初始化srcArray数组
		Lambda5 lam5 = new Lambda5();
		Random rand = new Random();
		for (int i = 0; i < 100000; i++) {
			lam5.srcArray.add(rand.nextInt(100000));
		}
		// 取得CPU核数，本机是4核
		int nThreads = Runtime.getRuntime().availableProcessors();
		// 用于等待多线和结束
		final CountDownLatch threadsCount = new CountDownLatch(nThreads);
		// 实现Runnable的内部类
		class MyRunnable implements Runnable {
			int start = 0;
			int end = 0;
			Integer max = 0;
			MyRunnable(int start, int end) {
				this.start = start;
				this.end = end;
			}
			public void run() {
				// midArray用来保存中间结果
				ArrayList<Integer> midArray = new ArrayList<Integer>();
				ArrayList<Integer> tempArray = new ArrayList<Integer>(lam5.srcArray.subList(start, end));
				for(Integer i : tempArray) {
					// 这个循环用来消耗时间
					for (int l = 0; l < 1000000; l++) {
						if ((l % 2) == 0) {
							l = l * 2;
							l = l / 2;
						}
					}
					if ((i % 2) == 0) {
						midArray.add(i);
					}
				}
				for (Integer i : midArray) {
					if (i > max) {
						max = i;
					}
				}
				threadsCount.countDown(); 
			}
		}
		// 开始计时
		long start = System.currentTimeMillis();
		// 有可能出现小数，因此加1补足
		int step = lam5.srcArray.size() / nThreads + 1;
		// 保存线程对象
		ArrayList<MyRunnable> threadsArrayList = new ArrayList<MyRunnable>();  
		for(int i = 0; i < nThreads; i ++) {
			int startIndex = i * step;
			int endIndex = (i + 1) * step < lam5.srcArray.size() ? (i + 1) * step : lam5.srcArray.size();
			MyRunnable temp = new MyRunnable(startIndex, endIndex);
			threadsArrayList.add(temp);
			new Thread(temp).start();
		}
		// 等待所有线和结束
		try {
			threadsCount.await();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		// 找出最大整数
		int max = 0;
		for (MyRunnable i : threadsArrayList) {
			if (i.max > max) {
				max = i.max;
			}
		}
		// 计时结束
		long end = System.currentTimeMillis();
		// 输出结果
		System.out.println("[Max]" + max + ",[time]" + (end - start));
	}
}

 

Java团队元老亲授，跟着大神学JAVA！
人邮异步社区
02-12 489
9.9元秒杀！Java团队元老亲自授课，跟着大神学JAVA！ 原创 异步社区 来源 | 异步 本期9.9元限时秒杀，异步君给苦于Java瓶颈期的大家推荐《Java编程15讲》！ 作者：郭屹 共15个讲义，限时9.9元秒杀 15讲能学好诞生24年的JAVA吗？你当然会感到怀疑，众所周知，在技术向的IT论坛上，“如何在十天之内快速掌握好Java？”这类问题，往往会招来嘲笑。 来源于知乎 但在当下...
MVC图片上传详解 IIS (安装SSL证书后) 实现 HTTP 自动跳转到 HTTPS C#中Enum用法小结 表达式目录树 “村长”教你测试用例 引用provinces.js的三级联动...
热门推荐
01-10 3万+
MVC图片上传详解 MVC图片上传--控制器方法 新建一个控制器命名为File,定义一个Img方法 [HttpPost]public ActionResult Img(HttpPostedFileBase shangchuan){string path = @"\upload\" + DateTime.Now.ToFileTime() + ".jpg";Session...
常用Lamda表达式以及其使用过程中容易引发故障的点
weixin_42924400的博客
05-16 973
本文用到的实体类都在下面。
JAVA中传统接口形式_对比讲解lambda表达式与传统接口函数实现方式
weixin_33740713的博客
02-24 386
在本号之前写过的一些文章中，笔者使用了lambda表达式语法，一些读者反映说代码看不懂。本以为java 13都已经出了，java 8中最重要特性lambda表达式大家应该都掌握了，实际上还是存在大量的程序员没有使用java8，还有的使用了java8也不会使用lambda表达式。所以，写这篇文章还是有必要的，如果您觉得我的文章对您有帮助，期待您的关注。Lambda表达式是Java 8最流行最常用的功...
JAVA之 Lambda
最新发布
aningxiaoxixi的博客
06-05 623
其核心思想是将行为作为参数传递，替代匿名内部类，提升代码的简洁性和可读性。Lambda 表达式是 Java 8 的核心特性，通过。的实例，编译时自动转换为接口实现。或等效不可变的局部变量（隐式。Lambda 可访问。
Java中Lambda 表达式有何用处？如何使用？
qq_42977042的博客
03-07 827
1.什么是Lambda? 我们知道，对于一个Java变量，我们可以赋给其一个 “值”。 如果你想把“一块代码”赋给一个Java变量，应该怎么做呢？ 比如，我想把右边那块代码，赋给一个叫做aBlockOfCode的Java变量： 在Java 8之前，这个是做不到的。但是Java 8问世之后，利用Lambda特性，就可以做到了。 当然，这个并不是一个很简洁的写法。所以，为了使这个赋值操作更加el...
关于lambda表达式的几个疑问
我想吃红薯的博客
07-13 287
疑问一：如何使用lambda表达式 创建一个Student类，不实现Comparable接口。 public class Student { private String name; private Integer age; public String getName() { return name; } public void setName(String...
Java中的lambda表达式
qq_73333296的博客
05-07 226
一、基本概念1.背景Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。Lambda 表达式（Lambda expression）可以看作是一个匿名函数，基于数学中的λ演算得名，也可称为闭包（Closure）2.Lambda表达式的语法基本语法: ->{代码块}Lambda表达式由三部分组成->前为形参。
【Java面试】如何系统准备秋招？献上一份超硬核Java学习路线图+学习资源，拿走不谢！！
weixin_66896902的博客
09-03 631
Servlet生命周期；Servlet上下文；多关注技术大佬的博客发布的技术文章，多看过来人分享的学习经验，最好养成自己写博客的习惯，刚开始当做做笔记，巩固学到的内容。现在这个群已经变得非常活跃，经常有大佬在群里面解答问题，也有很多初学Java互相交流学习问题，很多参加了校招，面试分享自己得到的经验，以及被问到的面试题。Spring上下文；有些在招收应届生的时候，不少中小公司甚至在“项目经验”方面没要求，哪怕没学习项目经验也不要紧，只会问些网上比较大路的面试题，能说上来即可。JDBC模板配置应用；
Java-回调函数
花无名
08-24 720
Java lambda 回调函数 回调接口 lambda表达式
Java期末考试试卷及相关解释
01-15
在进阶特性方面，可能会测试考生对泛型、集合框架（如ArrayList、LinkedList、HashMap、TreeMap等）、枚举、注解、Lambda表达式以及Stream API的理解和应用。这些特性使得Java能够处理更复杂的数据结构和编写更简洁...
Java中的Lambda表达式
LiuMM101的博客
05-19 493
Lambda表达式概述： Lambda表达式是一种语法，是一个匿名函数，是对匿名函数的简写形式，我们可以把 Lambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递），可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升； Lambda表达式语法： ()：小括号表示抽象方法的参数 ->：固定写法，箭头将Lambda表达式分为左右两部分，左边写的是实现的这个接口中抽象方法中的形参列表，右边就是对抽象方法的处理； ...
Java6有lambda吗_Java8 -Lambda表达式(6)
weixin_39947961的博客
02-25 134
1.复合Lambda表达式的有用方法Java8的好几个函数式接口都有为方便而设计的方法。具体而言，许多函数式接口，比如用于传递Lambda表达式的Comparator、Function和Predicate都提供了允许你进行复合的方法。这是什么意思呢？在实践中，这意味着你可以把多个简单的Lambda复合成为复杂的表达式。比如，你可以让两个谓词之间做一个or操作，组合成为了一个更大的谓词。而且，你还可...
【Java】：lambda 表达式
island1314的博客
11-27 1万+
📃1. 背景 🚀🔥Lambda表达式 是JDK8新增的特性，Lambda表达式 可以取代大部分匿名内部类，写出更优雅的Java代码，尤其在集合的遍历和其他集合操作中，可以将函数作为一个方法的参数，也就是函数作为参数传递到方法中，极大地优化代码结构JDK也提供了大量的内置函数式接口供开发者使用，使得Lambda表达式 的运用更加方便、高效。Lambda2. 基本使用 🖊🥑 1. 语法格式🎈 Lambda表达式的基本语法：由组成类似方法中的形参列表，这里的参数是函数式接口里的参数。
Lambda表达式(JAVA基础)
ZangLing的博客
02-28 1369
一.基本语法 二.实现函数接口 三.引用方法创建线程 四.操作集合 五.闭包问题
Lambda表达式注意事项
先学再说
06-27 5567
1.Lambda表达式本身无类型。即不存在直接访问内部成员，所以“.”运算符对于lambda表达式是没有意义的。 如： Type type=((int x)=>x).ToString(); //Error .运算符不适用于Lambda表达式类型的操作数 2.lambda表达式无类型，也不能放在is运算符的左侧。 如：bool b=((int x)=>x) is Func; /
Lambda表达式和匿名内部类
weixin_30787531的博客
07-24 372
例1：无参函数的简写 如果需要新建一个线程，一种常见的写法是这样： // JDK7 匿名内部类写法 new Thread(new Runnable(){// 接口名 @Override public void run(){// 方法名 System.out.println("Thread run()"); } }).start(); ...
Lambda 表达式带来的复杂性的破解之道
明明如月的技术博客
11-27 2862
一、背景 几年前和多人会提 “Java 8 的新特性”，现在 Java 8 几乎成了标配。 曾经很多人抵触 Lambda 表达式，现在几乎也成了标配。 实际开发中最常见的是，很多人使用 Stream 来处理集合类。 二、看法 对于 Lambda 表达式或者 Stream 的看法不尽一致。 2.1 支持 使用 Lambda 表达式可以减少类或者方法的常见。 使用 Stream 可以享受链式编程的乐趣。 有些人看别人都在用，似乎有些高端，或者担心自己被淘汰也跟着大量使用。 2.2 反对 有些人对 lambda
lambda表达式
作为一个既爱敲代码又享受生活的码农，我希望通过这个平台，在编程与大家一起成长！
12-17 2297
lambda表达式的快速入门！
如何在Java中使用Lambda表达式简化代码？
09-09
在Java中，Lambda表达式提供了一种简洁的方式来表示只包含一个方法的接口（也称为函数式接口）的实例。Lambda表达式可以极大地简化代码，特别是当你使用匿名内部类时。Lambda表达式的基本语法是： ``` (parameters) -> expression 或 (parameters) -> { statements; } ``` 下面是一个使用Lambda表达式简化代码的例子： 假设我们有一个`Comparator`接口的匿名内部类实例，用于比较两个字符串的长度： ```java Comparator<String> comparator = new Comparator<String>() { @Override public int compare(String s1, String s2) { return Integer.compare(s1.length(), s2.length()); } }; ``` 使用Lambda表达式，可以将上述匿名内部类替换为以下形式的代码： ```java Comparator<String> comparator = (s1, s2) -> Integer.compare(s1.length(), s2.length()); ``` 这个Lambda表达式替代了原有的`compare`方法的实现，使得代码更加简洁明了。 Lambda表达式还允许你直接使用方法引用和构造函数引用，进一步简化代码。例如，如果你想对一个列表进行排序，使用Lambda表达式可以写为： ```java List<String> list = Arrays.asList("Apple", "Orange", "Banana", "Pear"); list.sort((s1, s2) -> s1.compareTo(s2)); ``` 或者，使用方法引用来进一步简化： ```java list.sort(String::compareTo); ``` 在Java 8及以后的版本中，Lambda表达式配合Stream API可以实现更加流畅和高效的数据处理： ```java List<String> fruits = list.stream() .filter(f -> f.startsWith("A")) .map(String::toUpperCase) .collect(Collectors.toList()); ``` 这里使用了`filter`和`map`方法的Lambda表达式，对列表进行过滤和转换，然后收集结果。 使用Lambda表达式的好处是代码更加简洁，并且能够提高代码的可读性和可维护性。但是，需要注意的是Lambda表达式只适用于函数式接口，这些接口只能有一个抽象方法。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值