平常经常在用Stream，但是很少全面的整理一下用法。今天是基于Java8版本对Stream的用法进行了整理。

Stream是Java8提供的一个接口，主要定义了一种流式处理数据的方式。它扩展自接口BaseStream。所以讲Stream的用法，先要简单说一下BaseStream的用法。

BaseStream

BaseStream 接口提供了如下能力：

iterator 返回一个迭代器，可以用于遍历流中的元素。

1
2
3
4
5


List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Iterator<Integer> iterator = numbers.stream().iterator();
while(iterator.hasNext()) {
    System.out.println(iterator.next()); 
}

输出结果是

spliterator 返回一个分割器Spliterator，可以用于将流分成若干个部分进行并行处理。这个方法对于使用者来说基本没什么用。

1
2


List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Spliterator<Integer> spliterator = numbers.stream().spliterator();

isParallel 判断流是否是并行流。

1
2
3


List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
boolean isParallel = numbers.stream().parallel().isParallel();
System.out.println(isParallel); // true

sequential 将并行流转换为顺序流。

1
2


List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> sequentialStream = numbers.stream().parallel().sequential();

parallel 将顺序流转换为并行流。

1
2


List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> parallelStream = numbers.stream().parallel();

unordered 返回一个无序流。

1
2


List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> unorderedStream = numbers.stream().unordered();

注意，它的含义并不是把流变成无序的，只是将流的有序约束关闭了。也就是说，现在输出这个stream的内容，仍然是1,2,3,4,5

onclose 在关闭流之前执行一个操作。

1
2
3


List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> stream = numbers.stream().onClose(() -> System.out.println("Stream closed."));
stream.close();//Stream closed.

close 关闭流，释放流占用的资源。

1
2
3


List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> stream = numbers.stream();
stream.close();

Stream

我们再看一下Stream的用法：

allMatch 判断所有元素是否都满足给定的条件。示例：

1
2
3
4
5
6
7


        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

            boolean allEven = numbers.stream().allMatch(n -> n % 2 == 0);
            System.out.println("All even? " + allEven);

            boolean allGreaterThanZero = numbers.stream().allMatch(n -> n > 0);
            System.out.println("All greater than zero? " + allGreaterThanZero);

结果：

1
2


All even? false
All greater than zero? true

anyMatch 判断是否存在至少一个元素满足给定的条件。示例：

1
2
3
4
5
6
7


            List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

            boolean anyEven = numbers.stream().anyMatch(n -> n % 2 == 0);
            System.out.println("Any even? " + anyEven);

            boolean anyNegative = numbers.stream().anyMatch(n -> n < 0);
            System.out.println("Any negative? " + anyNegative);

结果：

1
2


Any even? true
Any negative? false

builder 创建一个Stream.Builder，可以用于构建一个Stream。示例：

1
2
3
4
5
6
7
8


            Stream.Builder<Integer> builder = Stream.builder();

            builder.add(1);
            builder.add(2);
            builder.add(3);

            Stream<Integer> stream = builder.build();
            stream.forEach(System.out::println);

结果：

collect 将Stream中的元素收集到一个结果容器中。Collector是一个接口，可以自定义收集器。示例：

1
2
3
4
5
6
7


            List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

            List<Integer> evenNumbers = numbers.stream()
                .filter(n -> n % 2 == 0)
                .collect(Collectors.toList());

            System.out.println("Even numbers: " + evenNumbers);

结果：

1

Even numbers: [2, 4, 6, 8, 10]

concat 合并两个Stream，返回一个新的Stream。示例：

1
2
3
4
5
6
7
8
9


            List<Integer> numbers1 = Arrays.asList(1, 2, 3);
            List<Integer> numbers2 = Arrays.asList(4, 5, 6);

            Stream<Integer> stream1 = numbers1.stream();
            Stream<Integer> stream2 = numbers2.stream();

            Stream<Integer> combinedStream = Stream.concat(stream1, stream2);

            combinedStream.forEach(System.out::println);

结果：

count 返回Stream中元素的个数。示例：

