当前位置：首页 > article >正文

Stream API 如何使用

article 2024/11/17 18:27:51

简介

Stream 就像工厂中的流水线，适合重复、简单的操作，当数据量较大时，使用 Stream 会获得效率上的提升

如何构建流

Stream.of()
Arrays.stream()
Collection.stream()

流有那些种类

并行流
串行流

流 API 的种类

流 API 可以分为两大类：中间 API 和终结 API

并行流的原理

利用 ForkoinPool ，为每一个 CPU 分配一个任务，最后将任务汇总、收集

案例一，过滤满足条件的元素

public class StreamTest {
    public static void main(String[] args) {
        // 1 ～ 10 的整数列表
        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        List<Integer> evenNumbers = numbers.stream()
                // 留下 n % 2 == 0 为真的元素
                .filter(n -> n % 2 == 0)
                // 留下大于 3 的偶数
                .filter(n -> n > 3)
                // 转换为 List
                .toList();
        // 输出
        System.out.println(evenNumbers);
    }
}

案例二，将多维数组转为一维数组

public class StreamTest {
    public static void main(String[] args) {
        // 二维字符串列表
        List<List<String>> array = List.of(
                List.of("A", "B", "C"),
                List.of("D", "E", "F"),
                List.of("G", "H", "I")
        );

        List<String> list = array.stream()
                // flatMap 进行展开
                .flatMap(List::stream)
                .toList();

        System.out.println(list);
    }
}

案例三，查找满足条件的第一个元素

public class StreamTest {
    public static void main(String[] args) {
        List<Integer> integers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // findFirst 方法返回 Optional 对象，为了防止流为空的情况
        Optional<Integer> first = integers.stream()
                .filter(integer -> (integer & 1) == 0)
        // 串行流 findFirst 和 findAny 行为一致 
                .findFirst();

        System.out.println(first.orElse(0));
    }
}

案例四，判断流中的元素是否存在满足某一条件的元素

public class StreamTest {
    public static void main(String[] args) {
        List<Integer> integers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        System.out.println(integers.stream()
                // allatch 用于判断流中元素是否都满足某一特定条件
                .anyMatch(integer -> integer % 2 == 0));
    }
}

案例五，对流中的元素进行类型转换

public class StreamTest {
    public static void main(String[] args) {
        List<Integer> integers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        integers.stream()
                .map(String::valueOf)
                .toList()
                .forEach(s -> System.out.println(s instanceof String));
    }
}

案例六，计算列表中的数字和

public class StreamTest {
    public static void main(String[] args) {
        List<Integer> integers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        int sum = integers.stream()
                .mapToInt(Integer::intValue)
                .sum();
        
        System.out.println(sum);
    }
}

案例七，对列表中的元素进行累加

public class StreamTest {
    public static void main(String[] args) {
        List<Integer> integers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // 基本类型的 Stream 拥有求和、累加、最大、最小的直接 API
        Optional<Integer> sum = integers.stream()
                .reduce(Integer::sum);
        
        sum.ifPresent(System.out::println);
    }
}

案例八，并行流的累乘

public class StreamTest {
    public static void main(String[] args) {
        List<Integer> integers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        Integer reduce = integers.stream()
                .parallel()
                .reduce(1,
                        (a, b) -> a * b,  // 累乘器
                        (a, b) -> a * b); // 结合器

        System.out.println(reduce);
    }
}