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处理集合数据，简单来说，就是把集合当成流水线，可以对流水线上的数据进行各种加工。这种方式更简洁，也更函数式。
使用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)</t>: 过滤元素，只保留满足条件的元素。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)</t>: 将元素转换为另一种类型。List<String> list = Arrays.asList("apple", "banana", "orange"); list.stream() .map(String::toUpperCase) .forEach(System.out::println); // 输出 "APPLE", "BANANA", "ORANGE" -
flatMap(Function<t stream>> mapper)</t>: 将元素转换为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)</t>: 对每个元素执行操作，但不会改变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)</t>: 对每个元素执行操作。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)</t>: 将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)</t>: 将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)</t>: 找到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)</t>: 找到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)</t>: 判断Stream中是否存在至少一个元素满足条件。List<String> list = Arrays.asList("apple", "banana", "orange"); boolean anyMatch = list.stream().anyMatch(s -> s.startsWith("a")); // anyMatch = true -
allMatch(Predicate<t> predicate)</t>: 判断Stream中是否所有元素都满足条件。List<String> list = Arrays.asList("apple", "banana", "orange"); boolean allMatch = list.stream().allMatch(s -> s.length() > 3); // allMatch = true -
noneMatch(Predicate<t> predicate)</t>: 判断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);这种方式更加灵活，可以根据不同的异常类型进行不同的处理。