1
2
3
4


            List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

            long count = numbers.stream().count();
            System.out.println("Count: " + count);

结果：

1

Count: 10

distinct 返回一个去重后的Stream。示例：

1
2
3
4


            List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 3, 3, 4, 4, 4, 4);

            List<Integer> distinctNumbers = numbers.stream().distinct().collect(Collectors.toList());
            System.out.println("Distinct numbers: " + distinctNumbers);

结果：

1

Distinct numbers: [1, 2, 3, 4]

empty 创建一个空的Stream。示例：

1
2


            Stream<String> emptyStream = Stream.empty();
            emptyStream.forEach(System.out::println);

结果：

filter 对Stream中的元素进行筛选，返回符合条件的元素组成的新的Stream。示例：

1
2
3
4


            List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

            List<Integer> evenNumbers = numbers.stream().filter(n -> n % 2 == 0).collect(Collectors.toList());
            System.out.println("Even numbers: " + evenNumbers);

结果：

1

Even numbers: [2, 4, 6, 8, 10]

findAny 返回任意一个元素。示例：

1
2
3
4


            List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

            Optional<Integer> anyEvenNumber = numbers.stream().filter(n -> n % 2 == 0).findAny();
            System.out.println("Any even number: " + anyEvenNumber.get());

结果：

1

Any even number: 2

findFirst 返回第一个元素。示例：

1
2
3
4


            List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

            Optional<Integer> firstEvenNumber = numbers.stream().filter(n -> n % 2 == 0).findFirst();
            System.out.println("First even number: " + firstEvenNumber.get());

结果：

1

First even number: 2

flatMap 将Stream中的元素映射为一个Stream，将所有Stream中的元素合并成一个Stream。示例：

1
2
3
4
5
6
7
8
9


            List<List<Integer>> numbers = Arrays.asList(
                Arrays.asList(1, 2, 3),
                Arrays.asList(4, 5, 6),
                Arrays.asList(7, 8, 9)
            );

            Stream<Integer> flatStream = numbers.stream().flatMap(List::stream);

            flatStream.forEach(System.out::println);

结果：

flatMapToDouble 将Stream中的元素映射为一个DoubleStream，将所有DoubleStream中的元素合并成一个DoubleStream。
flatMapToInt 将Stream中的元素映射为一个IntStream，将所有IntStream中的元素合并成一个IntStream。
flatMapToLong 将Stream中的元素映射为一个LongStream，将所有LongStream中的元素合并成一个LongStream。
forEach 对Stream中的每个元素执行给定的操作。示例：

1
2
3


            List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

            numbers.stream().forEach(System.out::println);

结果：

forEachOrdered 对Stream中的每个元素按顺序执行给定的操作。示例：

1
2
3
4
5
6
7


            List<Integer> numbers = Arrays.asList(2, 1, 3, 5, 4);

            System.out.println("Output in original order:");
            numbers.stream().forEachOrdered(System.out::println);

            System.out.println("Output in sorted order:");
            numbers.stream().sorted().forEachOrdered(System.out::println);

结果：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


Output in original order:
2
1
3
5
4
Output in sorted order:
1
2
3
4
5

generate 生成一个无限长度的Stream，其中每个元素由Supplier提供。示例：

1
2


            Stream<String> stream = Stream.generate(() -> "hello").limit(3);
            stream.forEach(System.out::println);

结果：

1
2
3


hello
hello
hello

iterate 生成一个无限长度的Stream，其中第一个元素由seed提供，后续元素由指定的函数f生成。示例：

1
2


            Stream<Integer> stream = Stream.iterate(1, n -> n + 1).limit(10);
            stream.forEach(System.out::println);

结果：

limit 截取Stream中的前maxSize个元素，返回一个新的Stream。示例：

1
2
3
4


            List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

            List<Integer> firstThree = numbers.stream().limit(3).collect(Collectors.toList());
            System.out.println("First three numbers: " + firstThree);

结果：

1

First three numbers: [1, 2, 3]

map 对Stream中的元素进行映射，将每个元素转换为另一个元素。示例：

