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

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

什么是lambda表达式

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

在一些编程语言中，比如Python、Java、C#等，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 对象进行 map、filter、orElseGet 等操作，以及在 ifPresent 中执行特定的操作。这使得使用 Optional 对象变得更加便捷和清晰。Lambda表达式提供了一种紧凑且易读的方式来定义 Optional 对象的转换和操作。

总结

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