java8中的22个lambda表达式用法入门

最新推荐文章于 2024-10-30 23:35:37 发布
最新推荐文章于 2024-10-30 23:35:37 发布
阅读量299 收藏 2
点赞数 5
分类专栏： Java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/freellf/article/details/128358570
版权
本文介绍了如何利用Java的lambda表达式进行集合操作，涉及过滤、映射、peek、扁平化、限制和跳过等中间型操作，以及计数、查找最大值、最小值等最终型操作，展示了其在简化代码和处理数据方面的强大功能。

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

/**
 * lambda表达式简明扼要的以流水线的方式云处理集合内的数据，可以很轻松的完成过滤，分组，收集、归约这类操作。
 * 总得来说，lambda的操作分为两类，中间型和最终型。
 * 
 */
public class LambdaExpression {

	public static void main(String[] args) {
        
		//中间型操作
		filter(Lists.newArrayList("frist", "second", "third"));
		map(Lists.newArrayList(1, 2, 3));
		peek(Lists.newArrayList("a", "b", "c"));
		flatMap(Lists.newArrayList("hell", "word"));
		limit(Lists.newArrayList("hello", "world", "good", "boy"));
		skip(Lists.newArrayList("hello", "world", "good", "boy"));
		concat();
		distinct(Lists.newArrayList("1", "2", "3", "2", "4", "5", "5"));
		sorted(Lists.newArrayList("1", "5", "3", "7", "4", "9", "2"));
		//test();
		
		//最终型操作
		
		count(Lists.newArrayList("1", "3", "5", "6"));
		max(Lists.newArrayList("1", "3", "5", "10"));
		min(Lists.newArrayList("4", "3", "5", "6"));
		findFirst(Lists.newArrayList("10", "3", "5", "6"));
		findAny();
		anyMatch(Lists.newArrayList("10", "3", "5", "6"));
		allMatch(Lists.newArrayList("10", "3", "5", "6", "3"));
		noneMatch(Lists.newArrayList("10", "3", "5", "6", "3"));
		collect(Lists.newArrayList("10", "3", "5", "6", "3"));
		reduce();
		toArray(Lists.newArrayList("10", "3", "5", "6", "3"));
		lterator(Lists.newArrayList("10", "3", "5", "6", "3"));
		foreach(Lists.newArrayList("10", "3", "5", "6", "3"));
	}

	private static void test(){
		ArrayList<String> dataList = Lists.newArrayList("hello", "world", "good", "boy");
		List<String> transform = dataList.stream().flatMap(data -> Arrays.stream(data.split(""))).distinct().collect(Collectors.toList());
		System.out.println(JSON.toJSONString(transform));
	}
	
	// 1, filter
	// filter会按照指定的条件匹配出符合要求的元素，并返回一个新的stream流，可以配合其他中间型或最终型API使用.
	// 示例：
	public static void filter(List<String> dataList) {
		List<String> filter = dataList.stream()
				.filter(
						// 筛选出值为second的匹配项
						data -> data.equals("second"))
				.collect(Collectors.toList());
		System.out.println(filter);
	}

	// 2, map
	// map可以将一个对象转换为另一个对象，并返回一个新的stream流，比如将一个integer对象转换为String对象。
	// 示例：
	public static void map(List<Integer> dataList) {
		List<String> transform = dataList.stream()
				.map(
						// 也可以写成String::valueOf
						data -> String.valueOf(data))
				.collect(Collectors.toList());
		System.out.println(transform);
	}

	// 3, peek
	// peek会对流中的元素逐个遍历处理， 它与map的区别在于: map一般用于对象的转换， peek用于对象的消费，即不改变元素本身的类型。
	// 示例
	public static void peek(List<String> dataList) {
		List<String> transform = dataList.stream()
				// peek是对元素逐一消费，在这里程序会逐个打印a, b, c
				.peek(data -> System.out.println(data))
				// map是对元素进行转换，这里将其转写成大写A， B， C
				.map(data -> data.toUpperCase()).collect(Collectors.toList());
		System.out.println(transform);
	}

	// 4, flatMap
	// flatMap可以将已有的对象转化为另一个对象，它是一个一对多的逻辑。它与map的区别在于:
	// map是一对一的，即将一个对象转换为别一个对象，而flatMap是一对多的，即将一个对象拆分为多个对象。
	public static void flatMap(List<String> dataList) {
		List<String> transform = dataList.stream().flatMap(data -> Arrays.stream(data.split("")))
				.collect(Collectors.toList());
		System.out.println(transform);
	}

	// 5, limit
	// 就相当于sql中的limit, 可以指定保留前N的元素。
	public static void limit(List<String> dataList) {
		List<String> transform = dataList.stream().limit(2).collect(Collectors.toList());
		System.out.println(transform);
	}

	// 6, skip
	// 作用与limit相反， 会抛弃前N的元素
	public static void skip(List<String> dataList) {
		List<String> transform = dataList.stream().skip(2).collect(Collectors.toList());
		System.out.println(transform);
	}

