JAVA中stream流的基础处理方法有哪些

发布时间：2023-03-24 16:31:32 作者：iii
来源：亿速云阅读：187

JAVA中Stream流的基础处理方法有哪些

引言

在Java 8中，引入了Stream API，它提供了一种高效且易于使用的方式来处理集合数据。Stream API允许开发者以声明式的方式处理数据，使得代码更加简洁、易读。本文将详细介绍Java中Stream流的基础处理方法，包括流的创建、中间操作、终端操作以及一些常用的流操作示例。

1. Stream流的创建

在Java中，可以通过多种方式创建Stream流。以下是几种常见的创建方式：

1.1 从集合创建流

最常用的方式是从集合（如List、Set等）创建流。可以通过调用集合的stream()方法来获取一个流。

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

1.2 从数组创建流

可以通过Arrays.stream()方法从数组创建流。

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

1.3 使用Stream.of()创建流

Stream.of()方法可以接受任意数量的参数，并返回一个流。

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

1.4 使用Stream.generate()创建无限流

Stream.generate()方法可以生成一个无限流，通常与limit()方法一起使用来限制流的大小。

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

1.5 使用Stream.iterate()创建无限流

Stream.iterate()方法可以生成一个无限流，通常与limit()方法一起使用来限制流的大小。

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

2. 中间操作

中间操作是对流进行处理的操作，它们返回一个新的流，允许链式调用。中间操作是惰性的，只有在终端操作调用时才会执行。

2.1 filter()

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

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

2.2 map()

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

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

2.3 flatMap()

flatMap()方法用于将流中的每个元素映射为一个流，然后将所有流合并为一个流。

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"]

2.4 distinct()

distinct()方法用于去除流中的重复元素。

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

2.5 sorted()

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

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

2.6 peek()

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

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

2.7 limit()

limit()方法用于限制流的大小。

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

2.8 skip()

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

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

3. 终端操作

终端操作是流的最终操作，它们会触发流的处理并返回一个结果。终端操作执行后，流将不能再被使用。

3.1 forEach()

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

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

3.2 collect()

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

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

3.3 reduce()

reduce()方法用于将流中的元素归约为一个值。

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

3.4 count()

count()方法用于计算流中的元素数量。

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

3.5 anyMatch()

anyMatch()方法用于判断流中是否有任意一个元素满足条件。

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

3.6 allMatch()

allMatch()方法用于判断流中的所有元素是否都满足条件。

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

3.7 noneMatch()

noneMatch()方法用于判断流中是否没有任何元素满足条件。

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

3.8 findFirst()

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

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

3.9 findAny()

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

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

3.10 min() 和 max()

min()和max()方法用于返回流中的最小值和最大值。

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

4. 常用的流操作示例

4.1 过滤并收集

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

4.2 映射并收集

List<String> list = Arrays.asList("apple", "banana", "cherry");
List<Integer> result = list.stream()
                           .map(String::length)
                           .collect(Collectors.toList());
// result: [5, 6, 6]

4.3 去重并排序

List<String> list = Arrays.asList("banana", "apple", "cherry", "apple");
List<String> result = list.stream()
                          .distinct()
                          .sorted()
                          .collect(Collectors.toList());
// result: ["apple", "banana", "cherry"]

4.4 归约求和

List<Integer> list = Arrays.asList(1, 2, 3, 4);
int sum = list.stream()
              .reduce(0, Integer::sum);
// sum: 10

4.5 分组

List<String> list = Arrays.asList("apple", "banana", "cherry");
Map<Integer, List<String>> result = list.stream()
                                        .collect(Collectors.groupingBy(String::length));
// result: {5=["apple"], 6=["banana", "cherry"]}

4.6 分区

List<String> list = Arrays.asList("apple", "banana", "cherry");
Map<Boolean, List<String>> result = list.stream()
                                         .collect(Collectors.partitioningBy(s -> s.length() > 5));
// result: {false=["apple"], true=["banana", "cherry"]}

4.7 连接字符串

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

5. 并行流

Java中的Stream API还支持并行流处理，可以通过parallelStream()方法将流转换为并行流，从而利用多核处理器的优势。

List<String> list = Arrays.asList("a", "b", "c");
list.parallelStream().forEach(System.out::println);
// 输出顺序可能不同

6. 注意事项

流的不可重用性：一旦流被终端操作消费，就不能再被使用。如果需要再次处理数据，必须重新创建流。
流的惰性求值：中间操作是惰性的，只有在终端操作调用时才会执行。
并行流的线程安全：在使用并行流时，需要注意线程安全问题，尤其是在处理共享数据时。

7. 总结

Java中的Stream API提供了一种强大且灵活的方式来处理集合数据。通过使用Stream，开发者可以以声明式的方式编写代码，使得代码更加简洁、易读。本文详细介绍了Stream流的创建、中间操作、终端操作以及一些常用的流操作示例。希望本文能帮助读者更好地理解和使用Java中的Stream API。