Lambda表达式是Java 8中引入的一个重要特性，它允许开发者以更加简洁的方式编写函数式代码。在本文中，我们将深入探讨Lambda表达式的概念、语法和用法，并为每个实例提供代码演示，同时对比与传统方法的区别和优势。
1. Lambda表达式概述
Lambda表达式是一种匿名函数，它主要用于表示简单的行为或代码块，并可以在需要时传递到其他函数中。Lambda表达式可以看作是一个函数式接口的实例，它由三个部分组成：参数列表、箭头符号和表达式体。以下是一个简单的Lambda表达式示例：
() -> System.out.println("Hello, World!");
在这个示例中，Lambda表达式包含一个空参数列表，箭头符号"->"和一个输出"Hello, World!"的表达式体。它可以通过调用Lambda表达式的函数式接口来执行。
2. Lambda表达式语法
Lambda表达式的语法非常简单，它由三个部分组成：参数列表、箭头符号和表达式体。以下是Lambda表达式的语法：
(parameters) -> expression
或者
(parameters) -> { statements; }
其中，参数列表可以是空的、包含一个参数或包含多个参数。如果有多个参数，则需要使用逗号分隔参数。表达式体可以是一个简单的表达式，也可以是一个代码块。
当使用Java语言时，Lambda表达式也由三个关键部分组成：
参数列表：指定Lambda函数接受的参数。参数可以有零到多个，用逗号隔开，放在小括号中。
箭头符号：箭头符号“->”用于分隔参数列表和表达式体。它表示将给定的参数映射到表达式体中进行计算。
表达式体：指定Lambda函数执行的代码块，可以是任何有效的表达式或语句块。
下面是一个简单的示例，展示了一个使用Lambda表达式来对字符串数组进行排序的例子：
// 对字符串数组进行排序 String[] myArray = {"hello", "world", "lambda", "expression"}; // 使用Lambda表达式定义排序规则 Arrays.sort(myArray, (String str1, String str2) -> str1.compareTo(str2)); // 输出排序后的结果 System.out.println(Arrays.toString(myArray));
在这个例子中，Lambda表达式被用作Comparator的实现传递给Arrays.sort方法。Lambda表达式(String str1, String str2) -> str1.compareTo(str2)指定了排序规则，它接受两个参数str1和str2，并返回它们比较的结果。这意味着该字符串数组将按字母序进行排序。
需要注意的是，Lambda表达式需要使用函数式接口来实现。函数式接口是一个只有一个抽象方法的接口，它可以被Lambda表达式实现。Java 8提供了许多内置的函数式接口，例如Comparator、Runnable和Function等。
3. Lambda表达式用法
Lambda表达式的主要用途是作为函数式接口的
提供了一些demo;
1.遍历列表并输出每个元素
List<String> list = Arrays.asList("apple", "banana", "orange"); // 使用Lambda遍历列表 list.forEach(item -> System.out.println(item)); // 常规写法 for (String item : list) { System.out.println(item); }
2.筛选列表中的偶数并返回一个新列表
List list = Arrays.asList(1, 2, 3, 4, 5, 6);
// 使用Lambda筛选偶数
List<Integer> evenList = list.stream().filter(num -> num % 2 == 0).collect(Collectors.toList()); System.out.println(evenList); // 常规写法 List<Integer> evenList2 = new ArrayList<>(); for (Integer num : list) { if (num % 2 == 0) { evenList2.add(num); } } System.out.println(evenList2);
3.将字符串转换为大写并返回一个新列表
List<String> list = Arrays.asList("apple", "banana", "orange"); // 使用Lambda将字符串转换为大写 List<String> upperList = list.stream().map(str -> str.toUpperCase()).collect(Collectors.toList()); System.out.println(upperList); // 常规写法 List<String> upperList2 = new ArrayList<>(); for (String str : list) { upperList2.add(str.toUpperCase()); } System.out.println(upperList2);
4.计算列表中所有元素的总和
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5); // 使用Lambda计算列表元素总和 int sum = list.stream().reduce(0, (a, b) -> a + b); System.out.println(sum); // 常规写法 int sum2 = 0; for (Integer num : list) { sum2 += num; } System.out.println(sum2);
5.将列表中的元素转换为键值对并放入Map中
List<String> list = Arrays.asList("apple", "banana", "orange"); // 使用Lambda将列表中的元素转换为键值对并放入Map中 Map<String, Integer> map = list.stream().collect(Collectors.toMap(Function.identity(), String::length)); System.out.println(map); // 常规写法 Map<String, Integer> map2 = new HashMap<>(); for (String str : list) { map2.put(str, str.length()); } System.out.println(map2);
6. 筛选集合中的元素
// 使用Lambda表达式筛选出小于10的数字 List<Integer> numbers = Arrays.asList(1, 5, 10, 15); List<Integer> filteredNumbers = numbers.stream() .filter(n -> n < 10) .collect(Collectors.toList()); // 传统写法 List<Integer> filteredNumbers = new ArrayList<>(); for (Integer n : numbers) { if (n < 10) { filteredNumbers.add(n); } }
7. 在集合中进行映射
// 使用Lambda表达式将字符串转换为它们的长度 List<String> words = Arrays.asList("apple", "banana", "orange"); List<Integer> wordLengths = words.stream() .map(s -> s.length()) .collect(Collectors.toList()); // 传统写法 List<Integer> wordLengths = new ArrayList<>(); for (String s : words) { wordLengths.add(s.length()); }
8.对集合中的元素进行排序
// 使用Lambda表达式将集合中的元素按字母顺序排序 List<String> words = Arrays.asList("apple", "banana", "orange"); Collections.sort(words, (s1, s2) -> s1.compareTo(s2)); // 传统写法 List<String> words = Arrays.asList("apple", "banana", "orange"); Collections.sort(words, new Comparator<String>() { public int compare(String s1, String s2) { return s1.compareTo(s2); } });
9.执行多个操作
// 使用Lambda表达式执行多个操作 List<String> words = Arrays.asList("apple", "banana", "orange"); words.stream() .filter(s -> s.startsWith("a")) .map(s -> s.toUpperCase()) .forEach(System.out::println); // 传统写法 List<String> words = Arrays.asList("apple", "banana", "orange"); for (String s : words) { if (s.startsWith("a")) { System.out.println(s.toUpperCase()); } }
10.对整数数组进行排序
//传统写法： int[] arr = {3, 1, 4, 1, 5, 9, 2, 6, 5}; Arrays.sort(arr, new Comparator<Integer>() { public int compare(Integer a, Integer b) { return a - b; } });
//Lambda写法： int[] arr = {3, 1, 4, 1, 5, 9, 2, 6, 5}; Arrays.sort(arr, (a, b) -> a - b);
说明：这个示例展示了如何使用Lambda表达式对一个整数数组进行排序。在传统写法中，我们需要定义一个实现Comparator接口的类，并在排序时将其传递给Arrays.sort()方法。而在Lambda写法中，我们只需要编写一行简单的代码即可完成相同的操作。
11使用Stream API过滤集合元素
//传统写法： List<String> list = Arrays.asList("apple", "banana", "cherry", "date"); List<String> filteredList = new ArrayList<>(); for (String s : list) { if (s.startsWith("a")) { filteredList.add(s); } }
//Lambda写法： List<String> list = Arrays.asList("apple", "banana", "cherry", "date"); List<String> filteredList = list.stream() .filter(s -> s.startsWith("a")) .collect(Collectors.toList());
说明：这个示例展示了如何使用Lambda表达式和Stream API对一个字符串列表进行过滤。在传统写法中，我们需要手动遍历整个集合并筛选出符合条件的元素，而在Lambda写法中，我们可以使用stream()方法将集合转换为流，并使用filter()方法对流进行过滤操作。
12. 使用Lambda表达式作为方法参数
//传统写法： public static void operate(int a, int b, Operation operation) { System.out.println(operation.operate(a, b)); } interface Operation { int operate(int a, int b); } operate(2, 3, new Operation() { public int operate(int a, int b) { return a + b; } });
//Lambda写法： public static void operate(int a, int b, IntBinaryOperator operator) { System.out.println(operator.applyAsInt(a, b)); } operate(2, 3, (a, b) -> a + b);
说明：这个示例展示了如何使用Lambda表达式作为方法参数。在传统写法中，我们需要定义一个实现某个接口的类，并在调用方法时将其传递给方法。而在Lambda写法中，我们可以直接在调用方法时编写Lambda表达式作为参数，从而省略了额外的类定义。
13.使用Lambda表达式作为变量
//传统写法： public static void printMessage(String message) { System.out.println(message); } printMessage("Hello, world!");
//Lambda写法： Consumer<String> printer = (message) -> System.out.println(message); printer.accept("Hello, world!");
说明：这个示例展示了如何使用Lambda表达式定义一个函数式接口的实现，并将其作为变量使用。在传统写法中，我们需要定义一个方法并在调用时传递参数。而在Lambda写法中，我们可以先定义一个函数式接口，然后使用Lambda表达式创建其实现，并将其赋值给一个变量。
4.Lambda表达式优缺点
Lambda表达式具有以下优点：
简洁：使用Lambda表达式可以少写很多样板代码。
灵活：Lambda表达式可以在运行时定义，在需要时才创建。
易读：Lambda表达式的语法简单明了，易于理解。
Lambda表达式也具有以下缺点：
可读性：过度使用Lambda表达式可能会降低代码的可读性。
性能：Lambda表达式的性能可能比普通方法略差。但在大部分场景下，这个差距是微不足道的。
