超好用的特性:Stream 流

一、介绍

JDK 8引入了Stream API,它是Java中处理集合数据的一种新方式。Stream流提供了一种更简洁、更灵活的方式来对集合进行操作和处理。

Stream流可以看作是一种高级的迭代器,它可以对集合中的元素进行过滤、映射、排序、聚合等操作,而不需要显式地使用循环。这样可以使代码更加简洁、易读,并且可以充分利用多核处理器的优势。

Stream流的特点包括:

  1. 延迟计算:Stream流中的操作是惰性执行的,只有在终止操作时才会触发计算。这种延迟计算的特性可以提高性能,因为只计算需要的结果。

  2. 内部迭代:Stream流使用内部迭代器来遍历集合,这意味着不需要显式地编写循环来遍历集合。这样可以提高代码的简洁性和可读性。

  3. 支持并行操作:Stream流可以很方便地进行并行操作,即将任务分成多个子任务并行执行,然后将结果合并。这可以提高处理大量数据的效率。

使用Stream流可以大大简化集合数据的处理,使代码更加简洁、易读,并且可以充分发挥多核处理器的优势。

二、相关操作

  1. 创建Stream流:

    • 从集合创建:可以通过集合的stream()方法或parallelStream()方法来创建一个Stream流。
    • 从数组创建:可以使用Arrays类的stream()方法来创建一个Stream流。
    • 使用Stream.of()方法:可以直接传入多个元素来创建一个Stream流。
    • 使用Stream.generate()或Stream.iterate()方法:可以生成一个无限流。
  2. Stream流的中间操作:

    • filter():过滤掉不满足条件的元素。
    • map():对元素进行映射转换。
    • flatMap():将多个流合并成一个流。
    • distinct():去除重复的元素。
    • sorted():对元素进行排序。
    • limit():限制元素的数量。
    • skip():跳过指定数量的元素。
  3. Stream流的终端操作:

    • forEach():对每个元素执行指定操作。
    • collect():将元素收集到一个集合中。
    • reduce():将元素进行归约操作,得到一个最终结果。
    • count():计算元素的数量。
    • min()和max():找到最小值和最大值。
    • anyMatch()、allMatch()和noneMatch():检查是否存在满足条件的元素。

三、实例

  1. 过滤(filter):筛选出集合中满足指定条件的元素。
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");

List<String> filteredNames = names.stream()
                                 .filter(name -> name.length() > 4)
                                 .collect(Collectors.toList());

System.out.println(filteredNames); // 输出:[Alice, Charlie]
  1. 映射(map):将集合中的元素进行转换。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

List<Integer> squaredNumbers = numbers.stream()
                                       .map(number -> number * number)
                                       .collect(Collectors.toList());

System.out.println(squaredNumbers); // 输出:[1, 4, 9, 16, 25]
  1. 排序(sorted):对集合中的元素进行排序。
List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 9);

List<Integer> sortedNumbers = numbers.stream()
                                     .sorted()
                                     .collect(Collectors.toList());

System.out.println(sortedNumbers); // 输出:[1, 2, 5, 8, 9]
  1. 去重(distinct):去除集合中的重复元素。
List<Integer> numbers = Arrays.asList(1, 2, 3, 2, 4, 3, 5);

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

System.out.println(distinctNumbers); // 输出:[1, 2, 3, 4, 5]
  1. 限制(limit)和跳过(skip):限制集合中元素的数量或跳过指定数量的元素。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

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

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

List<Integer> skippedNumbers = numbers.stream()
                                      .skip(2)
                                      .collect(Collectors.toList());

System.out.println(skippedNumbers); // 输出:[3, 4, 5]
  1. 匹配(match):检查集合中是否存在满足指定条件的元素。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

boolean anyMatch = numbers.stream()
                          .anyMatch(number -> number > 3);

System.out.println(anyMatch); // 输出:true

boolean allMatch = numbers.stream()
                          .allMatch(number -> number > 0);

System.out.println(allMatch); // 输出:true

boolean noneMatch = numbers.stream()
                           .noneMatch(number -> number < 0);

System.out.println(noneMatch); // 输出:true
  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

int max = numbers.stream()
                 .reduce(Integer.MIN_VALUE, (a, b) -> a > b ? a : b);

System.out.println(max); // 输出:5
  1. 遍历(forEach):对集合中的每个元素执行指定操作。
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

names.stream()
     .forEach(name -> System.out.println("Hello, " + name));

// 输出:
// Hello, Alice
// Hello, Bob
// Hello, Charlie
  1. 统计(summarizing):获取集合中元素的统计信息,如总数、平均值、最大值、最小值等。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

IntSummaryStatistics stats = numbers.stream()
                                    .mapToInt(Integer::intValue)
                                    .summaryStatistics();

System.out.println("Count: " + stats.getCount());
System.out.println("Sum: " + stats.getSum());
System.out.println("Average: " + stats.getAverage());
System.out.println("Max: " + stats.getMax());
System.out.println("Min: " + stats.getMin());

// 输出:
// Count: 5
// Sum: 15
// Average: 3.0
// Max: 5
// Min: 1
  1. 分组(groupingBy):根据指定条件对集合中的元素进行分组。
List<Person> people = Arrays.asList(
    new Person("Alice", 25),
    new Person("Bob", 30),
    new Person("Charlie", 25),
    new Person("David", 35),
    new Person("Eve", 30)
);

Map<Integer, List<Person>> ageGroups = people.stream()
                                             .collect(Collectors.groupingBy(Person::getAge));

System.out.println(ageGroups);

// 输出:
// {25=[Person{name='Alice', age=25}, Person{name='Charlie', age=25}], 
//  30=[Person{name='Bob', age=30}, Person{name='Eve', age=30}], 
//  35=[Person{name='David', age=35}]}
  1. 并行处理(parallelStream):使用并行流来并行处理集合中的元素。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

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

System.out.println(sum); // 输出:15
  1. flatMap操作:将多个流合并成一个流。
List<List<Integer>> numberLists = Arrays.asList(
    Arrays.asList(1, 2, 3),
    Arrays.asList(4, 5, 6),
    Arrays.asList(7, 8, 9)
);

List<Integer> flattenedList = numberLists.stream()
                                         .flatMap(List::stream)
                                         .collect(Collectors.toList());

System.out.println(flattenedList);

// 输出:[1, 2, 3, 4, 5, 6, 7, 8, 9]
  1. 查找(findFirst和findAny):查找集合中满足指定条件的元素。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

Optional<Integer> firstEvenNumber = numbers.stream()
                                           .filter(number -> number % 2 == 0)
                                           .findFirst();

System.out.println(firstEvenNumber); // 输出:Optional[2]

Optional<Integer> anyEvenNumber = numbers.stream()
                                         .filter(number -> number % 2 == 0)
                                         .findAny();

System.out.println(anyEvenNumber); // 输出:Optional[2](可能不同于findFirst的结果)
  1. 去除空值(filterNotNull):过滤掉集合中的空值。
List<String> names = Arrays.asList("Alice", null, "Bob", null, "Charlie");

List<String> nonNullNames = names.stream()
                                 .filter(Objects::nonNull)
                                 .collect(Collectors.toList());

System.out.println(nonNullNames); // 输出:[Alice, Bob, Charlie]
  1. 使用自定义操作(customOperation):根据自己的需求编写自定义的操作。
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

List<String> uppercaseNames = names.stream()
                                   .map(String::toUpperCase)
                                   .collect(Collectors.toList());

System.out.println(uppercaseNames); // 输出:[ALICE, BOB, CHARLIE]

你可能感兴趣的:(java,java,stream,流,特性)