Java Stream流

weixin_47363690

已于 2024-09-18 15:38:26 修改

阅读量441

点赞数 19

分类专栏： java 文章标签： java 开发语言

于 2024-09-18 15:35:38 首次发布

本文链接：https://blog.csdn.net/weixin_47363690/article/details/142329233

版权

java 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

Java 8 引入了 Stream API，这是一个用于处理集合数据的强大工具。Stream API 提供了一系列高级功能，如过滤、映射、归约、查找等，使得处理集合数据变得更加简洁和高效。下面是对 Stream API 的详细介绍，包括其基本概念、常用操作和示例。

1 基本概念

Stream：表示一组数据的序列，支持顺序和并行操作。
Source：流的来源，可以是集合、数组、文件、I/O 等。
Intermediate Operations：中间操作，返回一个新的流，可以链式调用多个中间操作。
Terminal Operations：终端操作，执行流的计算并返回结果，终止流的操作链。

2 创建Stream流

2.1 单列集合创建

List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream();

2.2 数组创建

String[] array = {"a", "b", "c"};
// Arrays.stream
Stream<String> stream = Arrays.stream(array);
// Stream.of
Stream<String> stream2 = Stream.of(array);

2.3 双列集合创建

Map<String, Integer> map = new HashMap<>();
map.put("小黑", 17);
map.put("小白", 16);
Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
entrySet.stream().filter(s -> s.getValue() > 16).forEach(s -> System.out.println(s.getKey() + "===" + s.getValue()));

2.4 文件创建

try (Stream<String> lines = Files.lines(Paths.get("file.txt"), StandardCharsets.UTF_8)) {
    lines.forEach(System.out::println);
} catch (IOException e) {
    e.printStackTrace();
}

3 Stream中间操作

3.1 filter

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> evenNumbers = numbers.stream().filter(n -> n > 2).collect(Collectors.toList());
System.out.println(evenNumbers); // 输出[3, 4, 5]

过滤流中的元素，只保留满足条件的元素。

3.2 map

List<String> words = Arrays.asList("apple", "banana", "cherry");
List<Integer> lengths = words.stream().map(String::length).collect(Collectors.toList());
System.out.println(lengths); // 输出[5, 6, 6]，返回字符串长度

将流中的每个元素转换为另一种形式。

3.3 distinct

List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 4, 4, 5);
List<Integer> uniqueNumbers = numbers.stream().distinct().collect(Collectors.toList());
System.out.println(uniqueNumbers); // 输出[1, 2, 3, 4, 5]

去重，保留唯一元素。以下是对象中根据某属性去重的例子：

private static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
    Set<Object> seen = ConcurrentHashMap.newKeySet();
    return t -> seen.add(keyExtractor.apply(t));
}
authors.stream().filter(distinctByKey(s -> s.getName())).forEach(s -> System.out.println(s.toString()));

3.4 sorted

List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5);
List<Integer> sortedNumbers = numbers.stream().sorted().collect(Collectors.toList());
System.out.println(sortedNumbers); // 输出[1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

排序，默认自然排序。如果是根据对象中某属性排序，可以参照如下：

// 根据Book对象中的createTime属性进行降序排列
.sorted(Comparator.comparing(Book::getCreateTime).reversed())

3.5 flatMap

List<List<Integer>> lists = Arrays.asList(
                Arrays.asList(1, 2),
                Arrays.asList(3, 4)
        );
List<Integer> flatList = lists.stream().flatMap(List::stream).collect(Collectors.toList());
        System.out.println(flatList); // 输出[1, 2, 3, 4]

将流中的每个元素转换为一个流，然后将所有流扁平化为一个流。

3.6 limit

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
List<Integer> limitedList = numbers.stream().limit(5).collect(Collectors.toList());
System.out.println(limitedList); // 结果: [1, 2, 3, 4, 5]

返回一个最多包含maxSize个元素的流，如果流中的元素少于maxSize，则返回所有元素，如果大于maxSize，超出部分将会被舍弃。

3.7 skip

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
List<Integer> skippedList = numbers.stream().skip(5).collect(Collectors.toList());
System.out.println(skippedList); // 结果: [6, 7, 8, 9, 10]

返回一个跳过前 n 个元素的流，如果流中的元素少于 n，则返回一个空流。

3.8 peek

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> result = numbers.stream().peek(System.out::println).filter(n -> n % 2 == 0).collect(Collectors.toList());

用于调试，打印流中的每个元素。

4 Stream终结操作

4.1 forEach

List<String> words = Arrays.asList("apple", "banana", "cherry");
words.stream().forEach(System.out::println);

遍历流中的每个元素。

4.2 collect

List<String> words = Arrays.asList("apple", "banana", "cherry");
List<String> result = words.stream().filter(w -> w.startsWith("a")).collect(Collectors.toList());

将流中的元素收集到一个集合中。

4.3 reduce

// 方式一
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> sum = numbers.stream().reduce(Integer::sum);
sum.ifPresent(System.out::println); // 输出：15

// 方式二，提供一个初始值
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream().reduce(2, Integer::sum);
System.out.println(sum); // 输出：17

归并，对流中的数据按照你指定的计算方式计算出一个结果。

4.4 count

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 9);
long count = numbers.stream().count();
System.out.println(count); // 输出：6

计算流中元素的数量。

4.5 max&min

List<Integer> numbers1 = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> max = numbers1.stream().max(Integer::compare);
max.ifPresent(System.out::println); // 输出：5

List<Integer> numbers2 = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> min = numbers2.stream().min(Integer::compare);
min.ifPresent(System.out::println); // 输出：1

max：返回流中最大值的元素。

min：返回流中最小值的元素。