Java中Stream流详解

概要

✨介绍

Java中的Stream是Java 8引入的一种新的API，用于处理集合或数组中的数据，提供了一种简洁且高效的方式来进行各种操作，如过滤、排序、映射、汇总等。Stream不存储数据，它更像是一个高级迭代器，通过一系列流水线操作来处理数据。Stream操作可以分为两类：中间操作和终端操作。

🍁特点

• 惰性求值 (Lazy Evaluation)：Stream中的操作是惰性执行的，只有在终止操作执行时，才会实际计算结果。
• 不可变性 (Immutability)：Stream是不可变的，每次对Stream的操作都会返回一个新的Stream，而不会修改原始数据源。
• 无存储 (No Storage)：Stream不会存储数据，数据存储在数据源中。

💪操作类型

• 中间操作 (Intermediate Operations)：返回一个新的Stream，允许多个操作链式调用。这些操作都是惰性执行的，直到执行终止操作。

常见的中间操作包括：filter(), map(), sorted(), distinct(), limit(), skip(), peek()等。

• 终止操作 (Terminal Operations)：触发Stream的处理并生成结果。终止操作会关闭Stream，使得Stream无法再被使用。

常见的终止操作包括：forEach(), collect(), reduce(), count(), min(), max(), anyMatch(), allMatch(), noneMatch()等。

🐜优缺点

优点：

1. 代码简洁性与可读性：Stream 提供了声明式的编程方式，使得代码更简洁、优雅。可以通过链式调用将复杂的操作步骤清晰地表达出来，减少了样板代码（如循环和条件判断）的使用。
2. 函数式编程支持：Stream 强化了Java对函数式编程的支持。开发者可以将Lambda表达式与Stream结合，使用map、filter、reduce等操作处理数据，这种方式更加直观且容易维护。
3. 并行处理能力：Stream 支持并行流（parallelStream），允许在多核处理器上并行处理数据，提升处理性能，特别适合大规模数据处理的场景。
4. 惰性求值：Stream 的惰性求值特性可以优化性能。只有在终止操作执行时，Stream 才会真正执行操作。这使得可以将多个中间操作组合起来，并且只需遍历数据源一次，减少不必要的计算。
5. 流畅的API设计：Stream API 设计非常流畅，提供了多种常用操作，可以很方便地组合这些操作来实现各种复杂的数据处理逻辑。

缺点：

1. 调试困难：由于Stream使用了链式调用和Lambda表达式，调试过程比传统的for循环复杂得多。特别是在链式操作中出现错误时，定位问题可能较为困难。
2. 性能开销：虽然Stream可以通过并行处理提升性能，但在某些场景下，它的性能可能低于传统的循环。例如，在涉及大量对象创建或短小集合的场景中，Stream的惰性求值和中间对象的创建可能带来额外的性能开销。
3. 可读性问题：虽然Stream可以使代码更加简洁，但过度使用或在不适合的场合使用Stream可能导致代码过于复杂，降低可读性，特别是对于不熟悉Stream的开发者而言。
4. 资源消耗：在某些情况下，Stream 可能导致较高的内存消耗。例如，如果在一个非常大的集合上使用复杂的流操作链，可能会占用大量内存，甚至导致OutOfMemoryError。
5. 不适合所有场景：Stream 更适合处理无状态的、不可变的数据操作。对于需要频繁修改数据或需要处理具有状态的操作，传统的迭代方法可能更为合适。

package com.stream;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

/**
* 需求：找出姓张，并且是3个字的名字，存入到一个新集合中
*/
public class Demo {
    public static void main(String[] args) {
        ArrayList<String> names = new ArrayList<>();
        Collections.addAll(names, "张三丰", "张无忌", "周芷若", "赵敏", "张三", "韦一笑");

        // 方案一：传统遍历
        List<String> list = new ArrayList<>();
        for (String name : names) {
            if (name.startsWith("张") && name.length() == 3) {
                list.add(name);
            }
        }
        System.out.println(list); // [张三丰, 张无忌]


        // 方案二：Stream
        List<String> list2 = names.stream()
                .filter(name -> name.startsWith("张") && name.length() == 3)
                .collect(Collectors.toList());
        System.out.println(list2); // [张三丰, 张无忌]
    }
}

获取Steam流

获取List集合的Stream流

ArrayList<String> names = new ArrayList<>();
Collections.addAll(names, "张三丰", "张无忌", "周芷若", "赵敏", "张三", "韦一笑");
Stream<String> stream = names.stream();

获取Set集合的Stream流

Set<String> set = new HashSet<>();
Collections.addAll(set, "九阳神功", "乾坤大挪移", "九阴白骨爪", "峨眉剑法");
Stream<String> stream1 = set.stream();

获取Map集合的流

