Java高频面试之SE-23

hello啊，各位观众姥爷们！！！本baby今天又来了！哈哈哈哈哈嗝🐶

Java 中的 Stream 是 Java 8 引入的一种全新的数据处理方式，它基于函数式编程思想，提供了一种高效、简洁且灵活的方式来操作集合数据。Stream 的核心思想是 声明式编程（告诉程序"做什么"，而不是"怎么做"）。

---

1. Stream 的核心特点

1. 无存储：Stream 不存储数据，只是对数据源的视图（如集合、数组、I/O 通道等）。
2. 函数式操作 ：支持链式调用（如 filter → map → collect），每个操作返回新的 Stream。
3. 延迟执行（Lazy Evaluation） ：中间操作（如 filter、map）不会立即执行，只有在终端操作（如 collect）触发时才会计算。
4. 可消费性：Stream 只能被消费一次，终端操作后 Stream 即失效。

---

2. Stream 的创建

Stream 可以通过多种方式创建：

(1) 从集合创建

List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream();       // 顺序流
Stream<String> parallelStream = list.parallelStream(); // 并行流

(2) 从数组创建

String[] array = {"a", "b", "c"};
Stream<String> stream = Arrays.stream(array);

(3) 静态工厂方法

Stream<String> stream = Stream.of("a", "b", "c");
Stream<Integer> infiniteStream = Stream.iterate(0, n -> n + 1); // 无限流
Stream<Double> randomStream = Stream.generate(Math::random);     // 生成流

---

3. Stream 的操作分类

Stream 的操作分为两类：

• 中间操作（Intermediate Operations） ：返回新的 Stream，可以链式调用（如 filter, map, sorted）。
• 终端操作（Terminal Operations） ：触发计算并关闭 Stream（如 collect, forEach, reduce）。

---

4. 常用中间操作

(1) filter(Predicate<T>)：过滤元素

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> evens = numbers.stream()
    .filter(n -> n % 2 == 0)
    .collect(Collectors.toList()); // [2, 4]

(2) map(Function<T, R>)：元素转换

List<String> words = Arrays.asList("apple", "banana");
List<Integer> lengths = words.stream()
    .map(String::length)
    .collect(Collectors.toList()); // [5, 6]

(3) sorted()：排序

List<Integer> numbers = Arrays.asList(3, 1, 4);
List<Integer> sorted = numbers.stream()
    .sorted()
    .collect(Collectors.toList()); // [1, 3, 4]

(4) distinct()：去重

List<Integer> numbers = Arrays.asList(1, 2, 2, 3);
List<Integer> unique = numbers.stream()
    .distinct()
    .collect(Collectors.toList()); // [1, 2, 3]

(5) limit(long) 和 skip(long)：限制和跳过元素

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> result = numbers.stream()
    .skip(2)
    .limit(2)
    .collect(Collectors.toList()); // [3, 4]

---

5. 常用终端操作

(1) collect(Collector)：将流转换为集合或其他结构

List<String> list = Stream.of("a", "b", "c")
    .collect(Collectors.toList()); // [a, b, c]

String joined = Stream.of("a", "b", "c")
    .collect(Collectors.joining(", ")); // "a, b, c"

(2) forEach(Consumer<T>)：遍历元素

Stream.of("a", "b", "c")
    .forEach(System.out::println); // 输出 a b c

(3) reduce(BinaryOperator<T>)：归约操作（如求和）

int sum = Stream.of(1, 2, 3, 4)
    .reduce(0, Integer::sum); // 10

(4) count()：统计元素数量

long count = Stream.of(1, 2, 3).count(); // 3

(5) anyMatch() / allMatch() / noneMatch()：条件匹配

boolean hasEven = Stream.of(1, 3, 5)
    .anyMatch(n -> n % 2 == 0); // false

---

6. 并行流（Parallel Stream）

通过 parallelStream() 或 stream().parallel() 创建并行流，利用多核处理器加速处理：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4);
List<Integer> squares = numbers.parallelStream()
    .map(n -> n * n)
    .collect(Collectors.toList()); // [1, 4, 9, 16]

注意：

• 并行流适用于数据量大且无状态的操作。
• 避免在并行流中使用共享可变变量。

---

7. 原始类型流（Primitive Streams）

Java 提供了针对原始类型的流，避免装箱开销：

• IntStream（int 类型）
• LongStream（long 类型）
• DoubleStream（double 类型）

IntStream.range(1, 5).forEach(System.out::println); // 输出 1 2 3 4
double avg = DoubleStream.of(1.0, 2.0, 3.0).average().orElse(0); // 2.0

---

8. Stream 的典型应用场景

(1) 集合过滤和转换

List<User> users = ...;
List<String> names = users.stream()
    .filter(u -> u.getAge() > 18)
    .map(User::getName)
    .collect(Collectors.toList());

(2) 分组和统计

Map<String, List<User>> groupByCity = users.stream()
    .collect(Collectors.groupingBy(User::getCity));

(3) 数据归约

int totalAge = users.stream()
    .mapToInt(User::getAge)
    .sum();

---

9. 注意事项

1. Stream 不可重用 ：终端操作后 Stream 关闭，再次使用会抛出 IllegalStateException。
2. 避免副作用 ：不要在 map、filter 中修改外部状态。
3. 性能权衡：并行流不一定更快，需根据数据量和操作复杂度评估。

---