	// 7, concat
	// 可以将多个流的数据合并为一个流
	public static void concat() {
		List<String> transform = Stream.concat(Stream.of("hello"), Stream.of("world")).collect(Collectors.toList());
		System.out.println(transform);
	}
	
	//8, distinct
	//用于对流中的元素去重
	public static void distinct(ArrayList<String> dataList){
		List<String> transform = dataList.stream().distinct().collect(Collectors.toList());
		System.out.println(transform);
	}
	
	//9, sorted
	//用于对流中的数据排序
	public static void sorted(ArrayList<String> dataList){
		List<String> transform = dataList.stream().sorted(
				Comparator.comparingInt(Integer :: parseInt)).collect(Collectors.toList());
		System.out.println(transform);
	}
	
	
	//10, count
	//统计元素的个数，不会自动去重
    public static void count(ArrayList<String> dataList) {
    	long count = dataList.stream().count();
    	System.out.println(count);
    }	
	
    //11, max
    //匹配元素最大值并返回
    public static void max(ArrayList<String> dataList) {
    	String max = dataList.stream().max(
    			Comparator.comparing(Integer::parseInt)).get();
    	System.out.println(max);
    }	
	
    //12, min
    //匹配元素最小值并返回
    public static void min(ArrayList<String> dataList) {
    	String min = dataList.stream().min(
    			Comparator.comparing(Integer::parseInt)).get();;
    	System.out.println(min);
    }
    
    //13, findFirst
    //找到第一匹配的元素后立即返回
    public static void findFirst(ArrayList<String> dataList) {
    	String first = dataList.stream().findFirst().get();
    	System.out.println(first);
    }
    
    //14, findAny
    //找到任何匹配的元素就返回。如果用在一个串行流中，跟findFirst效果一样。如果用在并行流中，就会比较高效。
    public static void findAny() {
        int asInt = IntStream.range(1, 10).parallel().findAny().getAsInt();
    	System.out.println(asInt);
    }
    
    //15, anyMatch
    //用于判断是否符合匹配条件的元素
    public static void anyMatch(ArrayList<String> dataList){
    	boolean match = dataList.stream().anyMatch(
    			data -> data.equals("3"));
    	System.out.println(match);
    }
    
    //16, allMatch
    //用于判断是否所有元素都符合匹配条件。
    public static void allMatch(ArrayList<String> dataList){
    	boolean match = dataList.stream().allMatch(
    			data -> data.equals("3"));
    	System.out.println(match);
    }
    

    //17, noneMatch
    //用于判断是否所有元素都不符合匹配条件
    public static void noneMatch(ArrayList<String> dataList){
    	boolean match = dataList.stream().noneMatch(
    			data -> data.equals("3"));
    	System.out.println(match);
    }
	
    //18, collect
    //将流转换为指定的类型， 比如List转换为Set
    public static void collect(ArrayList<String> dataList) {
    	Set<String> collect = dataList.stream().collect(Collectors.toSet());
    	System.out.println(collect);
    }
	
    //19, reduce
    //将元素合并起来，得到一个新值
    public static void reduce(){
    	int reduce = IntStream.range(0,  10).reduce(0,  (v1, v2) -> v1 + v2);
    	System.out.println(reduce);
    }
	
	//20, toArray
    public static void toArray(ArrayList<String> dataList){
    	Object[] collect = dataList.stream().toArray();
    	System.out.println(JSON.toJSONString(collect));
    }
    
    //21, lterator
    //将流转换为一个迭代器
    public static void lterator(ArrayList<String> dataList){
    	Iterator<String> iterator = dataList.stream().iterator();
    	while(iterator.hasNext())
    	{
    		System.out.println(iterator.next());
    	}
    }
    