Map<String, Integer> map = new HashMap<>();
map.put("李白", 521);
map.put("杜甫", 412);
map.put("白居易", 243);
map.put("陶渊明", 156);

// map keys 的 Stream
Set<String> strings = map.keySet();
Stream<String> stream2 = strings.stream();

// Map values 的 Stream
Collection<Integer> values = map.values();
Stream<Integer> stream3 = values.stream();

Set<Map.Entry<String, Integer>> entries = map.entrySet();
Stream<Map.Entry<String, Integer>> kvs = entries.stream();
kvs.filter(v -> v.getKey().contains("白"))
	.forEach(i -> System.out.println(i.getKey() + ": " + i.getValue()));

获取数组的Stream流

String[] names2 = {"薛平贵", "王宝钏", "葛青", "葛大", "张伟"};
Stream<String> stream4 = Arrays.stream(names2);
Stream<String> stream5 = Stream.of(names2);

package com.stream;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Demo0 {
    public static void main(String[] args) {
        // 一、获取List集合的Stream流
        ArrayList<String> names = new ArrayList<>();
        Collections.addAll(names, "张三丰", "张无忌", "周芷若", "赵敏", "张三", "韦一笑");
        Stream<String> stream = names.stream();

        // 二、获取Set集合的Stream流
        Set<String> set = new HashSet<>();
        Collections.addAll(set, "九阳神功", "乾坤大挪移", "九阴白骨爪", "峨眉剑法");
        Stream<String> stream1 = set.stream();

        // 三、获取Map集合的流
        Map<String, Integer> map = new HashMap<>();
        map.put("李白", 521);
        map.put("杜甫", 412);
        map.put("白居易", 243);
        map.put("陶渊明", 156);

        // map keys 的 Stream
        Set<String> strings = map.keySet();
        Stream<String> stream2 = strings.stream();

        // Map values 的 Stream
        Collection<Integer> values = map.values();
        Stream<Integer> stream3 = values.stream();

        Set<Map.Entry<String, Integer>> entries = map.entrySet();
        Stream<Map.Entry<String, Integer>> kvs = entries.stream();
        kvs.filter(v -> v.getKey().contains("白"))
                .forEach(i -> System.out.println(i.getKey() + ": " + i.getValue()));

        // 四、获取数组的Stream流
        String[] names2 = {"薛平贵", "王宝钏", "葛青", "葛大", "张伟"};
        Stream<String> stream4 = Arrays.stream(names2);
        Stream<String> stream5 = Stream.of(names2);
        List<String> collect = stream5.filter(v -> v.length() == 3).collect(Collectors.toList());

        for (String s : collect) {
            System.out.println(s);
        }
    }
}

Stream的方法

filter：根据给定的条件过滤出符合条件的元素。

public static void filter() {
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
    List<Integer> evenNumbers = numbers.stream()
		.filter(n -> n % 2 == 0)
		.collect(Collectors.toList());

    System.out.println(evenNumbers); // [2, 4]
}

map：将每个元素通过给定的函数映射成另一个元素（对每一项数据进行加工处理）。

public static void map() {
	List<String> words = Arrays.asList("hello", "world", "java");
	
	List<Integer> wordLengths = words.stream()
		.map(String::length)
		.collect(Collectors.toList());
		
	System.out.println(wordLengths); // [5, 5, 4]
}

peek：对流中的每个元素执行操作并返回一个新的流，主要用于调试。

public static void map() {
	Stream<String> stream = Stream.of("apple", "banana", "cherry");
	Stream<String> peekedStream = stream.peek(System.out::println); // "apple", "banana", "cherry"
}

sorted：对Stream中的元素进行排序。

public static void sorted() {
	List<Integer> numbers = Arrays.asList(8, 3, 6, 7, 5);
	
   	List<Integer> sortedNumbers = numbers.stream()
		.sorted((a, b) -> a - b)
       	.collect(Collectors.toList());

	System.out.println(sortedNumbers); // [3, 5, 6, 7, 8]
}

distinct：去除Stream中的重复元素。

public static void distinct() {
	List<String> daxias = Arrays.asList("张无忌", "赵敏", "张无忌", "周芷若", "赵敏");

	List<String> distinctDaxias = daxias.stream()
		.distinct()
        .collect(Collectors.toList()); // [张无忌, 赵敏, 周芷若]

	System.out.println(distinctDaxias);
}

reduce：对Stream中的元素进行归约操作，可以实现求和、求最大值、求最小值等操作。

