长沙景点门票价格表_seo全称_竞价推广是什么工作_指数平台

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());javaSystem.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);// 预期结果：计算总和 15int 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);// 预期结果：找到最大值 5Optional<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");// 预期结果：找到最小元素 appleOptional<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");// 预期结果：找到最大元素 cherryOptional<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");// 预期结果：流中元素的数量 3long 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