    //22, foreach
    //对流中的元素逐个遍历
    public static void foreach(ArrayList<String> dataList){
    	dataList.stream().forEach(
    			data -> System.out.println(data));
    	
    	//等同
    	dataList.forEach(data -> System.out.println(data));
    }

Java 入门指南：Java 8 新特性 —— Lambda 表达式
热带鱼的技术博客
09-21 1570
Java Lambda 表达式是 Java 8 引入的一个功能，它允许以更简洁的方式编写函数式接口的实现。 Lambda 表达式可以被认为是一种匿名函数，它没有名称，但有参数列表、函数体和可能的异常列表。它可以用来替代使用匿名内部类实现函数式接口的方式 Lambda 表达式可以简化代码，使代码更加简洁、可读性更强，尤其在使用函数式接口和结合 Java Stream API 进行编程时非常有用。
从初学者到专家：Java的Lambda表达式完整指南
热门推荐
LHY537200的博客
03-21 1万+
Lambda是Java中的一种函数式编程特性，它允许以简洁、灵活的方式定义行为（函数），并将其作为参数传递给方法或操作集合数据。通过Lambda表达式，我们可以更方便地实现函数式编程的思想，简化代码编写，并提高代码的可读性和可维护性。它是Java语言在处理函数对象和函数式编程方面的重要进步，为开发者提供了更多的编程选择和表达能力。
Java8 Lambda表达式使用
后青春的诗
12-24 672
Lambda表达式介绍 Java8的一个大亮点是引入Lambda表达式，使用它设计的代码更加简洁。通过Lambda表达式，可以替代我们以前经常写的匿名内部类来实现接口。Lambda表达式本质是一个匿名函数。 Lambda表达式体验 通过一个小例子来体验一下Lambda表达式。 public class TestLambda { public static void main(String[] args) { Cal cal = new Cal() { .
Java8-lambda表达式的使用
一蓑烟雨任平生
07-01 213
Lambda表达式的使用 Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以 传递的代码（将代码像数据一样进行传递）。使用它可以写出更简洁、更 灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了 提升 * * 1.举例： (o1,o2) -> Integer.compare(o1,o2); * 2.格式： * -> :lambda操作符 或 箭头操作符 * ->左边：lambda形参列表 （其实就...
Java8 Lambda表达式教程
java1024p的博客
12-25 122
长期目标是将Java向函数式编程语言这个方向引导（并不是要完全变成一门函数式编程语言，只是让它有更多的函数式编程语言的特性），也正是由于这个原因，Oracle并没有简单地使用内部类去实现λ表达式，而是使用了一种更动态、更灵活、易于将来扩展和改变的策略（invokedynamic）。这么做的原因是：由于Collection库需要为批处理操作添加新的方法，如forEach()，stream()等，但是不能修改现有的Collection接口——如果那样做的话所有的实现类都要进行修改，包括很多客户自制的实现类。
java8 lambda常用方法汇总
Boush
02-10 969
在日常工作中，经常会用到 java8 的 lambda 新特性，可以让代码变得简洁，便于理解，并减少代码量，本文主要列举常用的 lambda 方法，主要涉及：forEach、collect、map、reduce、flatMap、peek、distinct、sorted、filter、allMatch、anyMatch、findFirst、Optional。
快速入门Java中的Lambda表达式
09-01
Java中的Lambda表达式是Java SE 8引入的一个关键特性，它是函数式编程风格的重要组成部分。在其他编程语言中，如Scala、Haskell等，Lambda表达式早已被广泛使用，但Java直到第八个版本才正式支持。Lambda表达式使得...
30分钟入门Java8之lambda表达式学习
08-30
Lambda 表达式是 Java 8 的核心特性之一，它简化了对那些只需要一个方法的接口（即 Functional Interface）的实现，尤其是处理集合操作时，如流（Stream API）中的操作。 在传统的 Java 编程中，我们常常使用匿名...
Java8 Lambda表达式常用方法
孤独没有颜色
07-03 223
filter方法 对noviceGuideBeans遍历筛选出符合条件（集合中对象id等于guideTaskId）的结果集 map方法 获取petList对象集合中的petId属性集合。 双冒号::操作符 调用PlayerPet类的getPetId方法 ...
java8新特性：lambda表达式的使用
m0_68269137的博客
09-05 228
java8新特性：lambda表达式的使用
java lambda max_在Java中使用Lambda表达式查找Max
weixin_35156503的博客
02-13 1436
小编典典该方法Comparator.comparing(…)旨在创建一个Comparator使用基于对象属性的订单进行比较的。当使用lambda表达式i-> i(这是(int i) -> { return i;}此处的简短写法)作为属性提供程序函数时，结果Comparator将比较值本身。这工作时，要比较的对象有一个 自然秩序 的Integer了。所以Stream.of(1,2,4,3...
Java8 新特性 —— Lambda 表达式、函数接口以及方法引用详解
最新发布
m0_74620530的博客
10-30 1697
本系列主要深入学习Java8新特性，本文是Lambda表达式，函数接口以及方法引用的学习，在平时工作学习中，有助于提升我们的编程能力，使代码变得简洁优雅。
Java8特性详解 lambda表达式 Stream
u014754272的博客
03-15 436
1.lambda表达式 Java8最值得学习的特性就是Lambda表达式和Stream API，如果有python或者javascript的语言基础，对理解Lambda表达式有很大帮助，因为Java正在将自己变的更高（Sha）级（Gua），更人性化。--------可以这么说lambda表达式其实就是实现SAM接口的语法糖。 lambda写的好可以极大的减少代码冗余，同时可读性也好过冗长的内部...
JAVA8新特性学习
qq_33261889的博客
02-01 319
Java8学习
java lambda表达式对List进行操作，包括过滤、指定字段去重、合计、分组统计、排序、列表转字符串、String[]转List＜String＞、List＜String＞排序
gdgztt的专栏
03-02 4068
java lambda表达式对list进行操作，包括过滤、指定字段去重、合计、分组统计、排序、列表转字符串，熟练使用将告别xml写复杂sql
Java中Lambda表达式的使用
mocas_wang的博客
07-16 3282
1 简介 Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。 Lambda表达式还增强了集合库。 Java SE 8添加了2个对集合数据进行批量操作的包:java.util.function包以及java.util.stream包。 流(stream)就如同迭代器(iterator),但附加了许多额外的功能。 总的来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值