Java中如何用Stream处理集合数据-Java-PHP中文网

Java中如何用Stream处理集合数据

冰火之心

发布： 2025-06-23 23:08:01

原创

1042人浏览过

java stream处理集合数据的方式更简洁且函数式，关键在于理解中间操作和终端操作。1. 创建stream可通过集合的stream()或parallelstream()方法、stream.of()方法或arrays.stream()方法；2. 常用中间操作包括filter过滤元素、map转换元素类型、flatmap处理嵌套集合、sorted排序、peek调试、distinct去重、limit截取、skip跳过元素；3. 常用终端操作有foreach遍历、toarray转数组、reduce累积计算、collect收集到集合、min找最小值、max找最大值、count统计数量、anymatch判断存在满足条件元素、allmatch判断所有元素满足条件、nonematch判断所有元素不满足条件、findfirst找第一个元素、findany找任意元素；4. 使用并行流时需注意数据量大小、线程安全问题及处理顺序；5. stream api相比传统循环更简洁易并行，但调试困难且性能可能不如循环；6. 处理stream异常可用try-catch封装或自定义函数式接口捕获异常并处理。

Java中如何用Stream处理集合数据

Java Stream处理集合数据，简单来说，就是把集合当成流水线，可以对流水线上的数据进行各种加工。这种方式更简洁，也更函数式。

使用Stream API处理集合数据，关键在于理解Stream的操作类型：中间操作和终端操作。中间操作返回一个新的Stream，可以链式调用，而终端操作则会触发Stream的实际计算，并产生结果。

如何创建Stream

创建Stream的方式有很多种，最常见的是从集合创建。比如：

立即学习“Java免费学习笔记（深入）”；

List<String> list = Arrays.asList("apple", "banana", "orange");
Stream<String> stream = list.stream(); // 创建顺序流
Stream<String> parallelStream = list.parallelStream(); // 创建并行流

登录后复制

还可以直接使用Stream.of()方法：

Stream<String> stream = Stream.of("apple", "banana", "orange");

登录后复制

甚至可以从数组创建：

String[] array = {"apple", "banana", "orange"};
Stream<String> stream = Arrays.stream(array);

登录后复制

Stream的常用中间操作有哪些？

中间操作是Stream处理的核心，它们可以对Stream中的元素进行转换、过滤、排序等操作。

filter(Predicate<T> predicate): 过滤元素，只保留满足条件的元素。

List<String> list = Arrays.asList("apple", "banana", "orange", "grape");
list.stream()
    .filter(s -> s.startsWith("a"))
    .forEach(System.out::println); // 输出 "apple"

登录后复制

map(Function<T, R> mapper): 将元素转换为另一种类型。

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

登录后复制

flatMap(Function<T, Stream<R>> mapper): 将元素转换为Stream，并将所有Stream合并为一个Stream。这个操作在处理嵌套集合时非常有用。

List<List<String>> nestedList = Arrays.asList(
    Arrays.asList("apple", "banana"),
    Arrays.asList("orange", "grape")
);
nestedList.stream()
    .flatMap(Collection::stream)
    .forEach(System.out::println); // 输出 "apple", "banana", "orange", "grape"

登录后复制

sorted(): 对元素进行排序。可以传入Comparator自定义排序规则。

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

登录后复制

peek(Consumer<T> action): 对每个元素执行操作，但不会改变Stream。常用于调试。

List<String> list = Arrays.asList("apple", "banana", "orange");
list.stream()
    .peek(System.out::println) // 输出每个元素
    .map(String::toUpperCase)
    .forEach(System.out::println); // 输出大写版本

登录后复制

distinct(): 去除重复元素。

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

登录后复制

limit(long maxSize): 截取Stream，只保留前maxSize个元素。

List<String> list = Arrays.asList("apple", "banana", "orange", "grape");
list.stream()
    .limit(2)
    .forEach(System.out::println); // 输出 "apple", "banana"

登录后复制

skip(long n): 跳过前n个元素。

List<String> list = Arrays.asList("apple", "banana", "orange", "grape");
list.stream()
    .skip(2)
    .forEach(System.out::println); // 输出 "orange", "grape"

登录后复制

Stream的常用终端操作有哪些？

终端操作会触发Stream的计算，并产生最终结果。

forEach(Consumer<T> action): 对每个元素执行操作。

钉钉 AI 助理
钉钉AI助理汇集了钉钉AI产品能力，帮助企业迈入智能新时代。

21

查看详情
```
List<String> list = Arrays.asList("apple", "banana", "orange");
list.stream()
    .forEach(System.out::println);
```
登录后复制

toArray(): 将Stream转换为数组。

List<String> list = Arrays.asList("apple", "banana", "orange");
String[] array = list.stream().toArray(String[]::new);

登录后复制

reduce(T identity, BinaryOperator<T> accumulator): 将Stream中的元素累积起来。

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

登录后复制