public static void reduce() {
	List<Integer> numbers = Arrays.asList(8, 3, 6, 7, 5);

    // 求和
    Integer sum1 = numbers.stream().reduce((a, b) -> a + b).get();
    Integer sum2 = numbers.stream().reduce(Integer::sum).get();

    System.out.println("sum1: " + sum1 + "，sum2：" + sum2); // sum1: 29，sum2：29

    // 最大值
    Integer max1 = numbers.stream().reduce((a, b) -> a > b ? a : b).get();
    Integer max2 = numbers.stream().reduce(Integer::max).get();
    System.out.println("max1：" + max1 + "，max2：" + max2); // max1：8，max2：8

	// 最小值
    Integer min1 = numbers.stream().reduce((a, b) -> a < b ? a : b).get();
    Integer min2 = numbers.stream().reduce(Integer::min).get();
    System.out.println("min1：" + min1 + "，min2：" + min2); // min1：3，min2：3
}

limit：限制Stream中元素的数量。

public static void limit() {
	List<Integer> numbers = Arrays.asList(8, 3, 6, 7, 5);
    List<Integer> limitedNumbers = numbers.stream()
		.limit(3)
		.collect(Collectors.toList());

	System.out.println(limitedNumbers); // [8, 3, 6]
}

skip：跳过Stream中的前几个元素。

public static void skip() {
		List<Integer> numbers = Arrays.asList(8, 3, 6, 7, 5);
    List<Integer> limitedNumbers = numbers.stream()
		    .skip(2)
		    .collect(Collectors.toList());

    System.out.println(limitedNumbers); // [6, 7, 5]
}

anyMatch：检查Stream中是否有满足给定条件的元素。

public static void anyMatch() {
	List<String> daxia = Arrays.asList("张无忌", "赵敏", "宋青书", "周芷若", "张三丰", "韦一笑");

	boolean isWiyixiao = daxia.stream().anyMatch("韦一笑"::equals);
	boolean isSongqingshu = daxia.stream().anyMatch("宋青书"::equals);
    boolean isXiexun = daxia.stream().anyMatch("谢逊"::equals);

    System.out.println(isWiyixiao);    // true
    System.out.println(isSongqingshu); // true
    System.out.println(isXiexun);      // false
}

allMatch：检查Stream中的所有元素是否都满足给定条件。

public static void allMatch() {
    List<Integer> numbers = Arrays.asList(8, 3, 6, 7, 5);
    
    boolean isAllLesstheTen = numbers.stream().allMatch(v -> v < 10);
    boolean isAllLesstheFive = numbers.stream().allMatch(v -> v < 5);

	System.out.println(isAllLesstheTen);  // true
    System.out.println(isAllLesstheFive); // false
}

noneMatch：检查Stream中的所有元素是否都不满足给定条件。

public static void noneMatch() {
    List<Integer> numbers = Arrays.asList(8, 3, 6, 7, 5);
    
    boolean noneMatch1 = numbers.stream().noneMatch(v -> v > 10);
    boolean noneMatch2 = numbers.stream().noneMatch(v -> v > 5);

    System.out.println(noneMatch1); // true
    System.out.println(noneMatch2); // false
}

findFirst：返回Stream流中的第一个元素。

public static void findFirst() {
    List<String> daxia = Arrays.asList("张无忌", "赵敏", "宋青书", "周芷若", "张三丰", "韦一笑");
    
    String firstEle = daxia.stream().findFirst().get();

    System.out.println(firstEle); // 张无忌
}

findAny：返回Stream中的任意一个元素。

public static void findAny() {
    List<String> daxia = Arrays.asList("张无忌", "赵敏", "宋青书", "周芷若", "张三丰", "韦一笑");
    
    String anyEle = daxia.stream().findAny().get();

    System.out.println(anyEle); // 张无忌
}

count：返回Stream中的元素数量。

public static void count() {
    ArrayList<Integer> numbers = new ArrayList<>();

    for (int i = 0; i < 100000; i++) {
        numbers.add(i);
    }

    long count = numbers.stream().count();
    System.out.println("集合总长度为：" + count); // 集合总长度为：100000
}

max：返回Stream中的最大值。

public static void max() {
    List<Integer> numbers = Arrays.asList(8, 3, 6, 7, 5);
    
    Integer maxValue = numbers.stream().max((a, b) -> a - b).get();

    System.out.println(maxValue); // 8
}

min：返回Stream中的最小值。

public static void min() {
    List<Integer> numbers = Arrays.asList(8, 3, 6, 7, 5);
    
	Integer maxValue = numbers.stream().min((a, b) -> a - b).get();

	System.out.println(maxValue); // 3
}

小结

通过使用Stream，Java开发者可以以一种更简洁、清晰和高效的方式处理数据集，极大地提高了代码的可读性和可维护性。但是项目开发中要注意以下事项：

• 避免过度使用: 虽然Stream非常强大，但也要避免滥用，特别是在简单的情况下，可能会导致代码可读性下降。
• 性能考虑: 在处理小数据集时，Stream的性能可能不如传统的循环，因此在使用时应根据具体场景选择合适的工具。