1
2
3
4


            List<String> words = Arrays.asList("hello", "world", "java");

            List<Integer> wordLengths = words.stream().map(String::length).collect(Collectors.toList());
            System.out.println("Word lengths: " + wordLengths);

结果：

1

Word lengths: [5, 5, 4]

mapToDouble 将Stream中的元素映射为double类型。
mapToInt 将Stream中的元素映射为int类型。
mapToLong 将Stream中的元素映射为long类型。
max 返回Stream中的最大元素。示例：

1
2
3
4


            List<Integer> numbers = Arrays.asList(2, 4, 6, 8, 10);

            Optional<Integer> maxNumber = numbers.stream().max(Integer::compare);
            System.out.println("Max number: " + maxNumber.get());

结果：

1

Max number: 10

min 返回Stream中的最小元素。示例：

1
2
3
4


            List<Integer> numbers = Arrays.asList(2, 4, 6, 8, 10);

            Optional<Integer> minNumber = numbers.stream().min(Integer::compare);
            System.out.println("Min number: " + minNumber.get());

结果：

1

Min number: 2

noneMatch 判断所有元素是否都不满足给定的条件。示例：

1
2
3
4
5
6
7


            List<Integer> numbers = Arrays.asList(1, 3, 5, 7, 9);

            boolean noneEven = numbers.stream().noneMatch(n -> n % 2 == 0);
            System.out.println("None even? " + noneEven);

            boolean noneNegative = numbers.stream().noneMatch(n -> n < 0);
            System.out.println("None negative? " + noneNegative);

结果：

1
2


None even? true
None negative? true

of 创建一个包含指定元素的Stream。示例：

1
2


            Stream<String> stream = Stream.of("apple", "banana", "cherry");
            stream.forEach(System.out::println);

结果：

1
2
3


apple
banana
cherry

peek 对Stream中的每个元素执行给定的操作，返回一个新的Stream。示例：

1
2
3
4
5
6
7
8
9


            List<Integer> numbers = Arrays.asList(2, 4, 6, 8, 10);

            List<Integer> doubledNumbers = numbers.stream()
                .peek(n -> System.out.println("Before doubling: " + n))
                .map(n -> n * 2)
                .peek(n -> System.out.println("After doubling: " + n))
                .collect(Collectors.toList());

            System.out.println("Doubled numbers: " + doubledNumbers);

结果：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


Before doubling: 2
After doubling: 4
Before doubling: 4
After doubling: 8
Before doubling: 6
After doubling: 12
Before doubling: 8
After doubling: 16
Before doubling: 10
After doubling: 20
Doubled numbers: [4, 8, 12, 16, 20]

reduce 通过指定的累加器函数对Stream中的元素进行归约。示例：

1
2
3
4
5
6
7


            List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

            int sum = numbers.stream().reduce(0, (a, b) -> a + b);
            System.out.println("Sum: " + sum);

            int product = numbers.stream().reduce(1, (a, b) -> a * b);
            System.out.println("Product: " + product);

结果：

1
2


Sum: 15
Product: 120

skip 跳过Stream中的前n个元素，返回一个新的Stream。示例：

1
2
3
4


            List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

            List<Integer> skippedNumbers = numbers.stream().skip(2).collect(Collectors.toList());
            System.out.println("Skipped numbers: " + skippedNumbers);

结果：

1

Skipped numbers: [3, 4, 5]

sorted 对Stream中的元素进行排序，返回一个新的Stream。示例：

1
2
3
4


            List<Integer> numbers = Arrays.asList(2, 1, 3, 5, 4);

            List<Integer> sortedNumbers = numbers.stream().sorted().collect(Collectors.toList());
            System.out.println("Sorted numbers: " + sortedNumbers);

结果：

1

Sorted numbers: [1, 2, 3, 4, 5]

toArray 将Stream中的元素转换为一个数组。示例：

1
2
3
4


            List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

            Integer[] array = numbers.stream().toArray(Integer[]::new);
            System.out.println("Array: " + Arrays.toString(array));

结果：

1

Array: [1, 2, 3, 4, 5]

Java8Stream用法整理

文章目录

BaseStream

Stream