Java Stream流的常见生成和操作方法总结

生成Stream流的常见方式

1. 通过Collection接口生成

可以通过Collection接口提供的stream()和parallelStream()方法生成一个Stream或ParallelStream流：

List<String> list = Arrays.asList("apple", "banana", "orange");
Stream<String> stream = list.stream(); // 生成Stream流
Stream<String> parallelStream = list.parallelStream(); // 生成ParallelStream流

2. 通过数组生成

可以通过数组的静态方法Arrays.stream()生成一个Stream流:

int[] arr = {1, 2, 3, 4, 5};
IntStream stream = Arrays.stream(arr); // 生成IntStream流

3. 通过指定数据方式生成

可以通过静态方法Stream.of()和Arrays.stream()生成一个Stream流:

Stream<Integer> stream1 = Stream.of(1, 2, 3, 4, 5); // 生成Stream流
Stream<Integer> stream2 = Arrays.stream(new Integer[]{1, 2, 3, 4, 5}); // 生成Stream流

4. 通过生成函数方式生成

可以通过静态方法Stream.generate()和Stream.iterate()生成一个Stream流:

Stream<Integer> stream1 = Stream.generate(() -> new Random().nextInt(100)); // 生成无限个随机数的Stream流
Stream<Integer> stream2 = Stream.iterate(0, n -> n + 2).limit(5); // 生成0, 2, 4, 6, 8的Stream流

Stream流的常用操作

1. filter()方法

filter()方法使用一个Lambda表达式作为参数，筛选出符合条件的元素：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> stream = list.stream();
Stream<Integer> result = stream.filter(i -> i % 2 == 0);
result.forEach(System.out::println); // 输出：2, 4

2. map()方法

map()方法使用一个Lambda表达式作为参数，将元素映射为一个新的元素：

List<String> list = Arrays.asList("apple", "banana", "orange");
Stream<String> stream = list.stream();
Stream<String> result = stream.map(s -> s.toUpperCase());
result.forEach(System.out::println); // 输出：APPLE, BANANA, ORANGE

3. distinct()方法

distinct()方法返回一个没有重复元素的Stream流：

List<String> list = Arrays.asList("apple", "banana", "orange", "apple");
Stream<String> stream = list.stream();
Stream<String> result = stream.distinct();
result.forEach(System.out::println); // 输出：apple, banana, orange

4. sorted()方法

sorted()方法将流中的元素按照自然顺序或者指定的Comparator排序：

List<Integer> list = Arrays.asList(3, 5, 1, 4, 2);
Stream<Integer> stream = list.stream();
Stream<Integer> result = stream.sorted();
result.forEach(System.out::println); // 输出：1, 2, 3, 4, 5

5. limit()方法和skip()方法

limit()方法返回一个由原Stream包含的前n个元素组成的新Stream；skip()方法返回一个并不包含原Stream的前n个元素的新Stream：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> stream = list.stream();
Stream<Integer> result1 = stream.limit(3);
result1.forEach(System.out::println); // 输出：1, 2, 3

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> stream = list.stream();
Stream<Integer> result2 = stream.skip(2);
result2.forEach(System.out::println); // 输出：3, 4, 5

6. reduce()方法

reduce()方法可以将流中的元素依次归约，返回结果：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
Stream<Integer> stream = list.stream();
Optional<Integer> result = stream.reduce((a, b) -> a + b);
System.out.println(result.get()); // 输出15

示例说明

示例1：使用Stream流的常见生成和操作

下面程序使用生成函数的方式生成Stream流, 对其中的偶数进行过滤(filter)和排序(sorted)操作, 最后输出结果:

import java.util.Random;
import java.util.stream.Stream;

public class StreamDemo {

    public static void main(String[] args) {
        Stream<Integer> stream = Stream.generate(() -> new Random().nextInt(100)).limit(10);
        Stream<Integer> result = stream.filter(i -> i % 2 == 0).sorted();
        result.forEach(System.out::println); // 输出：6, 16, 18, 26, 30, 56, 68, 84, 88, 92
    }
}

示例2：从文件中读取单词进行统计

下面示例读取指定文件(book.txt)中的单词, 对其进行统计后输出结果:

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Arrays;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class StreamDemo {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("D:/book.txt"));
        Stream<String> words = br.lines().flatMap(line -> Arrays.stream(line.split("\\W+"))).filter(word -> word.length() > 0);
        Map<String, Long> freq = words.collect(Collectors.groupingBy(String::toLowerCase, Collectors.counting()));
        System.out.println(freq);
    }
}

程序将单词进行toLowerCase()操作, 统计其出现的数量并输出结果.