一、概述
Stream操作简称流操作，这里的流与IO流毫无关系，这里的流指的是流式操作，就是流水线操作。
Stream流操作主要包包括三大模块：创建流操作、中间流操作、终结流操作。
其中创建流主要是创建Stream对象。每个Stream对象只能使用一次终结操作。
中间流操作指的是各种中间流操作方法，比如去重、过滤、排序等
终结流操作指的结果操作，终结操作的目的是产生最终结果。
二、创建流
2.1 基于数组创建流
public class StreamTest {
public static void createStream() {
// 通过数组生成流
int[] ints = {1,2,3,4,5,6};
IntStream s1 = Arrays.stream(ints);
Stream s2 = Stream.of("111","222","333");
String[] ss = {"123","321","456","654"};
Stream<String> s3 = Arrays.stream(ss);
}
}
3.2 通过构建器生成流
public class StreamTest {
public static void createStream() {
// 通过构建器生成流
Stream<Object> s4 = Stream.builder().add("123").add("321").add("444").add("@21").build();
}
}
3.3 基于集合生成流
public class StreamTest {
public static void createStream() {
// 通过集合生成流
List<String> lists = Arrays.asList("123","321","1212","32321");
Stream<String> s5 = lists.stream();
Stream<String> s6 = lists.parallelStream();// 并行流
}
}
3.4 创建空流
public class StreamTest {
public static void createStream() {
// 创建空流
Stream<String> s7 = Stream.empty();
}
}
3.5 基于函数创建无限流
public class StreamTest {
public static void createStream() {
// 创建无限流
Stream.generate(()->"number"+new Random().nextInt()).limit(100).forEach(System.out::println);
Stream.iterate(0,n -> n+2).limit(10).forEach(System.out::println);
}
}
三、流中间操作
这里的流中间操作指的是该操作的返回值仍然是流。
| 序号 | 操作 | 方法 | 说明 | 备注 |
|---|---|---|---|---|
| 1 | filter | Stream<T>filter(Predicate<?superT>predicate) | 返回当前流中满足参数predicate过滤条件的元素组成的新流 | 过滤器 |
| 2 | map | <R>Stream<R>map(Function<?superT,?extendsR>mapper) | 返回通过给定mapper作用于当前流的每个元素之后的结果组成的新流 | 函数 |
| 3 | mapToInt | IntStreammapToInt(ToIntFunction<?superT>mapper) | 返回通过给定mapper作用于当前流的每个元素之后的结果组成的新的Int流 | 函数 |
| 4 | mapToLong | LongStreammapToLong(ToLongFunction<?superT>mapper) | 返回通过给定mapper作用于当前流的每个元素之后的结果组成的新的Long流 | 函数 |
| 5 | mapToDouble | DoubleStreammapToDouble(ToDoubleFunction<?superT>mapper) | 返回通过给定mapper作用于当前流的每个元素之后的结果组成的新的Double流 | 函数 |
| 6 | flatMap | <R>Stream<R>flatMap(Function<?superT,?extendsStream<?extendsR>>mapper) | 根据给定的mapper作用于当前流的每个元素，将结果组成新的流来返回 | 扁平函数 |
| 7 | flatMapToInt | IntStreamflatMapToInt(Function<?superT,?extendsIntStream>mapper) | 根据给定的mapper作用于当前流的每个元素，将结果组成新的Int流来返回 | 扁平函数 |
| 8 | flatMapToLong | LongStreamflatMapToLong(Function<?superT,?extendsLongStream>mapper) | 根据给定的mapper作用于当前流的每个元素，将结果组成新的Long流来返回 | 扁平函数 |
| 9 | flatMapToDouble | DoubleStreamflatMapToDouble(Function<?superT,?extendsDoubleStream>mapper) | 根据给定的mapper作用于当前流的每个元素，将结果组成新的Double流来返回 | 扁平函数 |
| 10 | distinct | Stream<T>distinct() | 返回去掉当前流中重复元素之后的新流 | 去重 |
| 11 | sorted | Stream<T>sorted() | 返回当前流中元素排序之后的新流，需要元素类型实现Comparable | 排序 |
| 12 | sorted | Stream<T>sorted(Comparator<?superT>comparator) | 返回当前流中元素排序之后的新流，需要传递一个Comparator | 排序 |
| 13 | peek | Stream<T>peek(Consumer<?superT>action) | 针对流中的每个元素执行操作action | 查阅 |
| 14 | limit | Stream<T>limit(longmaxSize) | 返回指定的数量的元素组成的新流 | 限制 |
| 15 | skip | Stream<T>skip(longn) | 返回第n个之后的元素组成的新流 | 跳过 |
扁平函数，就是将当前流的每个元素通过执行给定的mapper操作，从而扩充，释放每个元素内的子元素，从而形成一个由所有子元素组成的新流，比如当前流是包含N个字符串的流，使用这个方法，可以获取到包含字符串中字符组成的流。
3.1 filter
filter方法是过滤器方法，针对的是流中所有元素，满足条件的元素将会被保留以组成新的流。
public class StreamTest {
public static void filterTest(List<String> list){
list.stream()
.filter(e -> e.length() > 4 && e.length()<7)// 过滤掉长度小于等于4,大于等于7的元素
.peek(System.out::println)// 查阅中间流结果
.collect(Collectors.toList());
}
public static void main(String[] args) {
List<String> list = Arrays.asList("123","456","789","1101","asdaa","3e3e3e","2321eew","212121121");
filterTest(list);
}
}
执行结果为：
asdaa
3e3e3e
filter方法的参数是Predicate类型，这个函数式接口用于获取一个参数返回一个boolean值，整个参数作为过滤条件。
3.2 map
map方法可以理解为函数，需要针对流中的每个元素执行，然后将执行的结果组成新的流返回。
public class StreamTest {
public static void mapTest(List<String> list){
list.stream()
.map(e -> "@" + e)// 为每个元素执行操作：添加前缀
.peek(System.out::println)// 查阅中间流结果
.collect(Collectors.toList());
}
public static void main(String[] args) {
List<String> list = Arrays.asList("123","456","789","1101","asdaa","3e3e3e","2321eew","212121121");
mapTest(list);
}
}
执行结果为：
@123
@456
@789
@1101
@asdaa
@3e3e3e
@2321eew
@212121121
map方法的参数类型为Function，该函数式接口用于接受一个参数，返回一个结果。
mapToInt、mapToLong、mapToDouble方法是map方法的扩展，其参数分别为ToIntFunction、ToLongFunction、ToDoubleFunction，分别接口一个参数，返回指定类型的值，分别为int、long、double，那么定义方法的时候就要注意返回值的类型了，必须一致，最后组成的新流就是一个int或long或double元素流（IntStream、LongStream、DoubleStream）。
mapToInt的简单使用（其他类似）：
public class StreamTest {
public static void mapToIntTest(List<String> list){
list.stream()
.mapToInt(e -> e.length())// 以元素的长度为新流
.peek(System.out::println)// 查询中间结果
.toArray();
}
public static void main(String[] args) {
List<String> list = Arrays.asList("123","456","789","1101","asdaa","3e3e3e","2321eew","212121121");
mapToIntTest(list);
}
}
执行结果为：
3
3
3
4
5
6
7
9
3.3 flatMap
flatMap和map还是有点关系的，都是针对流中的每一个元素进行操作，将结果组成新流，不过flatMap含有一层扩展之意，就是当流中元素包含子元素的时候，通过该方法，获取到元素的子元素，并将子元素组成新流返回。
public class StreamTest {
public static void flatMap(List<String> list){
list.stream()
.filter(e -> e.length()>5 && e.length()<7)
.peek(System.out::println)
.map(e -> e.split(""))// 将每个字符串元素分解为字符数组
.flatMap(Arrays::stream)//将每个字符数组并转化为流
.peek(System.out::println)
.collect(Collectors.toList());
}
public static void main(String[] args) {
List<String> list = Arrays.asList("123","456","789","1101","asdaa","3e3e3e","2321eew","212121121");
flatMap(list);
}
}
执行结果为：
3e3e3e
3
e
3
e
3
e
flatMapToInt、flatMapToLong、flatMapToDouble类似于之前的mapToInt之类。
3.4 distinct
distinct方法用于去重，很简单。
public class StreamTest {
public static void distinctTest(){
int[] int1 = {1,2,3,4};
int[] int2 = {5,3,7,1};
List<int[]> ints = Arrays.asList(int1,int2);
ints.stream()
.flatMapToInt(Arrays::stream)
.distinct()
.peek(System.out::println)
.toArray();
}
public static void main(String[] args) {
distinctTest();
}
}
执行结果为：
1
2
3
4
5
7
结果中显而易见，重复的1和3被去除了。
3.5 sorted
sorted表示对流中的元素进行排序，需要使用Conparable和Comparator。
public class StreamTest {
public static void sortedTest(List<String> list){
System.out.println("----自然顺序:");
list.stream().sorted().peek(System.out::println).collect(Collectors.toList());
System.out.println("----指定排序:");
list.stream().sorted((a,b) -> a.length()-b.length()).peek(System.out::println).collect(Collectors.toList());
}
public static void main(String[] args) {
List<String> list = Arrays.asList("123","456","789","1101","asdaa","3e3e3e","2321eew","212121121");
sortedTest(list);
}
}
执行结果为：
----自然顺序:
1101
123
212121121
2321eew
3e3e3e
456
789
asdaa
----指定排序:
123
456
789
1101
asdaa
3e3e3e
2321eew
212121121
当调用无参的sorted方法时，采用自然排序法排序，当使用指定比较器的方式时，可以自由指定排序规则。
3.6 limit
limit可用于从首个元素开始截取N个元素，组成新流返回。
public class StreamTest {
public static void limitTest(List<String> list){
list.stream().limit(2).peek(System.out::println).collect(Collectors.toList());
}
public static void main(String[] args) {
List<String> list = Arrays.asList("123","456","789","1101","asdaa","3e3e3e","2321eew","212121121");
limitTest(list);
}
}
执行结果为：
123
456
3.7 skip
skip表示放弃N个元素，将剩余元素组成新流返回。
public class StreamTest {
public static void skipTest(List<String> list){
list.stream().skip(2).peek(System.out::println).collect(Collectors.toList());
}
public static void main(String[] args) {
List<String> list = Arrays.asList("123","456","789","1101","asdaa","3e3e3e","2321eew","212121121");
skipTest(list);
}
}
执行结果为：
789
1101
asdaa
3e3e3e
2321eew
212121121
放弃了前2个元素，将剩余元素组成了新流。
四、流终结操作
| 序号 | 操作 | 方法 | 说明 | 备注 |
|---|---|---|---|---|
| 1 | forEach | voidforEach(Consumer<?superT>action) | 对流中的每个元素执行指定的操作action | 遍历 |
| 2 | forEachOrdered | voidforEachOrdered(Consumer<?superT>action) | 如果有序，则按序遍历流中元素，针对每个元素执行指定操作 | 按序遍历 |
| 3 | toArray | Object[]toArray() | 返回一个包含流中所有元素的数组 | 数组化 |
| 4 | toArray | <A>A[]toArray(IntFunction<A[]>generator) | 返回一个包含流中所有元素的参数指定类型的数组 | 数组化 |
| 5 | reduce | Treduce(Tidentity,BinaryOperator<T>accumulator) | 以给定初始值为基础归纳流中元素，返回一个值 | 归纳 |
| 6 | reduce | Optional<T>reduce(BinaryOperator<T>accumulator) | 直接归纳流中的元素，返回一个封装有结果的Optional | 归纳 |
| 7 | reduce | <U>Ureduce(Uidentity,BiFunction<U,?superT,U>accumulator,BinaryOperator<U>combiner) | 以给定的初始值为基础，（并行）归纳流中元素，最后将各个线程的结果再统一归纳，返回一个值 | 归纳 |
| 8 | collect | <R,A>Rcollect(Collector<?superT,A,R>collector) | 根据给定的收集器收集元素 | 归纳 |
| 9 | collect | <R>Rcollect(Supplier<R>supplier,BiConsumer<R,?superT>accumulator,BiConsumer<R,R>combiner) | 根据给定的各个参数归纳元素 | 归纳 |
| 10 | max | Optional<T>max(Comparator<?superT>comparator) | 根据给定的比较器，返回流中最大元素的Optional表示 | 最大值 |
| 11 | min | Optional<T>min(Comparator<?superT>comparator) | 根据给定的比较器，返回流中最小元素的Optional表示 | 最小值 |
| 12 | count | longcount() | 返回流中元素的个数 | 计数 |
| 13 | anyMatch | booleananyMatch(Predicate<?superT>predicate) | 校验流中是否有满足给定条件的元素 | 校验 |
| 14 | allMatch | booleanallMatch(Predicate<?superT>predicate) | 校验流中的元素是否全部满足给定条件 | 校验 |
| 15 | noneMatch | booleannoneMatch(Predicate<?superT>predicate) | 校验流中的元素是否全不满足给点条件 | 校验 |
| 16 | findFirst | Optional<T>findFirst() | 返回首个元素的Optional表示，如果为空流，返回空的Optional | 返回首个元素 |
| 17 | findAny | Optional<T>findAny() | 如果流中有元素，则返回第一个元素的Optional表示，否则返回一个空的Optional | 校验是否为空流 |
4.1 forEach和forEachOrdered
forEach就是遍历操作，针对流中的每个元素做最后的操作。
public class StreamTest {
public static void forEachTest(List<String> list){
list.stream().parallel().forEach(System.out::println);
}
public static void forEachOrderedTest(List<String> list){
list.stream().parallel().forEachOrdered(System.out::println);
}
public static void main(String[] args) {
List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
forEachTest(list);
System.out.println("----------");
forEachOrderedTest(list);
}
}
执行结果为：
asdaa
212121121
789
1101
2321eew
3e3e3e
456
123
----------
123
456
789
1101
212121121
asdaa
3e3e3e
2321eew
二者都是遍历操作，从结果是可以看出来，如果是单线程（也就是不加parallel方法的情况）那么二者结果是一致的，但是如果采用并行遍历，那么就有区别了，forEach并行遍历不保证顺序（顺序随机）,forEachOrdered却是保证顺序来进行遍历的。
4.2 toArray
public class StreamTest {
public static void toArrayTest(List<String> list){
Object[] objs = list.stream().filter(e -> e.length()>6).toArray();
String[] ss = list.stream().filter(e -> e.length()>6).toArray(String[]::new);
}
public static void main(String[] args) {
List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
toArrayTest(list);
}
}
toArray有两个方法，一个是无参方法，一个有参方法。
无参方法返回的只能是Object[]数组类型，而有参方法，可以指定结果数组类型，此乃二者区别。
使用有参方法可以直接完成类型转换，一次到位。
4.4 reduce
reduce方法有三个重载的方法，
public interface Stream<T> extends BaseStream<T, Stream<T>> {
Optional<T> reduce(BinaryOperator<T> accumulator);// 编号1
T reduce(T identity, BinaryOperator<T> accumulator);// 编号2
<U> U reduce(U identity,
BiFunction<U, ? super T, U> accumulator,
BinaryOperator<U> combiner);// 编号3
}
这三个方法的作用其实是一样的，就是归纳总结的意思。
首先看编号1方法，只有一个参数accumulator，这是一个累加器，方法的作用就是将这个累加器作用到流中的每一个元素，他需要两个输入参数，有一个输出参数，意思是对两个元素执行某些操作，返回一个结果，然后将这个结果与下一个元素作为参数再输入该方法，执行操作后再返回一个新结果，以此类推，直到最后一个元素执行完毕，返回的就是最终结果，因为流中的元素我们是不确定的，那么我们就无法确定reduce的结果，因为如果流为空，那么将会返回null，所以使用Optional作为返回值，妥善处理null值。
再看编号2方法，在编号1方法的基础上加了一个identity，且不再使用Optional，为什么呢，因为新加的identity其实是个初始值，后续的操作都在这个值基础上执行，那么也就是说，，如果流中没有元素的话，还有初始值作为结果返回，不会存在null的情况，也就不用Optional了。
再看编号3方法，在编号2方法的基础上又加了一个参数combiner，其实这个方法是用于处理并行流的归纳操作，最后的参数combiner用于归纳各个并行的结果，用于得出最终结果。
那么如果不使用并行流，一般使用编号2方法就足够了。
示例：
public class StreamTest {
public static void reduceTest(){
List<Integer> ints = Arrays.asList(1,2,3,4,5,6,7,8,9);
Optional<Integer> optional = ints.stream().reduce(Integer::sum);
System.out.println(optional.get());
System.out.println("-------------");
Integer max = ints.stream().reduce(Integer.MIN_VALUE, Integer::max);
System.out.println(max);
System.out.println("-------------");
Integer min = ints.parallelStream().reduce(Integer.MAX_VALUE, Integer::min, Integer::min);
System.out.println(min);
}
public static void main(String[] args) {
reduceTest();
}
}
执行结果为：
45
-------------
9
-------------
1
4.5 collect
collect操作是Stream中最强大的方法了，几乎可以得到任何你想要的结果，collect方法有两个重载方法：
public interface Stream<T> extends BaseStream<T, Stream<T>> {
<R> R collect(Supplier<R> supplier,
BiConsumer<R, ? super T> accumulator,
BiConsumer<R, R> combiner);// 编号1
<R, A> R collect(Collector<? super T, A, R> collector);// 编号2
}
collect是收集的意思，这里的作用就是收集归纳，将流中的数据映射为各种结果。
首先看看编号1方法，有三个参数：supplier用于生成一个R类型的结果容器来盛放结果，accumulator累加器用于定义盛放的方式，其中T为一个元素，R为结果容器，第三个参数combiner的作用是将并行操作的各个结果整合起来。
public class StreamTest {
public static void collectTest1(List<String> list){
ArrayList<String> arrayList = list.stream().skip(4).collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
arrayList.forEach(System.out::println);
}
public static void main(String[] args) {
List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
collectTest1(list);
}
}
执行结果：
212121121
asdaa
3e3e3e
2321eew
例子中，第一个：ArrayList::new表示创建一个新的ArrayList集合，第二个 ArrayList::add表示将元素一个一个添加到之前的集合中，第三个ArrayList::addAll表示将多个线程的ArrayList集合一个一个的整体添加到第一个集合中，最终整合出一个最终结果并返回。
然后我们重点来看看编号2方法。
它只需要一个Collector类型的参数，这个Collector可以称呼为收集器，我们可以随意组装一个收集器来进行元素归纳。
Collector是定义来承载一个收集器，但是JDK提供了一个Collectors工具类，在这个工具类里面预实现了N多的Collector供我们直接使用，之前的Collectors.toList()就是其用法之一。具体见下文。
public class StreamTest {
public static void collectTest2(List<String> list){
Set<String> set = list.stream().skip(4).collect(Collectors.toSet());
set.forEach(System.out::println);
}
public static void main(String[] args) {
List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
collectTest2(list);
}
}
执行结果为：
212121121
2321eew
3e3e3e
asdaa
有关Collector具体可阅读：Java流式操作系列-Collector和Collectors
4.6 max\min
通过给定的比较器，得出流中最大\最小的元素，为避免null返回，这里使用Optional来封装返回值。
public class StreamTest {
public static void maxMinTest(List<String> list){
System.out.println("长度最大：" + list.stream().max((a,b)-> a.length()-b.length()));
System.out.println("长度最小：" + list.stream().min((a,b)-> a.length()-b.length()));
}
public static void main(String[] args) {
List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
maxMinTest(list);
}
}
执行结果为：
长度最大：Optional[212121121]
长度最小：Optional[123]
4.7 count
count是无参方法，用于计数，返回流中元素个数。
public class StreamTest {
public static void countTest(List<String> list){
System.out.println("元素个数为：" + list.stream().count());
}
public static void main(String[] args) {
List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
countTest(list);
}
}
执行结果为：
元素个数为：8
4.8 anyMatch
该方法需要一个Predicate参数，用于校验流中的元素，只要有一个满足规则，则返回true，全不满足，返回false。
public class StreamTest {
public static void anyMatchTest(List<String> list){
System.out.println(list.stream().anyMatch(e -> e.length()>10));
System.out.println(list.stream().anyMatch(e -> e.length()>8));
}
public static void main(String[] args) {
List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
anyMatchTest(list);
}
}
执行结果为：
false
true
4.9 allMatch
该方法同样需要一个Predicate参数，用于校验流中的所有元素，只有全部满足规则才能返回true，只要有一个不满足则返回false。
public class StreamTest {
public static void allMatchTest(List<String> list){
System.out.println(list.stream().allMatch(e -> e.length()>1));
System.out.println(list.stream().allMatch(e -> e.length()>3));
}
public static void main(String[] args) {
List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
allMatchTest(list);
}
}
执行结果为：
true
false
4.10 noneMatch
该方法同样需要一个Predicate参数，用于校验流中的所有元素,只有所有元素都不满足规则的情况下返回true，否则返回false。
public class StreamTest {
public static void noneMatchTest(List<String> list){
System.out.println(list.stream().noneMatch(e -> e.length()>10));
System.out.println(list.stream().noneMatch(e -> e.length()>8));
}
public static void main(String[] args) {
List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
noneMatchTest(list);
}
}
执行结果为：
true
false
4.11 findFirst
该方法无参数，主要用于获取流中的第一个元素，如果流无序，那么可能返回任意一个。
public class StreamTest {
public static void findFirstTest(List<String> list){
System.out.println(list.stream().parallel().findFirst().get());
}
public static void main(String[] args) {
List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
findFirstTest(list);
}
}
执行结果为：
123
4.12 findAny
该方法无参数，主要用于获取流中的任一元素。
public class StreamTest {
public static void findAnyTest(List<String> list){
System.out.println(list.stream().parallel().findAny().get());
}
public static void main(String[] args) {
List<String> list = Arrays.asList("123","456","789","1101","212121121","asdaa","3e3e3e","2321eew");
findAnyTest(list);
}
}
执行结果为：
asdaa
五、总结
流式操作代码描述性强，易理解，而且功能强大，可以简化很多集合操作。在我们需要对集合数据进行处理的时候，不妨试试使用流式操作来实现。
参考：
来源：https://www.jianshu.com/u/c52a29db48b6
Java 面试宝典是大明哥全力打造的 Java 精品面试题，它是一份靠谱、强大、详细、经典的 Java 后端面试宝典。它不仅仅只是一道道面试题，而是一套完整的 Java 知识体系，一套你 Java 知识点的扫盲贴。
它的内容包括：
- 大厂真题：Java 面试宝典里面的题目都是最近几年的高频的大厂面试真题。
- 原创内容：Java 面试宝典内容全部都是大明哥原创，内容全面且通俗易懂，回答部分可以直接作为面试回答内容。
- 持续更新：一次购买，永久有效。大明哥会持续更新 3+ 年，累计更新 1000+，宝典会不断迭代更新，保证最新、最全面。
- 覆盖全面：本宝典累计更新 1000+，从 Java 入门到 Java 架构的高频面试题，实现 360° 全覆盖。
- 不止面试：内容包含面试题解析、内容详解、知识扩展，它不仅仅只是一份面试题，更是一套完整的 Java 知识体系。
- 宝典详情：https://www.yuque.com/chenssy/sike-java/xvlo920axlp7sf4k
- 宝典总览：https://www.yuque.com/chenssy/sike-java/yogsehzntzgp4ly1
- 宝典进展：https://www.yuque.com/chenssy/sike-java/en9ned7loo47z5aw
目前 Java 面试宝典累计更新 400+ 道，总字数 42w+。大明哥还在持续更新中，下图是大明哥在 2024-12 月份的更新情况：
想了解详情的小伙伴，扫描下面二维码加大明哥微信【daming091】咨询
同时，大明哥也整理一套目前市面最常见的热点面试题。微信搜[大明哥聊 Java]或扫描下方二维码关注大明哥的原创公众号[大明哥聊 Java] ，回复【面试题】 即可免费领取。
