Java——lambda表达式的几种用法

Java——lambda表达式

1、lambda表达式是什么?

lambda表达式是Java 8中引入的一种新特性,它可以让我们更简洁地编写函数式接口的实现;它是一种匿名函数,可以作为参数传递给方法或存储在变量中;Lambda 表达式的优势主要有以下几个方面:

  1. 简洁:Lambda 表达式可以用更少的代码来完成相同的功能。相比于传统的匿名内部类,Lambda 表达式更加简洁明了,可以极大地提高代码的可读性和可维护性。
  2. 易于理解:Lambda 表达式的语法非常简单,只需要一个箭头符号和一些参数即可。这使得代码更加易于理解和学习。
  3. 可读性强:Lambda 表达式可以使代码更加易读。它可以将代码分成更小的块,使得代码更加易于理解和维护。
  4. 可重用性强:Lambda 表达式可以被多次使用,可以作为参数传递给不同的方法。这使得代码更加灵活和可重用。
  5. 并行处理:Lambda 表达式可以用于并行处理,可以极大地提高程序的性能。
  6. 函数式编程:Lambda 表达式是函数式编程的一种体现,它可以使程序更加简洁、易读、易维护和可扩展。

2、符号 ->

在 Java 中,lambda 表达式使用箭头符号 -> 来分隔参数列表和lambda体。箭头符号的左侧是参数列表,可以是空的或非空的,而右侧是lambda体,它可以是一个表达式或一个代码块。

当lambda表达式只有一个参数时,可以省略参数列表中的括号。例如,(s) -> System.out.println(s) 可以简写为 s -> System.out.println(s)

当lambda体只有一行代码时,可以省略花括号和分号。例如,s -> System.out.println(s) 可以简写为 System.out::println

3、关于lambda表达式的例子

1、集合遍历

List<String> list = Arrays.asList("orange","apple","banana");

常规写法

for (String s : list) {
    System.out.println("01-常规:"+s);
}

lambda表达式写法

list.forEach(s -> System.out.println("01-lambda:"+s));

2、排序

List<String> list = Arrays.asList("orange","apple","banana");

常规写法

/**
这段代码使用了 Java 中的 Collections.sort 方法来对列表中的元素进行排序,其中 list 是一个字符串类型的列表对象。
在这个例子中,我们使用了一个匿名内部类来创建一个 Comparator 对象,用于比较字符串类型的元素。Comparator 是一个函数式接口,它定义了一个 compare 方法,接受两个参数并返回一个整数值。在这个匿名内部类中,我们实现了 compare 方法,使用 o1.compareTo(o2) 方法来比较两个字符串类型的元素,并返回比较结果。
然后,我们将这个 Comparator 对象作为第二个参数传递给 Collections.sort 方法,以便在排序时使用它进行比较。最后,我们在控制台中打印出排序后的列表对象。
因此,这段代码的作用是对字符串类型的列表对象进行排序,并在控制台中打印出排序后的列表对象
*/
Collections.sort(list, new Comparator<String>() {
	@Override
	public int compare(String o1, String o2) {
    	return o1.compareTo(o2);
	}
});
System.out.println("02-常规:"+list);

lambda表达式写法

/**
这段代码与之前的代码实现了相同的功能,使用了 Java 中的 Collections.sort 方法来对列表中的元素进行排序,其中 list 是一个字符串类型的列表对象。
不同之处在于,这里使用了 Java 8 中的 lambda 表达式来创建一个 Comparator 对象,而不是使用匿名内部类。lambda 表达式 (o1,o2) -> o1.compareTo(o2) 表示一个接受两个字符串类型参数并返回它们之间比较结果的函数。
然后,我们将这个 lambda 表达式作为第二个参数传递给 Collections.sort 方法,以便在排序时使用它进行比较。最后,我们在控制台中打印出排序后的列表对象。
因此,这段代码的作用与之前的代码相同,对字符串类型的列表对象进行排序,并在控制台中打印出排序后的列表对象。
*/
Collections.sort(list,(o1,o2) -> o1.compareTo(o2));

3、过滤

List<String> list = Arrays.asList("orange","apple","banana");

常规写法

//将a开头的元素存入list2
List<String> list2 = new ArrayList<>();
 for (String s : list) {
    if (s.startsWith("a")){
    	list2.add(s);
  	}
}
System.out.println("03-常规:"+list2);

lambda表达式写法

List<String> list3 = list.stream().filter(s -> s.startsWith("a")).collect(Collectors.toList());
System.out.println("03-lambda:"+list3);

