答案：Java 8的Stream API通过中间操作和终端操作实现惰性求值，提升性能与代码可读性。中间操作如filter、map返回新流且惰性执行，终端操作如forEach、collect触发计算并产生结果。惰性求值避免不必要的计算，支持短路操作，优化管道处理，适用于无限流。使用时需避免副作用、重复使用流、不当处理Optional及滥用并行流，推荐保持操作纯粹、正确关闭资源。
Java 8的Stream API确实为我们处理集合数据提供了一套强大而优雅的工具集，它主要包含两大类操作：中间操作（如
filter
map
sorted
forEach
collect
reduce
在我看来，理解Stream API的核心在于掌握其操作分类和惰性求值的哲学。它不仅仅是写出更短的代码，更是改变了我们思考数据处理的方式。
Stream API的常用操作
Stream API的操作可以大致分为两类：
立即学习“Java免费学习笔记（深入）”；
中间操作（Intermediate Operations）：
Stream
filter(Predicate<T> predicate)
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); numbers.stream().filter(n -> n % 2 == 0); // 得到 Stream<2, 4>
map(Function<T, R> mapper)
numbers.stream().map(n -> n * n); // 得到 Stream<1, 4, 9, 16, 25>
flatMap(Function<T, Stream<R>> mapper)
List<List<String>> sentences = Arrays.asList(
Arrays.asList("Hello", "World"),
Arrays.asList("Java", "Stream")
);
sentences.stream().flatMap(Collection::stream); // 得到 Stream<"Hello", "World", "Java", "Stream">distinct()
sorted()
sorted(Comparator<T> comparator)
peek(Consumer<T> action)
limit(long maxSize)
skip(long n)
终端操作（Terminal Operations）：
Stream
forEach(Consumer<T> action)
numbers.stream().filter(n -> n % 2 == 0).forEach(System.out::println); // 打印 2, 4
collect(Collector<T, A, R> collector)
List<Integer> evens = numbers.stream().filter(n -> n % 2 == 0).collect(Collectors.toList()); // 得到 [2, 4]
Map<Boolean, List<Integer>> partitioned = numbers.stream().collect(Collectors.partitioningBy(n -> n % 2 == 0)); // 得到 {true=[2, 4], false=[1, 3, 5]}reduce(BinaryOperator<T> accumulator)
reduce(T identity, BinaryOperator<T> accumulator)
Optional<Integer> sum = numbers.stream().reduce(Integer::sum); // 得到 Optional[15] Integer sumWithIdentity = numbers.stream().reduce(0, Integer::sum); // 得到 15
count()
min(Comparator<T> comparator)
max(Comparator<T> comparator)
anyMatch(Predicate<T> predicate)
allMatch(Predicate<T> predicate)
noneMatch(Predicate<T> predicate)
findFirst()
findAny()
Stream API的惰性求值
是的，Stream API是惰性求值的（Lazy Evaluation）。这意味着当你调用一个中间操作时，它并不会立即处理数据，而是仅仅记录下这个操作，并返回一个新的Stream。只有当一个终端操作被调用时，整个操作链才会被“激活”，数据才会从源头流过整个管道并进行计算。
这种机制带来了很多好处：
filter
limit(10)
filter
limit()
findFirst()
anyMatch()
在我看来，中间操作和终端操作之间的区别，是理解Stream API运作机制的关键。说白了，中间操作就像是你在规划一次旅行的路线图，你只是标记出要经过哪些地方，要怎么走，但你还没有真正出发。而终端操作，就是你真正踏上旅程，开始按照路线图行动，最终到达目的地。
中间操作的特性：
Stream
filter
map
peek
filter
map
sorted
distinct
sorted
distinct
终端操作的特性：
Stream
List
Optional
long
void
IllegalStateException
collect
reduce
count
forEach
举个例子，想象你有一箱苹果（源数据），你想找出其中红色的、没有虫子的，然后把它们切成片，最后装到一个篮子里。
filter(是红色的)
filter(没有虫子)
map(切成片)
collect(装到篮子里)
惰性求值是Stream API的性能基石，它让Stream在很多场景下比传统的迭代器循环更加高效，甚至能处理理论上的无限数据流。在我看来，这不仅仅是代码风格的改变，更是计算哲学上的一种优化。
1. 避免不必要的计算
这是惰性求值最直接的好处。Stream管道只有在终端操作被调用时才开始执行，并且会尽可能地延迟计算。这意味着，如果一个操作的结果在后续的管道中没有被用到，或者可以提前确定最终结果，那么这个操作甚至可能不会被完全执行。
考虑这样一个场景：
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");
Optional<String> foundName = names.stream()
.filter(name -> {
System.out.println("Filtering: " + name);
return name.startsWith("C");
})
.map(name -> {
System.out.println("Mapping: " + name);
return name.toUpperCase();
})
.findFirst(); // 终端操作如果你运行这段代码，你会发现输出可能是这样的：
Filtering: Alice Filtering: Bob Filtering: Charlie Mapping: Charlie
注意到了吗？
filter
map
findFirst()
filter
map
2. 短路操作的效率
limit()
findFirst()
anyMatch()
allMatch()
noneMatch()
limit(n)
anyMatch(predicate)
true
3. 管道优化
由于中间操作不立即执行，Stream API有机会对整个操作管道进行优化。JVM可以在内部重排操作顺序，或者将多个操作合并成一个，以减少遍历次数和提高CPU缓存效率。例如，一个
filter
map
4. 处理无限流
惰性求值是处理无限流（如
Stream.iterate()
Stream.generate()
// 生成一个无限的偶数流，并取出前5个
Stream.iterate(0, n -> n + 2) // 无限流
.limit(5) // 短路中间操作
.forEach(System.out::println); // 终端操作
// 输出：0, 2, 4, 6, 8如果没有
limit
iterate
总而言之，惰性求值让Stream API能够以一种更智能、更高效的方式处理数据。它将计算的责任从数据生成者转移到数据消费者，从而允许在需要时才进行计算，并提供灵活的优化机会。
Stream API虽然强大，但使用不当也可能引入一些意想不到的问题。我个人在实践中遇到过一些，也总结了一些经验，希望对大家有所帮助。
常见的陷阱：
修改源集合或外部状态（Side Effects）：
filter
map
List<String> names = new ArrayList<>(Arrays.asList("A", "B", "C"));
names.stream().filter(s -> {
// 错误示范：在filter中修改源集合
// names.remove(s); // 会抛出 ConcurrentModificationException
return true;
}).forEach(System.out::println);collect
forEach
peek
重复使用已消耗的Stream：
IllegalStateException
Stream<String> myStream = Arrays.asList("a", "b", "c").stream();
myStream.forEach(System.out::println); // 第一次消耗
// myStream.count(); // 错误！会抛出 IllegalStateException对Optional
findFirst()
min()
max()
Optional
get()
isPresent()
NoSuchElementException
List<Integer> emptyList = Collections.emptyList(); // 错误示范 // Integer max = emptyList.stream().max(Integer::compare).get();
Optional
orElse()
orElseGet()
orElseThrow()
ifPresent()
isPresent()
过度使用并行流（Parallel Stream）：
不关闭资源：
Files.lines()
BufferedReader.lines()
try-with-resources
try (Stream<String> lines = Files.lines(Paths.get("myfile.txt"))) {
lines.forEach(System.out::println);
} catch (IOException e) {
e.printStackTrace();
}最佳实践：
filter
map
forEach
collect
reduce
anyMatch
peek()
peek()
numbers.stream()
.filter(n -> n % 2 == 0)
.peek(e -> System.out.println("Filtered element: " + e))
.map(n -> n * n)以上就是Java 8中的Stream API有哪些常用操作？它是惰性求值的吗？的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
广告Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
746
收藏
