十个Lambda表达式小技巧,提高开发效率

最新推荐文章于 2025-04-28 07:30:00 发布

原创最新推荐文章于 2025-04-28 07:30:00 发布 · 205 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#windows #microsoft #java

本文介绍了如何使用Java的lambda表达式对集合遍历、排序、过滤、映射、规约等操作进行简化，并强调了lambda在提高编码效率方面的优势，尽管它并不直接提高程序运行速度。

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

进行集合遍历

List<String> list = Arrays.asList("apple", "banner", "orange");
for (String s : list) {
    System.out.println(s);
}

这个是一个普通的遍历方法。

之后我们来看经过lambda优化后的

list.forEach(s->{
    System.out.println(s);
});

之后也更加简化：

list.forEach(System.out::println);

排序

List<String> list = Arrays.asList("apple", "banner", "orange");
Collections.sort(list, new Comparator<String>() {
    @Override
    public int compare(String o1, String o2) {
        return o1.compareTo(o2);
    }
});

这个是正常的方法

下面我们来看简化的

Collections.sort(list,(o1,o2)->o1.compareTo(o2));

这个就可以看到优化的是非常的多了

过滤

List<String> list = Arrays.asList("apple", "banner", "orange");
List<String> list2 = new ArrayList<>();

for (String s:list){
    if (s.startsWith("a")) {
        list2.add(s);
    }
}

正常的代码。

经过lambda表达式优化后的代码

list.stream().filter(s->s.startsWith("a")).collect(Collectors.toList());

映射

List<String> list = Arrays.asList("apple", "banner", "orange");
List<Integer> list2 = new ArrayList<>();

for (String s : list) {
    list2.add(s.length());
}

下面来看简化

List<Integer> list3 = list.stream().map(s -> s.length()).collect(Collectors.toList());

规约

    List<Integer> list=Arrays.asList(1,2,3,4,5);
    int sum=0;
    for (Integer v : list) {
        sum+=v;
    }
    System.out.println(sum);

}

一个很简单，但是又不能不用for循环

list.stream().reduce(0,(a,b)->a+b);

首先第一个参数是初始值，代表着累加器的初始值。

分组

List<String> list = Arrays.asList("apple", "banana", "orange");
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);
}

一个按照长度分组的代码

Map<Integer,List<String>> group2=list.stream().collect(Collectors.groupingBy(String::length));

函数式接口

package com.xiaou;

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

public class Test {
    public static void main(String[] args) {
        MyInterface myInterface = new MyInterface() {
            @Override
            public void doSomething(String s) {
                System.out.println(s);
            }
        };
        myInterface.doSomething("hello world");

    }
}

正常情况下，我们需要重写其方法

我们来看lambda表达式的优化

MyInterface myInterface1=(s)-> System.out.println(s);
myInterface1.doSomething("hello world");

创建线程

Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("hello world");
    }
});
thread.start();

这是正常去创建一个线程

下面来看lambda表达式简化

Thread thread1 = new Thread(() -> System.out.println("hello world"));
thread1.start();

进行optional操作

String str="hello world";
if (str!=null){
    System.out.println(str.toUpperCase());
}

进行简化

Optional.ofNullable(str).map(String::toUpperCase).ifPresent(System.out::println);

optional有很多的操作。这里就不多说了。

进行stream的流水

List<String> list = Arrays.asList("apple", "orange");
List<String> list2 = new ArrayList<>();
for (String s : list) {
    if (s.startsWith("a")){
        list2.add(s.toUpperCase());
    }
}

Collections.sort(list2);

这是一个普通的写法。下面来看lambda的优化。

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

总结

最后我想说，lambda不会提高效率。匿名内部类对性能有损耗，只是会提高一些编码的效率。lambda还是很有必要去进行一个学习的。