Java 8 Stream操作示例

以下是 Java 8 之后常见的 Stream 操作示例，包含中文注释，便于理解各个操作的用途：

一. 常用操作

操作	说明
filter	过滤符合条件的元素
map	对元素进行转换
reduce	聚合操作，如求和、求乘积等
sorted	排序
distinct	去重
limit	截取前 N 个元素
skip	跳过前 N 个元素
anyMatch	是否存在至少一个满足条件
allMatch	是否所有都满足条件
noneMatch	是否全部都不满足条件
collect	收集结果，可以是 list、map 等
groupingBy	分组

1. filter 过滤出偶数

    // filter 过滤出偶数
    @Test
    public void testFilter() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4);
        List<Integer> even = list.stream()
                .filter(n -> n % 2 == 0) // 过滤出偶数
                .collect(Collectors.toList());
        log.info("even: {}", even);
    }

2. map 将每个元素乘2

    // map 将每个元素乘2
    @Test
    public void testMap() {
        List<Integer> list = Arrays.asList(1, 2, 3);
        List<Integer> mapped = list.stream()
                .map(n -> n * 2) // 每个元素乘2
                .collect(Collectors.toList());
        log.info("mapped: {}", mapped);
    }

3. reduce 求和

    // reduce 求和
    @Test
    public void testReduce() {
        List<Integer> list = Arrays.asList(1, 2, 3);
        int sum = list.stream()
                .reduce(0, Integer::sum); // 从0开始累加
        log.info("sum: {}", sum);
    }

4. sorted 升序排序

    // sorted 升序排序
    @Test
    public void testSorted() {
        List<Integer> list = Arrays.asList(3, 1, 2);
        List<Integer> sorted = list.stream()
                .sorted() // 默认升序
                .collect(Collectors.toList());
        log.info("sorted: {}", sorted);
    }

5. sorted + reverseOrder 倒序排序

    // sorted + reverseOrder 倒序排序
    @Test
    public void testReverseSorted() {
        List<Integer> list = Arrays.asList(1, 3, 2);
        List<Integer> reversed = list.stream()
                .sorted(Comparator.reverseOrder()) // 倒序排序
                .collect(Collectors.toList());
        log.info("reversed: {}", reversed);
    }

6. distinct 去重

    // distinct 去重
    @Test
    public void testDistinct() {
        List<Integer> list = Arrays.asList(1, 2, 2, 3);
        List<Integer> distinct = list.stream()
                .distinct() // 去除重复
                .collect(Collectors.toList());
        log.info("distinct: {}", distinct);
    }

7. limit 取前N个

    // limit 取前N个
    @Test
    public void testLimit() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4);
        List<Integer> limited = list.stream()
                .limit(2) // 取前两个元素
                .collect(Collectors.toList());
        log.info("limited: {}", limited);
    }

8. skip 跳过前N个

    // skip 跳过前N个
    @Test
    public void testSkip() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4);
        List<Integer> skipped = list.stream()
                .skip(2) // 跳过前两个
                .collect(Collectors.toList());
        log.info("skipped: {}", skipped);
    }

9. anyMatch 判断是否存在符合条件的元素

    // anyMatch 判断是否存在符合条件的元素
    @Test
    public void testAnyMatch() {
        List<Integer> list = Arrays.asList(1, 3, 5);
        boolean hasEven = list.stream()
                .anyMatch(n -> n % 2 == 0); // 是否有偶数
        log.info("hasEven: {}", hasEven);
    }

10. allMatch 判断是否所有元素都符合条件

    // allMatch 判断是否所有元素都符合条件
    @Test
    public void testAllMatch() {
        List<Integer> list = Arrays.asList(2, 4, 6);
        boolean allEven = list.stream()
                .allMatch(n -> n % 2 == 0); // 是否都是偶数
        log.info("allEven: {}", allEven);
    }

11. noneMatch 判断是否没有元素符合条件

    // noneMatch 判断是否没有元素符合条件
    @Test
    public void testNoneMatch() {
        List<Integer> list = Arrays.asList(1, 2, 3);
        boolean noneNegative = list.stream()
                .noneMatch(n -> n < 0); // 没有负数
        log.info("noneNegative: {}", noneNegative);
    }

12. collect + joining 拼接字符串

    // collect + joining 拼接字符串
    @Test
    public void testJoining() {
        List<String> names = Arrays.asList("张三", "李四", "王五");
        String result = names.stream()
                .collect(Collectors.joining(", ")); // 使用逗号拼接
        log.info("result: {}", result);
    }

13. collect + groupingBy 分组

    // collect + groupingBy 分组
    @Test
    public void testGroupingBy() {
        List<String> words = Arrays.asList("apple", "banana", "apricot", "blueberry");
        Map<Character, List<String>> grouped = words.stream()
                .collect(Collectors.groupingBy(word -> word.charAt(0))); // 按首字母分组
        log.info("grouped: {}", grouped);

    }

一线网资源-全网一站式平台