4、映射

 List<String> list = Arrays.asList("orange","apple","banana");

常规写法

//取长度
List<Integer> list2 = new ArrayList<>();
for (String s : list) {
    list2.add(s.length());
}
System.out.println("04-常规:"+list2);

lambda表达式写法

//map:对每一个元素进行类型转换处理
List<Integer> list3 = list.stream().map(s -> s.length()).collect(Collectors.toList());
System.out.println("04-lambda:"+list3);

5、规约

//规约操作是指将一系列元素缩减为单个值的操作,例如求和、求平均值、求最大值、求最小值等。
List<Integer> list = Arrays.asList(1,2,3,4,5);

常规写法

//求和
int sum = 0;
for (Integer integer : list) {
    sum += integer;
}
System.out.println("05-常规:"+sum);

lambda表达式写法

int sum2 = list.stream().reduce(0,(a,b) -> a + b);
System.out.println("05-lambda:"+sum2);

6、分组

List<String> list = Arrays.asList("orange","apple","banana");

常规写法

//按照字符串长度分组,并将分组后的结果存储在一个 Map 对象中
Map<Integer,List<String>> groups = new HashMap<>();
for (String s : list) {
    int length = s.length();
    if (!groups.containsKey(length)){
	groups.put(length,new ArrayList<>());
    }
    groups.get(length).add(s);
}
System.out.println("06-常规:"+groups);

lambda表达式写法

//将原始的字符串类型的列表对象 list 转换为一个流对象,并使用 Collectors.groupingBy 操作对流中的元素进行分组
Map<Integer,List<String>> groups2 = list.stream().collect(Collectors.groupingBy(String::length));
System.out.println("06-lambda:"+groups2);

7、接口实现

package lambda;

public interface MyInterface {
    public void hello(String s);
}

常规写法

/*
创建一个匿名内部类,实现了一个自定义的接口 MyInterface 中的方法 hello,该方法接受一个字符串类型的参数 s,并在控制台中输出该参数。然后,通过创建该匿名内部类的实例对象 myInterface,调用了 hello 方法,并传入参数 "HelloWorld"。
*/
MyInterface myInterface = new MyInterface() {
    @Override
    public void hello(String s) {
		System.out.println("07-常规:"+s);
    }
};
myInterface.hello("HelloWorld");

lambda表达式写法

MyInterface myInterface1 = (s) -> System.out.println("07-lambda:"+s);
myInterface1.hello("HelloWorld");

8、线程

常规写法

Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
		System.out.println("08-常规:HelloWorld");
    }
});
thread.start();

lambda表达式写法

Thread thread1 = new Thread(() -> System.out.println("08-lambda:HelloWorld"));
thread1.start();

9、Optional

*Optional 类是 Java 8 中新增的一个类,用于解决空指针异常问题。它可以将一个可能为 null 的对象包装成一个 Optional 对象,从而避免了直接访问该对象时可能出现的空指针异常。

String str = "hello world";

常规写法

//转大写
if (str!=null){
	System.out.println("09-常规:"+str.toUpperCase());
}

lambda表达式写法

/*map对每一个元素进行转换
  ifPresent 方法,当 Optional 对象中存在值时,调用 lambda 表达式
*/
Optional.ofNullable(str)
		.map(String::toUpperCase)
		.ifPresent(s -> System.out.println("09-lambda:"+s));

10、流水线操作

List<String> list = Arrays.asList("orange","apple","banana");

常规写法

//将a开头的元素转大写后存入list2并排序
List<String> list2 = new ArrayList<>();
for (String s : list) {
    if (s.startsWith("a")){
		list2.add(s.toUpperCase());
    }
}
Collections.sort(list2);
System.out.println("10-常规:"+list2);

lambda表达式写法

 List<String> list3 = list.stream()
	.filter(s -> s.startsWith("a"))
	.map(String::toUpperCase)
	.sorted()
	.collect(Collectors.toList());
System.out.println("10-lambda:"+list3);

4、总结

如上所述,Lambda 表达式是 Java 8 中最重要的新特性之一,它可以极大地提高程序的可读性、可维护性和可扩展性。通过使用 Lambda 表达式,我们可以写出更加简洁、灵活和高效的代码。

学习来源:

【每天一个知识点:10个你必须掌握的Lambda表达式,效率翻倍!】https://www.bilibili.com/video/BV1vX4y12719?vd_source=6dc388fc252e23c3eee6cebba7464187

  • 0
    点赞
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值