JAVA开发中几个常用的lambda表达式!记得收藏起来哦~

2024-01-02 13:01:39

在这里插入图片描述

😄 19年之后由于某些原因断更了三年,23年重新扬帆起航,推出更多优质博文,希望大家多多支持~
🌷 古之立大事者,不惟有超世之才,亦必有坚忍不拔之志
🎐 个人CSND主页——Micro麦可乐的博客
🐥《Docker实操教程》专栏以最新的Centos版本为基础进行Docker实操教程,入门到实战
🌺《RabbitMQ》本专栏主要介绍使用JAVA开发RabbitMQ的系列教程,从基础知识到项目实战
🌸《设计模式》专栏以实际的生活场景为案例进行讲解,让大家对设计模式有一个更清晰的理解
如果文章能够给大家带来一定的帮助!欢迎关注、评论互动~

什么是lambda表达式

Lambda表达式是一种在许多编程语言中存在的匿名函数表达式,它可以用于创建简短的、一次性的函数。Lambda表达式通常用于函数式编程范式中,它允许开发者以更紧凑的方式定义匿名函数,而不必显式地声明函数的名称。

在一些编程语言中,比如PythonJavaC#等,Lambda表达式的一般形式为:

//java
(parameters) -> expression

//python
lambda arguments: expression

//C#
(parameters) => expression

Lambda表达式通常包含参数列表、箭头符号(->=>),以及一个表达式。这个表达式的值就是Lambda函数的返回值

下面我们就来介绍一下JAVA开发中比较常用的几个表达式:

01、使用Lambda表达式进行集合遍历

日常未使用Lambda表达式表现如下

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

使用Lambda表达式表现如下

List<String> list = Arrays.asList("apple", "banana", "orange");
list.forEach(fruit -> System.out.println(fruit));

Lambda表达式使得在集合遍历和操作中可以更紧凑地定义功能性代码块,这在函数式编程风格中很常见

02、使用Lambda表达式进行排序

日常未使用Lambda表达式表现如下

List<String> list = Arrays.asList("apple", "banana", "orange");
Collections.sort(list, new Comparator<String>() {
    public int compare(String s1, String s2) {
        return s1.compareTo(s2);
    }
});

使用Lambda表达式表现如下

List<String> list = Arrays.asList("apple", "banana", "orange");
Collections.sort(list, (s1, s2) -> s1.compareTo(s2));

Collections.sort()接受一个比较器(Comparator)作为参数,Lambda表达式用于实现比较器的compare方法。

03、使用Lambda表达式进行映射

这里举例了三种映射案例,

  • 对集合中的每个元素进行映射
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
// 使用Lambda表达式映射每个元素的平方
List<Integer> squares = numbers.stream()
                              .map(x -> x * x)
                              .collect(Collectors.toList());
System.out.println(squares);
// 输出: [1, 4, 9, 16, 25]
  • 对对象集合进行映射
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
// 使用Lambda表达式映射每个字符串的长度
List<Integer> lengths = names.stream()
                            .map(String::length)
                            .collect(Collectors.toList());
System.out.println(lengths);
// 输出: [5, 3, 7]
  • 对集合中的对象属性进行映射
List<Person> people = Arrays.asList(
        new Person("Alice", 25),
        new Person("Bob", 30),
        new Person("Charlie", 22)
);

// 使用Lambda表达式映射每个人的年龄
List<Integer> ages = people.stream()
                           .map(Person::getAge)
                           .collect(Collectors.toList());
System.out.println(ages);
// 输出: [25, 30, 22]

在这些例子中,map()函数用于将集合中的每个元素按照Lambda表达式指定的映射规则进行转换。这样的映射操作使得处理集合数据变得更加简洁和灵活

04、使用Lambda表达式进行过滤

日常未使用Lambda表达式表现如下

//排除包含字母b的水果
List<String> list = Arrays.asList("apple", "banana", "orange");
List<String> filteredList = new ArrayList<String>();
for (String fruit : list) {
    if (fruit.startsWith("b")) {
        filteredList.add(fruit);
    }
}

使用Lambda表达式表现如下

List<String> list = Arrays.asList("apple", "banana", "orange");
List<String> filteredList = list.stream().filter(fruit -> fruit.startsWith("b")).collect(Collectors.toList());

05、使用Lambda表达式进行分组

Lambda表达式可以结合Stream API的Collectors.groupingBy操作来进行分组

  • 按元素类型进行分组
List<String> words = Arrays.asList("apple", "banana", "orange", "avocado", "blueberry", "blackberry");

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

System.out.println(groupedByLength);
// 输出: {5=[apple], 6=[banana, orange], 7=[avocado], 9=[blueberry], 10=[blackberry]}
  • 按对象属性进行分组
List<Person> people = Arrays.asList(
        new Person("Alice", "Engineer"),
        new Person("Bob", "Doctor"),
        new Person("Charlie", "Engineer"),
        new Person("David", "Doctor")
);

Map<String, List<Person>> groupedByOccupation = people.stream()
.collect(Collectors.groupingBy(Person::getOccupation));

System.out.println(groupedByOccupation);
// 输出: 
//{Engineer=[Person{name='Alice', occupation='Engineer'}, Person{name='Charlie', occupation='Engineer'}],
//Doctor=[Person{name='Bob', occupation='Doctor'}, Person{name='David', occupation='Doctor'}]}

