Java8 Stream流常用方法是什么

Java8 Stream流常用方法是什么

Java 8引入了Stream API，它提供了一种高效且易于使用的方式来处理集合数据。Stream API允许我们以声明式的方式处理数据，并且可以轻松地并行化操作。本文将详细介绍Java 8中Stream流的常用方法，并通过示例代码展示如何使用这些方法。

1. Stream简介

Stream是Java 8中引入的一个新抽象，它允许我们以声明式的方式处理数据集合。Stream可以看作是对集合数据的高级迭代器，它提供了丰富的操作方法来处理数据，如过滤、映射、排序、聚合等。

Stream的主要特点包括：

• 惰性求值：Stream操作是惰性的，只有在终端操作执行时才会真正开始处理数据。
• 不可变性：Stream操作不会修改原始数据源，而是生成一个新的Stream。
• 并行处理：Stream可以轻松地并行化操作，以提高处理效率。

2. 创建Stream

在开始使用Stream之前，我们需要先创建一个Stream。Java 8提供了多种创建Stream的方式：

2.1 从集合创建Stream

我们可以通过集合的stream()方法或parallelStream()方法来创建一个Stream：

List<String> list = Arrays.asList("a", "b", "c"); Stream<String> stream = list.stream(); Stream<String> parallelStream = list.parallelStream(); 

2.2 从数组创建Stream

我们可以通过Arrays.stream()方法从数组创建一个Stream：

String[] array = {"a", "b", "c"}; Stream<String> stream = Arrays.stream(array); 

2.3 使用Stream.of()创建Stream

我们可以使用Stream.of()方法创建一个包含指定元素的Stream：

Stream<String> stream = Stream.of("a", "b", "c"); 

2.4 使用Stream.generate()创建无限Stream

我们可以使用Stream.generate()方法创建一个无限Stream，它通过提供的Supplier生成元素：

Stream<String> stream = Stream.generate(() -> "element").limit(10); 

2.5 使用Stream.iterate()创建无限Stream

我们可以使用Stream.iterate()方法创建一个无限Stream，它通过迭代生成元素：

Stream<Integer> stream = Stream.iterate(0, n -> n + 2).limit(10); 

3. Stream常用方法

Stream提供了丰富的操作方法，这些方法可以分为两类：中间操作和终端操作。

• 中间操作：返回一个新的Stream，允许我们链式调用多个操作。
• 终端操作：触发Stream的处理并返回结果或产生副作用。

3.1 中间操作

3.1.1 filter()

filter()方法用于过滤Stream中的元素，只保留满足条件的元素：

List<String> list = Arrays.asList("a", "b", "c", "d"); List<String> result = list.stream() .filter(s -> s.startsWith("a")) .collect(Collectors.toList()); // result: ["a"] 

3.1.2 map()

map()方法用于将Stream中的每个元素映射为另一个元素：

List<String> list = Arrays.asList("a", "b", "c"); List<String> result = list.stream() .map(String::toUpperCase) .collect(Collectors.toList()); // result: ["A", "B", "C"] 

3.1.3 flatMap()

flatMap()方法用于将Stream中的每个元素映射为一个Stream，然后将这些Stream合并为一个Stream：

List<List<String>> list = Arrays.asList( Arrays.asList("a", "b"), Arrays.asList("c", "d") ); List<String> result = list.stream() .flatMap(Collection::stream) .collect(Collectors.toList()); // result: ["a", "b", "c", "d"] 

3.1.4 distinct()

distinct()方法用于去除Stream中的重复元素：

List<String> list = Arrays.asList("a", "b", "a", "c"); List<String> result = list.stream() .distinct() .collect(Collectors.toList()); // result: ["a", "b", "c"] 

3.1.5 sorted()

sorted()方法用于对Stream中的元素进行排序：

List<String> list = Arrays.asList("c", "a", "b"); List<String> result = list.stream() .sorted() .collect(Collectors.toList()); // result: ["a", "b", "c"] 

我们还可以传入一个Comparator来自定义排序规则：

List<String> list = Arrays.asList("c", "a", "b"); List<String> result = list.stream() .sorted((s1, s2) -> s2.compareTo(s1)) .collect(Collectors.toList()); // result: ["c", "b", "a"] 

3.1.6 peek()

peek()方法用于对Stream中的每个元素执行操作，通常用于调试：

List<String> list = Arrays.asList("a", "b", "c"); List<String> result = list.stream() .peek(System.out::println) .collect(Collectors.toList()); // 输出: // a // b // c 

3.1.7 limit()

limit()方法用于截取Stream中的前N个元素：

List<String> list = Arrays.asList("a", "b", "c", "d"); List<String> result = list.stream() .limit(2) .collect(Collectors.toList()); // result: ["a", "b"] 

