Stream的基本用法过滤、排序、映射、终止、去重等

Stream 是 Java 8 引入的一种用于处理集合的 API，提供了一种声明性的方法来处理数据，通常比传统的 for 循环更简洁和可读。Stream API 支持顺序和并行两种流处理模式，能够对集合元素进行各种操作，如过滤、排序、映射等。

创建 Stream

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamExample {
    public static void main(String[] args) {
        // 创建一个 List
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

        // 创建 Stream
        Stream<String> nameStream = names.stream();
    }
}

1、过滤

用于过滤出符合条件的元素。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamFilterExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

        // 过滤名字长度大于 4 的元素
        List<String> filteredNames = names.stream()
                                          .filter(name -> name.length() > 4)
                                          .collect(Collectors.toList());

        System.out.println(filteredNames); // [Charlie, David]
    }
}

2、映射

用于将每个元素转换成另一种形式。

实例1

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamMapExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

        // 将每个名字转换成大写
        List<String> upperCaseNames = names.stream()
                                           .map(String::toUpperCase)
                                           .collect(Collectors.toList());

        System.out.println(upperCaseNames); // [ALICE, BOB, CHARLIE, DAVID]
    }
}

 示例2

List list = new ArrayList<>();
        //统计折线图
        List<Approval> approvalList = approvalMapper.queryAll();
        //去重组合成set集合（ApplyTime）
        Set<String> dates = approvalList.stream().map(Approval::getApplyTime).collect(Collectors.toSet());
        //数组排序
        List<String> dateList = CollUtil.newArrayList(dates);
        dateList.sort(Comparator.naturalOrder());
        for (String date : dateList) {
            // 统计当前日期的所有申请人数
            Long sum = approvalList.stream().filter(approval -> approval.getApplyTime().equals(date)).count();
            //类似于map可以链式组装
            Dict dict = Dict.create();
            Dict line = dict.set("date", date).set("value", sum);
            list.add(line);
        }

3、排序

用于对元素进行排序。

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamSortedExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Charlie", "Bob", "Alice", "David");

        // 对名字进行排序
        List<String> sortedNames = names.stream()
                                        .sorted()
                                        .collect(Collectors.toList());

        System.out.println(sortedNames); // [Alice, Bob, Charlie, David]
    }
}

4、收集 (collect)

import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

public class StreamCollectExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

        // 收集到 Set 中，自动去重
        Set<String> nameSet = names.stream()
                                   .collect(Collectors.toSet());

        System.out.println(nameSet); // [Alice, Bob, Charlie, David]
    }
}

5、去重

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamDistinctExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "Bob", "Alice");

        // 去除重复的名字
        List<String> distinctNames = names.stream()
                                          .distinct()
                                          .collect(Collectors.toList());

        System.out.println(distinctNames); // [Alice, Bob, Charlie]
    }
}

6、计数 (count)

import java.util.Arrays;
import java.util.List;

public class StreamCountExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

        // 计算名字长度大于 4 的元素个数
        long count = names.stream()
                          .filter(name -> name.length() > 4)
                          .count();

        System.out.println(count); // 2
    }
}

3. 终止操作与中间操作

• 中间操作：如 filter, map, sorted。这些操作返回一个新的 Stream，允许链式调用。
• 终止操作：如 collect, count, forEach。这些操作会触发流的处理并生成结果，流的处理也会在此时进行。

4

并行流

通过 parallelStream() 方法可以创建并行流，利用多核 CPU 提高处理性能。

import java.util.Arrays;
import java.util.List;

public class StreamParallelExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

        // 使用并行流进行处理
        names.parallelStream()
             .filter(name -> name.length() > 4)
             .forEach(System.out::println);
    }
}