06、使用Lambda表达式进行归约

Lambda表达式可以与Stream API一起使用,通过reduce()操作进行归约。归约操作将流中的元素组合成一个单一的结果

  • 对数字列表进行求和
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
// 使用Lambda表达式对数字列表进行求和
int sum = numbers.stream().reduce(0, (x, y) -> x + y);

System.out.println(sum);
// 输出: 15
  • 对字符串列表进行连接
List<String> words = Arrays.asList("Java", "Lambda", "Expression");
// 使用Lambda表达式对字符串列表进行连接
String result = words.stream().reduce("", (x, y) -> x + " " + y);

System.out.println(result.trim());
// 输出: Java Lambda Expression
  • 找到列表中的最大值
List<Integer> numbers = Arrays.asList(3, 7, 1, 9, 4);
// 使用Lambda表达式找到列表中的最大值
int max = numbers.stream().reduce(Integer::max).orElse(0);

System.out.println(max);
// 输出: 9

07、使用Lambda表达式进行函数式接口的实现

日常未使用Lambda表达式表现如下

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

MyInterface myObject = new MyInterface() {
    public void doSomething(String input) {
        System.out.println(input);
    }
};
myObject.doSomething("Hello World");

使用Lambda表达式表现如下

MyInterface myObject = input -> System.out.println(input);
myObject.doSomething("Hello World");

08、使用Lambda表达式进行线程的创建

在不使用Lambda表达式之前,我们通常都是这样创建线程的

Thread thread = new Thread(new Runnable() {
    public void run() {
        System.out.println("Thread is running.");
    }
});
thread.start();

使用Lambda表达式后,我们代码可以更加简化

Thread thread = new Thread(() -> System.out.println("Thread is running."));
thread.start();

再看看自定义的函数式接口

// 定义一个函数式接口
@FunctionalInterface
interface MyRunnable {
    void run();
}

public class LambdaExample {
    public static void main(String[] args) {
        // 使用Lambda表达式实现Runnable接口
        MyRunnable myRunnable = () -> System.out.println("Thread is running.");
        // 调用实现的run方法
        myRunnable.run();
    }
}

09、使用Lambda表达式进行Stream的流水线操作

日常未使用Lambda表达式表现如下

List<String> list = Arrays.asList("apple", "banana", "orange");
List<String> filteredList = new ArrayList<String>();
for (String fruit : list) {
    if (fruit.startsWith("a")) {
        filteredList.add(fruit.toUpperCase());
    }
}
Collections.sort(filteredList);

使用Lambda表达式表现如下

List<String> list = Arrays.asList("apple", "banana", "orange");
List<String> filteredList = list.stream().filter(fruit -> fruit.startsWith("a")).map(String::toUpperCase).sorted().collect(Collectors.toList());

10、使用Lambda表达式进行Optional的操作

在Java中 Optional 是用于处理可能为 null 的值的容器对象。使用Lambda表达式可以更方便地进行 Optional 对象的操作

日常未使用Lambda表达式表现如下

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

使用Lambda表达式表现如下

Optional<String> str = Optional.ofNullable("Hello World");
str.map(String::toUpperCase).ifPresent(System.out::println);

下面我们再来列举几个Lambda表达式进行Optional操作样例

1、创建Optional对象:

Optional<String> nameOptional = Optional.of("John");
// 或者可以使用empty()创建一个空的Optional对象
Optional<String> emptyOptional = Optional.empty();

2、使用Lambda表达式进行 map 操作:

Optional<String> nameOptional = Optional.of("John");

// 使用map将Optional中的值进行转换
Optional<String> upperCaseOptional = nameOptional.map(name -> name.toUpperCase());
System.out.println(upperCaseOptional.orElse("No value"));  
// 输出: JOHN

3、使用Lambda表达式进行 filter 操作:

Optional<String> nameOptional = Optional.of("John");

// 使用filter进行条件过滤
Optional<String> filteredOptional = nameOptional.filter(name -> name.length() > 3);
System.out.println(filteredOptional.orElse("Name is too short"));  
// 输出: John

4、使用Lambda表达式进行 orElseGet 操作:

Optional<String> nameOptional = Optional.empty();
// 使用orElseGet提供默认值的计算方法
String result = nameOptional.orElseGet(() -> "Default Name");
System.out.println(result);  
// 输出: Default Name

5、使用Lambda表达式进行 ifPresent 操作:

Optional<String> nameOptional = Optional.of("John");

// 使用ifPresent在Optional有值时执行操作
nameOptional.ifPresent(name -> System.out.println("Name: " + name));  
// 输出: Name: John

上述5个例子中的Lambda表达式被用于对 Optional 对象进行 mapfilterorElseGet 等操作,以及在 ifPresent 中执行特定的操作。这使得使用 Optional 对象变得更加便捷和清晰。Lambda表达式提供了一种紧凑且易读的方式来定义 Optional 对象的转换和操作。

总结

Lambda表达式的引入使得Java语言在函数式编程方面取得了显著的进步,提升了代码的可读性、简洁性和灵活性。Lambda表达式使得Java更适用于现代软件开发中的各种编程范式和设计模式。
如果你还有更多更好的使用技巧,欢迎评论区进行交流探讨

文章来源:https://blog.csdn.net/lhmyy521125/article/details/135334709
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。