3.1.8 skip()

skip()方法用于跳过Stream中的前N个元素：

List<String> list = Arrays.asList("a", "b", "c", "d"); List<String> result = list.stream() .skip(2) .collect(Collectors.toList()); // result: ["c", "d"] 

3.2 终端操作

3.2.1 forEach()

forEach()方法用于对Stream中的每个元素执行操作：

List<String> list = Arrays.asList("a", "b", "c"); list.stream().forEach(System.out::println); // 输出: // a // b // c 

3.2.2 collect()

collect()方法用于将Stream中的元素收集到一个集合中：

List<String> list = Arrays.asList("a", "b", "c"); List<String> result = list.stream() .collect(Collectors.toList()); // result: ["a", "b", "c"] 

我们还可以使用Collectors类提供的其他方法来收集元素，如toSet()、toMap()等：

Set<String> set = list.stream() .collect(Collectors.toSet()); Map<String, Integer> map = list.stream() .collect(Collectors.toMap(Function.identity(), String::length)); 

3.2.3 reduce()

reduce()方法用于将Stream中的元素通过指定的操作进行归约：

List<Integer> list = Arrays.asList(1, 2, 3, 4); Optional<Integer> result = list.stream() .reduce((a, b) -> a + b); // result: Optional[10] 

我们还可以提供一个初始值：

int result = list.stream() .reduce(0, (a, b) -> a + b); // result: 10 

3.2.4 count()

count()方法用于统计Stream中的元素数量：

List<String> list = Arrays.asList("a", "b", "c"); long count = list.stream().count(); // count: 3 

3.2.5 anyMatch()

anyMatch()方法用于判断Stream中是否有任意一个元素满足指定条件：

List<String> list = Arrays.asList("a", "b", "c"); boolean result = list.stream() .anyMatch(s -> s.startsWith("a")); // result: true 

3.2.6 allMatch()

allMatch()方法用于判断Stream中的所有元素是否都满足指定条件：

List<String> list = Arrays.asList("a", "b", "c"); boolean result = list.stream() .allMatch(s -> s.startsWith("a")); // result: false 

3.2.7 noneMatch()

noneMatch()方法用于判断Stream中是否没有任何元素满足指定条件：

List<String> list = Arrays.asList("a", "b", "c"); boolean result = list.stream() .noneMatch(s -> s.startsWith("d")); // result: true 

3.2.8 findFirst()

findFirst()方法用于返回Stream中的第一个元素：

List<String> list = Arrays.asList("a", "b", "c"); Optional<String> result = list.stream().findFirst(); // result: Optional["a"] 

3.2.9 findAny()

findAny()方法用于返回Stream中的任意一个元素：

List<String> list = Arrays.asList("a", "b", "c"); Optional<String> result = list.stream().findAny(); // result: Optional["a"] 或 Optional["b"] 或 Optional["c"] 

3.2.10 min()

min()方法用于返回Stream中的最小元素：

List<Integer> list = Arrays.asList(1, 2, 3, 4); Optional<Integer> result = list.stream() .min(Integer::compareTo); // result: Optional[1] 

3.2.11 max()

max()方法用于返回Stream中的最大元素：

List<Integer> list = Arrays.asList(1, 2, 3, 4); Optional<Integer> result = list.stream() .max(Integer::compareTo); // result: Optional[4] 

3.2.12 toArray()

toArray()方法用于将Stream中的元素转换为数组：

List<String> list = Arrays.asList("a", "b", "c"); String[] array = list.stream().toArray(String[]::new); // array: ["a", "b", "c"] 

4. 并行Stream

Stream API支持并行处理，我们可以通过parallelStream()方法或parallel()方法将Stream转换为并行Stream：

List<String> list = Arrays.asList("a", "b", "c"); list.parallelStream().forEach(System.out::println); 

并行Stream会自动将任务分配到多个线程上执行，从而提高处理效率。需要注意的是，并行处理并不总是比串行处理更快，特别是在数据量较小或任务本身较为简单的情况下。

5. 总结

Java 8的Stream API为我们提供了一种高效且易于使用的方式来处理集合数据。通过Stream，我们可以以声明式的方式对数据进行过滤、映射、排序、聚合等操作，并且可以轻松地并行化处理。本文详细介绍了Stream的常用方法，并通过示例代码展示了如何使用这些方法。

Stream API的强大之处在于它的灵活性和可组合性，我们可以通过链式调用多个操作来处理数据，而无需编写复杂的循环和条件判断。此外，Stream的惰性求值特性也使得它在处理大数据集时更加高效。

希望本文能帮助你更好地理解和使用Java 8中的Stream API，并在实际开发中发挥其强大的功能。