中介如何做网站收客西安seo代理计费

Java中Stream操作

Stream 和 Optional区别

• 用途不同：Stream 用于处理集合中的元素序列，支持丰富的中间操作和终端操作；Optional 用于表示一个值可能为 null 的情况，提供了一种更优雅的处理方式。
• 数据处理 vs. 容器：Stream 是处理数据流的工具，而 Optional 是一个容器，用于可能缺少值的情况。
• API风格：Stream 使用函数式编程风格进行操作，Optional 提供了对值进行安全处理的函数式方法。

在实际开发中，Stream 和 Optional 经常配合使用，Stream 可能包含 Optional 对象，以处理可能为 null 的元素，从而有效地提高代码的安全性和可读性。

generate

产生随机数字流，会一直输出

Stream<Double> stream = Stream.generate(Math::random);
stream.forEach(System.out::println);

iterate

一直循环添加

Stream<BigInteger> stream = Stream.iterate(BigInteger.ZERO, n -> n.add(BigInteger.ONE));
stream.forEach(System.out::println);

of和limit

// 创建指定长度随机数
List<Double> list = Stream.generate(Math::random).limit(10).toList();
list.forEach(System.out::println);// 创建不好喊任何元素的流
Stream<Object> empty = Stream.empty();
empty.forEach(System.out::println);// 创建一个给定值的流
Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6);
integerStream.forEach(System.out::println);// 使用 ofNullable 创建一个流，如果值为 null 则创建一个空流
Stream<String> stream = Stream.ofNullable("hello");
stream.forEach(System.out::println);

文件流

输入这个文件中的每一行

var lines = Files.lines(Path.of("D:\\Project\\demo\\sharding-sphere5\\service\\src\\test\\java\\cn\\bunny\\stream\\StreamTest.java"));
lines.forEach(System.out::println);lines.close();

带map相关

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);// Map处理数据
var list = numbers.stream().map(number -> number * 2).toList();
System.out.println(list);// 扁平化数据
List<List<Integer>> nestedNumbers = Arrays.asList(Arrays.asList(1, 2, 3),Arrays.asList(4, 5),Arrays.asList(6, 7, 8)
);
System.out.println("原始数据：" + nestedNumbers);
var integerList = nestedNumbers.stream().flatMap(List::stream).toList();
System.out.println(integerList);// 将每个字符串拆分为字符并输出
Stream<String> stream = Stream.of("apple", "banana", "cherry");
List<Object> objectList1 = stream.mapMulti((str, consumer) -> {System.out.println(str);for (char c : str.toCharArray()) {consumer.accept(c);}
}).toList();
System.out.println(objectList1);// 使用 mapMulti 方法处理流中的元素
Stream<Integer> integerStream = Stream.of(1, 2, 3);
var objectList = integerStream.mapMulti((num, consumer) -> {// [1, 1, 4, 8, 9, 27]consumer.accept(num * num);consumer.accept(num * num * num);
}).toList();
System.out.println(objectList);

limit

在需要仅处理流中前几个元素时，可以使用 limit 方法。

Stream<Integer> stream = Stream.iterate(0, i -> i + 1);
Stream<Integer> limit = stream.limit(5);
limit.forEach(System.out::println);

skip

在需要跳过流中的前几个元素后处理后续元素时，可以使用 skip 方法。

Stream<Integer> stream = Stream.iterate(0, i -> i + 1);
Stream<Integer> skip = stream.skip(3);
skip.forEach(System.out::println);

takeWhile

在需要根据条件获取流中开头满足条件的元素时，可以使用 takeWhile 方法。

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
Stream<Integer> integerStream = stream.takeWhile(num -> num < 4);
integerStream.forEach(System.out::println);

dropWhile

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
stream.dropWhile(num -> num < 4).forEach(System.out::println);

concat

在需要将两个流合并成一个流时，可以使用 concat 方法。

Stream<Integer> stream1 = Stream.of(1, 2, 3);
Stream<Integer> stream2 = Stream.of(4, 5, 6);
Stream<Integer> concatenatedStream = Stream.concat(stream1, stream2);
concatenatedStream.forEach(System.out::println);

distinct

在需要从流中去除重复元素时，可以使用 distinct 方法。

Stream<String> stream = Stream.of("apple", "banana", "apple", "orange", "banana");
stream.distinct().forEach(System.out::println);

sorted

默认情况下，sorted 方法会按自然顺序对元素进行升序排序。如果需要降序排序，可以使用 sorted(Comparator.reverseOrder())；返回负数是升序

// 当条件是负数时是升序还是降序、相等不变这句话对吗？
// 当使用 sorted 方法时，负数会被认为是比正数更小，所以如果排序条件是负数，它会被放在最前面，因此会是升序排序。
// 相等不变这句话通常是指排序时相等的元素在排序后的顺序不变，这在 Java 中是成立的。
Stream<Integer> stream = Stream.of(3, 1, 4, 1, 5, 9, 2, 6);
stream.sorted().forEach(System.out::println);

peek

在需要在流的处理过程中查看元素但不改变流本身时，可以使用 peek 方法。

Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
stream.peek(System.out::println).forEach(integer -> {
}); // 迭代所有元素
stream.close(); // 在所有操作完成后关闭流

max和min

这两个方法用于获取流中的最大值和最小值。它们通常用于包含可比较元素的流。

Stream<Integer> numbers = Stream.of(1, 2, 3, 4, 5);// 获取流中的最大值
Integer max = numbers.max(Integer::compareTo).orElse(0);
System.out.println("Max value: " + max);// 最小值
Stream<Integer> numbers2 = Stream.of(1, 2, 3, 4, 5);
Integer min = numbers2.min(Integer::compareTo).orElse(0);
System.out.println("Min value: " + min);

find

这两个方法用于从流中获取元素。findFirst 返回流中的第一个元素，而 findAny 返回流中的任意一个元素（在并行流中更有用）。

Stream<String> strings = Stream.of("apple", "banana", "cherry");// 找到第一个元素
Optional<String> firstElement = strings.findFirst();
System.out.println("First element: " + firstElement.orElse("No element found"));// 找到任意一个元素
Stream<String> strings2 = Stream.of("apple", "banana", "cherry");
Optional<String> anyElement = strings2.findAny();
System.out.println("Any element: " + anyElement.orElse("No element found"));

Match

anyMatch：判断流中是否至少有一个元素满足条件。
allMatch：判断流中的所有元素是否都满足条件。
noneMatch：判断流中是否所有元素都不满足条件。

// 检查是否有元素大于3
Stream<Integer> numbers = Stream.of(1, 2, 3, 4, 5);
boolean anyGreaterThanThree = numbers.anyMatch(num -> num > 3);
System.out.println("Any number greater than 3: " + anyGreaterThanThree);// 检查是否所有元素都小于10
Stream<Integer> numbers2 = Stream.of(1, 2, 3, 4, 5);
boolean allLessThanTen = numbers2.allMatch(num -> num < 10);
System.out.println("All numbers less than 10: " + allLessThanTen);// 检查是否所有元素都不等于0
Stream<Integer> numbers3 = Stream.of(1, 2, 3, 4, 5);
boolean noneEqualToZero = numbers3.noneMatch(num -> num == 0);
System.out.println("No numbers equal to zero: " + noneEqualToZero);