collect(Collector<T, A, R> collector): 将Stream中的元素收集到集合中。这是最常用的终端操作之一。

List<String> list = Arrays.asList("apple", "banana", "orange");
List<String> upperCaseList = list.stream()
    .map(String::toUpperCase)
    .collect(Collectors.toList()); // 收集到List
Set<String> upperCaseSet = list.stream()
    .map(String::toUpperCase)
    .collect(Collectors.toSet()); // 收集到Set

登录后复制

min(Comparator<T> comparator): 找到Stream中的最小元素。

List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 9);
Optional<Integer> min = numbers.stream().min(Integer::compareTo); // min = Optional[1]

登录后复制

max(Comparator<T> comparator): 找到Stream中的最大元素。

List<Integer> numbers = Arrays.asList(5, 2, 8, 1, 9);
Optional<Integer> max = numbers.stream().max(Integer::compareTo); // max = Optional[9]

登录后复制

count(): 统计Stream中的元素个数。

List<String> list = Arrays.asList("apple", "banana", "orange");
long count = list.stream().count(); // count = 3

登录后复制

anyMatch(Predicate<T> predicate): 判断Stream中是否存在至少一个元素满足条件。

List<String> list = Arrays.asList("apple", "banana", "orange");
boolean anyMatch = list.stream().anyMatch(s -> s.startsWith("a")); // anyMatch = true

登录后复制

allMatch(Predicate<T> predicate): 判断Stream中是否所有元素都满足条件。

List<String> list = Arrays.asList("apple", "banana", "orange");
boolean allMatch = list.stream().allMatch(s -> s.length() > 3); // allMatch = true

登录后复制

noneMatch(Predicate<T> predicate): 判断Stream中是否所有元素都不满足条件。

List<String> list = Arrays.asList("apple", "banana", "orange");
boolean noneMatch = list.stream().noneMatch(s -> s.startsWith("z")); // noneMatch = true

登录后复制

findFirst(): 找到Stream中的第一个元素。

List<String> list = Arrays.asList("apple", "banana", "orange");
Optional<String> first = list.stream().findFirst(); // first = Optional[apple]

登录后复制

findAny(): 找到Stream中的任意一个元素。在并行流中，效率可能更高。

List<String> list = Arrays.asList("apple", "banana", "orange");
Optional<String> any = list.stream().findAny(); // any = Optional[apple] (也可能是其他元素，取决于并行执行情况)

登录后复制

并行流的注意事项

并行流可以利用多核CPU的优势，提高处理速度。但需要注意以下几点：

数据量要足够大：并行流的开销比顺序流大，只有在数据量足够大时才能体现出优势。
线程安全问题：如果Stream的操作涉及到共享变量，需要考虑线程安全问题。
顺序问题：并行流不保证元素的处理顺序。如果需要保证顺序，可以使用forEachOrdered()代替forEach()。

Stream与传统循环的对比

Stream API相比传统的循环，代码更简洁，可读性更高。而且，Stream API可以更容易地进行并行处理。但是，Stream API也有一些缺点，比如调试比较困难，而且在某些情况下性能可能不如传统循环。选择哪种方式取决于具体的场景。

如何处理Stream中的异常

在Stream操作中，如果某个操作抛出异常，会导致整个Stream中断。为了避免这种情况，可以使用try-catch块来捕获异常，并进行处理。一种常见的做法是将可能抛出异常的操作封装到一个函数中，然后在map操作中使用该函数。

List<String> list = Arrays.asList("1", "2", "a", "4");
list.stream()
    .map(s -> {
        try {
            return Integer.parseInt(s);
        } catch (NumberFormatException e) {
            return null; // 或者返回一个默认值
        }
    })
    .filter(Objects::nonNull) // 过滤掉null值
    .forEach(System.out::println); // 输出 1, 2, 4

登录后复制

或者，可以自定义一个函数式接口来处理异常：

@FunctionalInterface
interface ThrowingFunction<T, R, E extends Exception> {
    R apply(T t) throws E;
}

static <T, R, E extends Exception> Function<T, R> handling(ThrowingFunction<T, R, E> throwingFunction, Class<E> exceptionClass) {
    return arg -> {
        try {
            return throwingFunction.apply(arg);
        } catch (Exception e) {
            if (exceptionClass.isInstance(e)) {
                System.err.println("Exception caught: " + e.getMessage());
                return null; // 或者返回一个默认值
            } else {
                throw new RuntimeException(e);
            }
        }
    };
}

// 使用示例
List<String> list = Arrays.asList("1", "2", "a", "4");
list.stream()
    .map(handling(Integer::parseInt, NumberFormatException.class))
    .filter(Objects::nonNull)
    .forEach(System.out::println);

登录后复制

这种方式更加灵活，可以根据不同的异常类型进行不同的处理。

以上就是Java中如何用Stream处理集合数据的详细内容，更多请关注php中文网其它相关文章！