流是用于操作数据源(如集合、数组等)生成的元素序列的抽象数据结构。流就像花洒一样,通过不同的过滤器和形状来改变数据流的形式和处理方式。
流的中间操作(如 filter
, map
等)不会立即执行,而是在终端操作(如 forEach
, collect
等)触发时才执行。这种特性允许流在进行多个中间操作时,只遍历一次数据源,从而提高效率。
流本身不存储数据,它只是数据的视图或操作的管道。流操作分为中间操作和终端操作。
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;
public class LazyExecution {
public static void main(String[] args) {
List<String> names = Arrays.asList("John", "Jane", "Jack", "Doe");
// 创建流并进行一系列中间操作
Stream<String> stream = names.stream()
.filter(name -> {
System.out.println("Filtering: " + name);
return name.startsWith("J");
})
.map(name -> {
System.out.println("Mapping: " + name);
return name.toUpperCase();
});
System.out.println("Before terminal operation");
// 终端操作开始时,中间操作才会执行
stream.forEach(System.out::println);
System.out.println("After terminal operation");
}
}
// 通过调用stream()函数进行流的创建
List<String> list = Arrays.asList("a", "b", "c");
Stream<String> streamFromList = list.stream();
// 通过调用Array中的stream()方法,将集合传进去进行流的创建
String[] array = ["a", "b", "c"];
Stream<String> streamFromArry = Arrays.stream(array);
Stream.of()
方法// 直接调用Stream.of()方法,传入若干字符串进行流的创建
Stream<String> streamOf = Stream.of("a", "b", "c");
⌨流操作分为中间操作和终端操作。中间操作返回的是流本身,可以进行链式调用。终端操作返回的是结果(如 List、数组、计算值等)。
filter
:过滤流中的元素。
list.stream().filter(s -> s.startsWith("a")).forEach(System.out::println);
map
:将元素映射到另一个形式。
list.stream().map(String::toUpperCase).forEach(System.out::println);
flatMap
:将每个元素映射为流,然后将这些流合并为一个流。
List<List<String>> listOfLists = Arrays.asList(
Arrays.asList("a", "b"),
Arrays.asList("c", "d")
);
listOfLists.stream().flatMap(List::stream).forEach(System.out::println);
sorted
:对流中的元素进行排序。
list.stream().sorted().forEach(System.out::println);
distinct
:去除流中的重复元素。
list.stream().distinct().forEach(System.out::println);
limit
:截取流中的前 n 个元素。
list.stream().limit(2).forEach(System.out::println);
skip
:跳过流中的前 n 个元素。
list.stream().skip(2).forEach(System.out::println);
import java.util.*;
import java.util.stream.*;
public class IntermediateOperations {
public static void main(String[] args) {
List<String> list = Arrays.asList("a", "b", "c", "a");
// filter
list.stream()
.filter(s -> s.startsWith("a"))
.forEach(System.out::println); // 输出: a, a
// map
list.stream()
.map(String::toUpperCase)
.forEach(System.out::println); // 输出: A, B, C, A
// sorted
list.stream()
.sorted()
.forEach(System.out::println); // 输出: a, a, b, c
// distinct
list.stream()
.distinct()
.forEach(System.out::println); // 输出: a, b, c
}
}
forEach
:对流中的每个元素执行操作。
list.stream().forEach(System.out::println);
collect
:将流中的元素收集到集合、列表或映射中。
List<String> filteredList = list.stream()
.filter(s -> s.startsWith("a"))
.collect(Collectors.toList());
toArray
:将流中的元素转换为数组。
String[] array = list.stream().toArray(String[]::new);
reduce
:对流中的元素进行合并操作。
Optional reduced = list.stream().reduce((s1, s2) -> s1 + "#" + s2);
count
:计算流中的元素数量。
long count = list.stream().count();
anyMatch
, allMatch
, noneMatch
:匹配流中的元素。
boolean anyMatch = list.stream().anyMatch(s -> s.startsWith("a"));
boolean allMatch = list.stream().allMatch(s -> s.length() == 1);
boolean noneMatch = list.stream().noneMatch(s -> s.startsWith("z"));
findFirst
,findAny
:查找流中的元素。
Optional first = list.stream().findFirst();
Optional any = list.stream().findAny();
import java.util.*;
import java.util.stream.*;
public class TerminalOperations {
public static void main(String[] args) {
List<String> list = Arrays.asList("a", "b", "c", "a");
// forEach
list.stream()
.forEach(System.out::println); // 输出: a, b, c, a
// collect
List<String> filteredList = list.stream()
.filter(s -> s.startsWith("a"))
.collect(Collectors.toList());
System.out.println(filteredList); // 输出: [a, a]
// toArray
String[] array = list.stream()
.toArray(String[]::new);
System.out.println(Arrays.toString(array)); // 输出: [a, b, c, a]
// reduce
Optional<String> reduced = list.stream()
.reduce((s1, s2) -> s1 + "#" + s2);
reduced.ifPresent(System.out::println); // 输出: a#b#c#a
// count
long count = list.stream()
.count();
System.out.println(count); // 输出: 4
// anyMatch, allMatch, noneMatch
boolean anyMatch = list.stream()
.anyMatch(s -> s.startsWith("a"));
System.out.println(anyMatch); // 输出: true
boolean allMatch = list.stream()
.allMatch(s -> s.length() == 1);
System.out.println(allMatch); // 输出: true
boolean noneMatch = list.stream()
.noneMatch(s -> s.startsWith("z"));
System.out.println(noneMatch); // 输出: true
// findFirst, findAny
Optional<String> first = list.stream()
.findFirst();
first.ifPresent(System.out::println); // 输出: a
Optional<String> any = list.stream()
.findAny();
any.ifPresent(System.out::println); // 可能输出: a
}
}
✌ 通过调用 parallelStream()
方法,可以将流转换为并行流,以提高性能。并行流将数据分割成多个块,并在多个线程中进行处理,从而加速计算过程。
import java.util.*;
import java.util.stream.*;
public class ParallelStream {
public static void main(String[] args) {
List<String> list = Arrays.asList("a", "b", "c", "d");
// 并行流
list.parallelStream()
.forEach(System.out::println); // 输出顺序不定
}
}
filter
, map
, sorted
等,支持链式调用,惰性执行。forEach
, collect
, reduce
等,触发流的处理并产生结果。parallelStream()
提供并行处理能力,适用于需要大量计算的场景。通过合理使用流,能够提高代码的可读性和性能。流的操作符及其特性是现代 Java 编程中非常重要的知识点。