1. 首页
  2. 博客
  3. java集合进阶 增强for介lambda表达式

java集合进阶 增强for介lambda表达式

当使用增强的 for 循环（foreach）时，可以更简洁地遍历集合中的元素。增强的 for 循环在 Java 5 中引入，它基于迭代器的概念，可以遍历实现了 Iterable 接口的集合类。

增强的 for 循环使用以下语法：

for (元素类型 变量名 : 集合) {
    // 循环体
}

其中，元素类型是集合中元素的类型，变量名是用于表示当前元素的变量名，集合是要遍历的集合对象。

以下是一个使用增强的 for 循环遍历集合的示例：

List<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Orange");

for (String fruit : fruits) {
    System.out.println(fruit);
}

上述示例中，使用增强的 for 循环遍历字符串列表 fruits，并打印每个水果的名称。

增强的 for 循环简化了遍历集合的代码，并且在遍历过程中无需显式地使用迭代器。然而，它只适用于遍历集合，无法进行集合的修改操作。

另外，Java 8 引入了 lambda 表达式，它是一种简洁而强大的函数式编程特性。通过 lambda 表达式，可以更灵活地处理集合中的元素。

可以使用 lambda 表达式结合函数式接口（Functional Interface）来实现集合的遍历和操作。函数式接口是只包含一个抽象方法的接口，例如 Consumer、Predicate 和 Function 等。

以下是一个使用 lambda 表达式遍历集合的示例：

List<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Orange");

fruits.forEach(fruit -> System.out.println(fruit));

上述示例中，使用 forEach 方法结合 lambda 表达式遍历字符串列表 fruits，并打印每个水果的名称。

通过 lambda 表达式，可以更直接地传递行为（behavior）给集合中的每个元素。可以使用不同的函数式接口来实现不同的操作，例如筛选元素、转换元素等。

以下是一个使用 lambda 表达式进行元素筛选的示例：

List<Integer> numbers = new ArrayList<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
numbers.add(4);
numbers.add(5);

numbers.stream()
       .filter(number -> number % 2 == 0)
       .forEach(System.out::println);

上述示例中，使用流（Stream）结合 lambda 表达式，筛选出列表 numbers 中的偶数元素，并打印出来。

使用 lambda 表达式可以使代码更简洁、易读，并且提供了更强大的集合操作能力

当使用 lambda 表达式进行集合操作时，还可以结合其他函数式接口和操作来实现更多功能。

  1. 筛选元素：使用 filter 方法筛选集合中符合特定条件的元素。示例如下：
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

List<Integer> evenNumbers = numbers.stream()
                                   .filter(number -> number % 2 == 0)
                                   .collect(Collectors.toList());

System.out.println(evenNumbers); // 输出：[2, 4, 6, 8, 10]

上述示例使用 filter 方法筛选出列表 numbers 中的偶数元素，并将筛选结果收集到新的列表 evenNumbers 中。

  1. 转换元素：使用 map 方法对集合中的每个元素进行转换。示例如下：
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

List<Integer> nameLengths = names.stream()
                                 .map(String::length)
                                 .collect(Collectors.toList());

System.out.println(nameLengths); // 输出：[5, 3, 7]

上述示例使用 map 方法将列表 names 中的每个字符串元素转换为其长度，并将转换结果收集到新的列表 nameLengths 中。

  1. 集合聚合操作：使用 reduce 方法对集合中的元素进行聚合操作，例如求和、求最大值等。示例如下：
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

int sum = numbers.stream()
                 .reduce(0, (a, b) -> a + b);

System.out.println(sum); // 输出：15

上述示例使用 reduce 方法对列表 numbers 中的元素进行求和操作。

除了上述示例，还有其他函数式接口和操作可以与 lambda 表达式结合使用，例如 forEach、sorted、distinct、limit 等。这些方法可以按需进行集合操作，使代码更简洁和可读。

需要注意的是，lambda 表达式和函数式接口在 Java 8 中引入，因此需要至少使用 Java 8 或更高版本的编译器和运行环境。

总结来说，lambda 表达式为集合操作提供了一种简洁而强大的方式，通过结合函数式接口和操作，可以实现丰富的集合操作功能。它可以使代码更具可读性，并且提供了更灵活的集合操作方式。

当使用 lambda 表达式进行集合操作时，还有一些其他常用的函数式接口和操作可以进一步扩展功能。

  1. 排序元素：使用 sorted 方法对集合中的元素进行排序。示例如下：
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

List<String> sortedNames = names.stream()
                                .sorted()
                                .collect(Collectors.toList());

System.out.println(sortedNames); // 输出：[Alice, Bob, Charlie]

上述示例使用 sorted 方法对列表 names 中的字符串元素进行字母顺序排序。

  1. 去重元素：使用 distinct 方法去除集合中的重复元素。示例如下：
List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 3, 4, 5, 5);

List<Integer> distinctNumbers = numbers.stream()
                                       .distinct()
                                       .collect(Collectors.toList());

System.out.println(distinctNumbers); // 输出：[1, 2, 3, 4, 5]

上述示例使用 distinct 方法去除列表 numbers 中的重复整数元素。

  1. 截取元素：使用 limit 方法截取集合中的前 N 个元素。示例如下：
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

List<Integer> firstThreeNumbers = numbers.stream()
                                         .limit(3)
                                         .collect(Collectors.toList());

System.out.println(firstThreeNumbers); // 输出：[1, 2, 3]

上述示例使用 limit 方法截取列表 numbers 中的前三个整数元素。

  1. 集合分组：使用 groupingBy 方法将集合中的元素按照指定的条件进行分组。示例如下：
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "Anna", "Alex");

Map<Character, List<String>> groupedNames = names.stream()
                                                 .collect(Collectors.groupingBy(name -> name.charAt(0)));

System.out.println(groupedNames); // 输出：{A=[Alice, Anna, Alex], B=[Bob], C=[Charlie]}

上述示例使用 groupingBy 方法将列表 names 中的字符串元素按照首字母进行分组。

除了上述示例，还有许多其他函数式接口和操作可用于集合操作，例如 flatMap、min、max、anyMatch、allMatch 等。它们可以根据具体需求实现更复杂的集合操作逻辑。

通过结合 lambda 表达式和这些函数式接口和操作，可以实现高效、简洁和灵活的集合操作，提高代码的可读性和可维护性。

需要注意的是，函数式接口和操作都是在 Java 8 中引入的，因此需要至少使用 Java 8 或更高版本的编译器和运行环境。

原文链接：codingdict.net

热门标签