Stream
Stream流操作分为3种类型：
创建Stream
Stream中间处理
终止Steam
1.开始管道
主要负责新建一个Stream流，或者基于现有的数组、List、Set、Map等集合类型对象创建出新的Stream流
| API | 功能说明 |
|---|---|
| stream() | 创建出一个新的stream串行流对象 |
| parallelStream() | 创建出一个可并行执行的stream流对象 |
| Stream.of() | 通过给定的一系列元素创建一个新的Stream串行流对象 |
1.stream
通过集合的 stream() 方法
List<String> list = Arrays.asList("apple", "banana", "cherry");
Stream<String> stream = list.stream();
2.Arrays.stream
通过数组的 Arrays.stream(Object[]) 方法
String[] array = {"apple", "banana", "cherry"};
Stream<String> stream = Arrays.stream(array);
3.Stream.of
使用 Stream.of(T… values) 静态方法
Stream<String> stream = Stream.of("apple", "banana", "cherry");
2.中间管道
负责对Stream进行处理操作，并返回一个新的Stream对象，中间管道操作可以进行叠加
| API | 功能说明 |
|---|---|
| filter() | 按照条件过滤符合要求的元素， 返回新的stream流 |
| map() | 将已有元素转换为另一个对象类型，一对一逻辑，返回新的stream流 |
| flatMap() | 将已有元素转换为另一个对象类型，一对多逻辑，即原来一个元素对象可能会转换为1个或者多个新类型的元素，返回新的stream流 |
| limit() | 仅保留集合前面指定个数的元素，返回新的stream流 |
| skip() | 跳过集合前面指定个数的元素，返回新的stream流 |
| concat() | 将两个流的数据合并起来为1个新的流，返回新的stream流 |
| distinct() | 对Stream中所有元素进行去重，返回新的stream流 |
| sorted() | 对stream中所有的元素按照指定规则进行排序，返回新的stream流 |
| peek() | 对stream流中的每个元素进行逐个遍历处理，返回处理后的stream流 |
1.filter
filter(Predicate<? super T> predicate): 过滤元素
示例： 过滤出列表中所有偶数
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
List<Integer> evenNumbers = numbers.stream()
.filter(n -> n % 2 == 0)
.collect(Collectors.toList());
System.out.println(evenNumbers); // 输出 [2, 4, 6]
2.map
map(Function<? super T, ? extends R> mapper): 转换每个元素到对应的结果
示例： 将每个字符串转换为大写
List<String> words = Arrays.asList("hello", "world");
List<String> upperCaseWords = words.stream()
.map(String::toUpperCase)
.collect(Collectors.toList());java
System.out.println(upperCaseWords); // 输出 [HELLO, WORLD]
3.flatMap
flatMap(Function<? super T, ? extends Stream<? extends R>> mapper): 将每个元素转换成另一个 Stream，然后将所有流连接成一个流
示例：将包含单词列表的列表转换为单词流
List<List<String>> listOfLists = Arrays.asList(
Arrays.asList("hello", "world"),
Arrays.asList("goodbye", "world")
);
List<String> words = listOfLists.stream()
.flatMap(List::stream)
.collect(Collectors.toList());
System.out.println(words); // 输出 [hello, world, goodbye, world]
4.sorted
sorted(): 对元素进行自然排序
示例：对整数列表进行自然排序
List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9);
List<Integer> sortedNumbers = numbers.stream()
.sorted()
.collect(Collectors.toList());
System.out.println(sortedNumbers); // 输出 [1, 1, 3, 4, 5, 9]
sorted(Comparator<? super T> comparator): 使用提供的比较器对元素进行排序
示例：使用自定义比较器对字符串列表进行排序
List<String> words = Arrays.asList("banana", "apple", "cherry");
List<String> sortedWords = words.stream()
.sorted(Comparator.reverseOrder())
.collect(Collectors.toList());
System.out.println(sortedWords); // 输出 [cherry, banana, apple]
5.peek
peek(Consumer<? super T> action): 用于调试，允许你无修改地查看流中的元素
示例：打印每个元素，用于调试。
List<String> words = Arrays.asList("hello", "world");
List<String> upperCaseWords = words.stream()
.peek(System.out::println) // 打印每个元素
.map(String::toUpperCase)
.collect(Collectors.toList());
6.limit
limit(long maxSize): 限制流的大小
示例：限制流的大小
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
List<Integer> limitedNumbers = numbers.stream()
.limit(3)
.collect(Collectors.toList());
System.out.println(limitedNumbers); // 输出 [1, 2, 3]
7.skip
skip(long n): 跳过流中的前 n 个元素
示例：跳过列表中的前 n 个元素。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
List<Integer> skippedNumbers = numbers.stream()
.skip(3)
.collect(Collectors.toList());
System.out.println(skippedNumbers); // 输出 [4, 5, 6, 7, 8, 9]
8.distinct
distinct(): 去除重复元素
List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 4, 4, 5, 5, 5, 6);
List<Integer> distinctNumbers = numbers.stream()
.distinct()
.collect(Collectors.toList());
System.out.println(distinctNumbers); // 输出 [1, 2, 3, 4, 5, 6]
3.终止管道
通过终止管道操作之后，Stream流将会结束，最后可能会执行某些逻辑处理，或者是按照要求返回某些执行后的结果数据
| API | 功能说明 |
|---|---|
| count() | 返回stream处理后最终的元素个数 |
| max() | 返回stream处理后的元素最大值 |
| min() | 返回stream处理后的元素最小值 |
| findFirst() | 找到第一个符合条件的元素时则终止流处理 |
| findAny() | 找到任何一个符合条件的元素时则退出流处理，这个对于串行流时与findFirst相同，对于并行流时比较高效，任何分片中找到都会终止后续计算逻辑 |
| anyMatch() | 返回一个boolean值，类似于isContains(),用于判断是否有符合条件的元素 |
| allMatch() | 返回一个boolean值，用于判断是否所有元素都符合条件 |
| noneMatch() | 安徽一个boolean值， 用于判断是否所有元素都不符合条件 |
| collect() | 将流转换为指定的类型，通过Collectors进行指定 |
| toArray() | 将流转换为数组 |
| iterator() | 将流转换为Iterator对象 |
| foreach() | 无返回值，对元素进行逐个遍历，然后执行给定的处理逻辑 |
1.forEach
forEach(Consumer<? super T> action): 对每个元素执行一个操作
示例：对每个元素执行打印操作
List<String> words = Arrays.asList("apple", "banana", "cherry");
// 预期结果：打印每个元素
words.stream().forEach(System.out::println);
// apple
// banana
// cherry
2.collect
collect(Collector<? super T, A, R> collector): 将流转换为其他形式，如列表、集合或 Map
示例：将流转换为列表
List<String> words = Arrays.asList("apple", "banana", "cherry");
// 预期结果：将流转换为列表 [APPLE, BANANA, CHERRY]
List<String> upperCaseWords = words.stream()
.map(String::toUpperCase)
.collect(Collectors.toList());
System.out.println(upperCaseWords);
3.reduce
reduce(T identity, BinaryOperator accumulator): 通过一个起始值，反复利用 BinaryOperator 来处理和累积元素，返回一个值
示例：使用 Integer::sum 作为累加器，将流中的整数相加
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
// 预期结果：计算总和 15
int sum = numbers.stream().reduce(0, Integer::sum);
System.out.println(sum); // 15
reduce(BinaryOperator accumulator): 使用一个 BinaryOperator 来累积元素，返回一个 Optional。
示例: 使用 Integer::max 作为累加器，找到流中的最大值。
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
// 预期结果：找到最大值 5
Optional<Integer> max = numbers.stream().reduce(Integer::max);
max.ifPresent(System.out::println); // 5
4.toArray
toArray(): 将流转换为对象数组
示例：使用 toArray 方法将流转换为对象数组
List<String> words = Arrays.asList("apple", "banana", "cherry");
// 预期结果：将流转换为对象数组 [apple, banana, cherry]
Object[] wordArray = words.stream().toArray();
System.out.println(Arrays.toString(wordArray));
toArray(IntFunction<A[]> generator): 将流转换为特定类型的数组
示例：使用 toArray 方法将流转换为特定类型的数组
List<String> words = Arrays.asList("apple", "banana", "cherry");
// 预期结果：将流转换为字符串数组 [apple, banana, cherry]
String[] wordArray = words.stream().toArray(String[]::new);
System.out.println(Arrays.toString(wordArray));
5.min
min(Comparator<? super T> comparator): 找到最小元素
示例：使用 min 方法找到流中的最小元素。
List<String> words = Arrays.asList("apple", "banana", "cherry");
// 预期结果：找到最小元素 apple
Optional<String> min = words.stream().min(String::compareTo);
min.ifPresent(System.out::println); // apple
6.max
max(Comparator<? super T> comparator): 找到最大元素
示例：使用 max 方法找到流中的最大元素。
List<String> words = Arrays.asList("apple", "banana", "cherry");
// 预期结果：找到最大元素 cherry
Optional<String> max = words.stream().max(String::compareTo);
max.ifPresent(System.out::println); // cherry
7.count
count(): 返回流中元素的数量。
示例：使用 count 方法返回流中元素的数量。
List<String> words = Arrays.asList("apple", "banana", "cherry");
// 预期结果：流中元素的数量 3
long count = words.stream().count();
System.out.println(count); // 3
8.anyMatch
anyMatch(Predicate<? super T> predicate): 检查是否至少有一个元素匹配给定的谓词
示例： 这个方法用于检查流中是否至少有一个元素匹配给定的谓词
List<String> words = Arrays.asList("apple", "banana", "cherry");
// 预期结果：至少有一个元素以 "a" 开头
boolean anyMatch = words.stream().anyMatch(s -> s.startsWith("a"));
System.out.println(anyMatch); // 输出 true
9.allMatch
allMatch(Predicate<? super T> predicate): 检查是否所有元素都匹配给定的谓词
示例：这个方法用于检查流中是否所有元素都匹配给定的谓词
List<String> words = Arrays.asList("apple", "banana", "cherry");
// 预期结果：所有元素都以 "c" 开头
boolean allMatch = words.stream().allMatch(s -> s.startsWith("c"));
System.out.println(allMatch); // 输出 false
10.noneMatch
noneMatch(Predicate<? super T> predicate): 检查是否没有元素匹配给定的谓词
示例： 这个方法用于检查流中是否没有元素匹配给定的谓词
List<String> words = Arrays.asList("apple", "banana", "cherry");
// 预期结果：没有元素以 "z" 开头
boolean noneMatch = words.stream().noneMatch(s -> s.startsWith("z"));
System.out.println(noneMatch); // 输出 true
10.noneMatch
noneMatch(Predicate<? super T> predicate): 检查是否没有元素匹配给定的谓词
示例： 这个方法用于检查流中是否没有元素匹配给定的谓词
List<String> words = Arrays.asList("apple", "banana", "cherry");
// 预期结果：没有元素以 "z" 开头
boolean noneMatch = words.stream().noneMatch(s -> s.startsWith("z"));
System.out.println(noneMatch); // 输出 true