浅谈stream流常用方法

​
前言：该篇博客主要是本人日常开发的stream流学习总结

什么是Stream？

Java8 中，Collection 新增了两个流方法，分别是 Stream() 和 parallelStream()

Java8 中添加了一个新的接口类 Stream，相当于高级版的 Iterator，它可以通过 Lambda 表达式对集合进行大批量数据操作，或者各种非常便利、高效的聚合数据操作。

为什么要用 Stream

在 Java8 之前，我们通常是通过 for 循环或者 Iterator 迭代来重新排序合并数据，又或者通过重新定义 Collections.sorts 的 Comparator 方法来实现，这两种方式对于大数据量系统来说，效率并不是很理想。Stream 的聚合操作与数据库 SQL 的聚合操作 sorted、filter、map 等类似。我们在应用层就可以高效地实现类似数据库 SQL 的 聚合操作了，从数据库中得到数据之后，往往需要根据业务场景对数据进行进一步的处理，而stream流的一些常用方法基本就满足了我们的常用的数据处理需求。

Stream入门

  List<String> nameList = Arrays.asList("张三", "李四", "王五", "赵柳", "张五六七", "王少", "赵四", "张仁", "李星");
        //需求：找出 姓张中名字最长的
        int maxLengthStartWithZ = nameList.stream()
                //过滤以“张”开头的对象，形成一个新的stream流
                .filter(e -> e.startsWith("张"))
                //将流中对象的length转为int，形成一个int类型stream流
                .mapToInt(String::length)
                //取流中最大,返回
                .max().getAsInt();
        System.out.println(nameList.get(maxLengthStartWithZ));

Stream 操作分类

官方将 Stream 中的操作分为两大类：终结操作（Terminal operations）和中间操作（Intermediate operations）。

中间操作会返回一个新的流，一个流可以后面跟随零个或多个中间操作。其目的主要是打开流，做出某种程度的数据映射/过滤，

然后会返回一个新的流，交给下一个操作使用。这类操作都是惰性化的（lazy），就是说，仅仅调用到这类方法，并没有真正开始流的遍历，

而是在终结操作开始的时候才真正开始执行。

中间操作又可以分为无状态（Stateless）与有状态（Stateful）操作:

​ 无状态是指元素的处理不受之前元素的影响；

​ 有状态是指该操作只有拿到所有元素之后才能继续下去。

终结操作是指返回最终的结果。一个流只能有一个终结操作，当这个操作执行后，这个流就被使用“光”了，无法再被操作。所以

这必定这个流的最后一个操作。终结操作的执行才会真正开始流的遍历，并且会生成一个结果。

终结操作又可以分为短路（Short-circuiting）与非短路（Unshort-circuiting）操作，

​ 短路是指遇到某些符合条件的元素就可以得到最终结果，

​ 非短路是指必须处理完所有元素才能得到最终结果。操作分类详情如下图所示：

​

stream常用方法

public class Streamplus {
    public static void main(String[] args) {
        List<Persion> persionList = Datainit();
        //distinic(persionList);
        filter(persionList);
        //total(persionList);
        //MaxAndMin(persionList);

    }

    //数据准备
    public static List<Persion> Datainit() {
        List<Persion> persionList = Arrays.asList(
                new Persion("吴彦祖", 168, "男"),
                new Persion("吴彦祖", 182, "男"),
                new Persion("吴彦祖", 182, "男"),
                new Persion("小黑", 186, "男"),
                new Persion("小红", 156, "女"),
                new Persion("小黄", 158, "女"),
                new Persion("小青", 165, "女"),
                new Persion("小紫", 172, "女"));
        return persionList;
    }


    //Stream实现分组
    public static void groupBy(List<Persion> persionList) {
        Map<String, List<Persion>> groupByList = persionList.stream()
                .collect(Collectors.groupingBy(Persion::getSex));
        System.out.println("分组后：" + groupByList);
    }

    //Stream实现过滤
    public static void filter(List<Persion> persionList) {
        List<Persion> filter = persionList
                .stream()
                .filter(student -> student.getHeight() > 180)
                .collect(Collectors.toList());
        System.out.println("过滤后：" + filter);
    }

    //Stream实现求和
    public static void total(List<Persion> persionList) {
        int totalHeight = persionList
                .stream()
                .mapToInt(Persion::getHeight)
                .sum();
        System.out.println(totalHeight);
        
        
    }

    //Stream找最大和最小
    public static void MaxAndMin(List<Persion> persionList) {
        int maxHeight = persionList
                .stream()
                .mapToInt(Persion::getHeight)
                .max()
                .getAsInt();
        System.out.println("max:" + maxHeight);
        int minHeight = persionList
                .stream()
                .mapToInt(Persion::getHeight)
                .min()
                .getAsInt();
        System.out.println("min:" + minHeight);
    }

补充：
stream流实现多字段去重

    //Stream实现多字段去重
    public static void distinic(List<Persion> persionList) {
        ArrayList<Persion> persionArrayList = persionList
                .stream()
                .collect
                        (Collectors
                                .collectingAndThen
                                        (Collectors.toCollection
                                                (() -> new TreeSet<>(Comparator.comparing(e -> e.getName() + ";" + e.getSex()))), ArrayList::new));
        System.out.println(persionArrayList);

    }

筛选出来的结果

因为 Stream 操作类型非常多，总结一下常用的

• map():将流中的元素进行再次加工形成一个新流，流中的每一个元素映射为另外的元素。

• filter(): 返回结果生成新的流中只包含满足筛选条件的数据

• limit()：返回指定数量的元素的流。返回的是 Stream 里前面的 n 个元素。

• skip()：和 limit()相反，将前几个元素跳过（取出）再返回一个流，如果流中的元素小于或者等于 n，就会返回一个空的流。

• sorted()：将流中的元素按照自然排序方式进行排序。

• distinct()：将流中的元素去重之后输出。

• peek()：对流中每个元素执行操作，并返回一个新的流，返回的流还是包含原来流中的元素。