文章目录

---

前言

大家好,好久不见了,最近由于实训的影响导致拖更了,在更新这一次估计javaSE基本上就算是完结了,还有一些落下的后面也会补上的,下次见面就是数据结构了

尽情期待吧!那么就让我们步入Stream流的学习吧! 

 

---

一、Stream流是什么？

Stream流是Java 8中的一个新特性，它提供了一种处理集合和数组的方式。Stream流可以让我们以一种更加简洁、高效、可读性更强的方式来处理数据。Stream流可以用于过滤、映射、排序、聚合等操作，它可以让我们避免使用循环和条件语句来处理数据，从而让代码更加简洁易懂。Stream流的操作可以分为中间操作和终止操作两种类型，中间操作返回的是一个新的Stream流，终止操作返回的是一个非Stream类型的结果。Stream流的处理是惰性求值的，只有在执行终止操作时才会开始处理数据。

流（Stream）是一种基于支持一次性处理数据的数据源的元素序列,流只能使用一次。

流的设计初衷是为了支持函数式编程，它的目的是将数据处理和数据存储分离开来，使得数据处理更加灵活和高效。因此，流的元素只是在流中传递的临时数据，它们并不是永久存储在内存中的数据。当流的元素被消费后，它们就会被释放，不能再次使用.

如果需要对同一个数据集进行多次不同的操作，可以使用流的中间操作方法来构建多个流管道，每个流管道都可以对流进行不同的操作，并返回一个新的流。这样就可以对同一个数据集进行多次操作，而不需要重新获取数据集。

二、流的分类

顺序流

顺序流是一种单线程的流，它按照数据流的顺序依次处理每个元素，每个元素的处理都必须等待上一个元素的处理完成才能开始。

并行流

并行流是一种多线程的流，它可以将数据分成多个部分并行处理，每个部分都可以在不同的线程中处理，从而提高处理效率。

使用顺序流可以保证数据处理的顺序和一致性，适用于处理数据量较小的情况。而使用并行流可以提高数据处理的速度，适用于处理数据量较大、处理时间较长的情况。但是并行流也有一些缺点，比如线程之间的通信和同步会带来额外的开销，而且并行流可能会影响数据的顺序和一致性。因此在使用并行流时需要注意线程安全和数据一致性等问题。

区别

顺序流和并行流的区别在于它们的处理方式不同，顺序流是单线程的，而并行流是多线程的。使用的方法也有一些区别，例如：

1. 获取顺序流：可以使用集合类的stream()方法、Arrays类的stream()方法、Stream类的of()方法、Stream类的iterate()方法、Stream类的generate()方法、Files类的lines()方法等来获取顺序流。

2. 获取并行流：可以使用集合类的parallelStream()方法、Stream类的of()方法的parallel()方法、Stream类的iterate()方法的parallel()方法、Stream类的generate()方法的parallel()方法等来获取并行流。

除此之外，顺序流和并行流的使用方法基本相同，例如可以使用map()、filter()、reduce()等方法对流进行操作。但需要注意的是，在使用并行流时需要考虑线程安全和数据一致性等问题。

下面我只会详细讲解顺序流的使用,并行流的使用大差不差,大家有兴趣可以自行尝试

三.获取流的常用方式

前面提到过,流（Stream）是一种基于支持一次性处理数据的数据源的元素序列,流只能使用一次

所以将流保存起来没有任何意义,但是获取还是很有必要的,下面我会将常用的获取方式详解,不常用的也会给出获取方式,大家有兴趣的话可以自行尝试!

对了,我觉得有必要的是因为我现在的知识面不广,接触不到太复杂的内容,等回头成了大牛再来补

哈哈,其实不说的大部分是我不会,小黑子,漏出鸡脚了吧

1.通过集合获取流：可以使用集合类中的stream()方法或parallelStream()方法来获取流

2.通过数组获取流：可以使用Arrays类中的stream()方法来获取流。

3.通过Stream.of()方法获取流：可以使用Stream类中的of()方法来获取流。

4.通过Stream.iterate()方法获取流：可以使用Stream类中的iterate()方法来获取流

Stream<Integer> stream = Stream.iterate(0, n -> n + 2).limit(5); // 获取顺序流

5.通过Stream.generate()方法获取流：可以使用Stream类中的generate()方法来获取流

Stream<Double> stream = Stream.generate(Math::random).limit(5); // 获取顺序流

 6.通过Files.lines()方法获取流：可以使用Files类中的lines()方法来获取流。

Stream<String> stream = Files.lines(Paths.get("file.txt")); // 获取顺序流

1.通过集合获取流

 可变参数不懂得详见http://t.csdn.cn/SSp8u

 源码

 

 刚才看了一下,有点麻烦,先欠着吧

大家暂时知道获取的这个方法就行了

2.通过数组获取流

 源码

3.通过Stream.of()方法获取流

 

四.常用方法用法

1. filter(Predicate<T> predicate)：过滤流中的元素，只保留符合条件的元素。
2. map(Function<T, R> mapper)：将流中的元素按照指定的方式进行映射，返回一个新的流。
3. flatMap(Function<T, Stream<R>> mapper)：将流中的元素按照指定的方式进行映射，然后将所有映射结果合并成一个流。
4. limit(long maxSize)：截取流中的前maxSize个元素。
5. skip(long n)：跳过流中的前n个元素。
6. sorted()：对流中的元素进行排序。
7. distinct()：去重，去除流中重复的元素。
8. forEach(Consumer<T> action)：对流中的每个元素执行指定的操作。
9. reduce(T identity, BinaryOperator<T> accumulator)：将流中的元素按照指定的方式进行累加，返回一个Optional对象。
10. collect(Collector<T, A, R> collector)：将流中的元素收集到一个集合中。
11. concat 合并a和b两个流为一个流

标红的不会进行讲解,有的是在我能力范围之外,当然了有两个,哈哈,主要是懒,不想了解

值得一提的是第六个排序好像可以指定排序规则,我去试试哈

确实可以哈

大家有兴趣可以试试,关于排序我之前的博文讲解的已经很透彻了,不再赘述

下面我只会简单演示一下,想要掌握的自己可以去练一下哈,到最后我会附上练习题和答案

1.filter(Predicate<T> predicate)：过滤流中的元素，只保留符合条件的元素

2.limit  &&  skip

 3.distinct()：去重，去除流中重复的元素。

 4.concat 合并a和b两个流为一个流

5. map(Function<T, R> mapper)：将流中的元素按照指定的方式进行映射，返回一个新的流

 突然想到这个问题了,解释一下

 6.forEach(Consumer<T> action)：对流中的每个元素执行指定的操作。

 就目前来看,我用的最多的是遍历

大家只要掌握遍历即可

7.collect(Collector<T, A, R> collector)：将流中的元素收集到一个集合中。

 

 5.练习

0,过滤奇数,只留下偶数

ArrayList<Integer> list = new ArrayList<>();
Collections.addAll(list,1,2,3,4,5,6,7,8,9,10);

1，男演员只要名字为3个字的前两人
2，女演员只要姓杨的，并且不要第一个
3，把过滤后的男演员姓名和女演员姓名合并到一起
4，将上一步的演员信息封装成Actor对象。
5，将所有的演员对象都保存到List集合中。

备注：演员类Actor，属性有：name，age
男演员：  "蔡坤坤,24" , "叶齁咸,23", "刘不甜,22", "吴签,24", "谷嘉,30", "肖梁梁,27"
女演员：  "赵小颖,35" , "杨颖,36", "高元元,43", "张天天,31", "刘诗,35", "杨小幂,33"

        ArrayList<String> list1 = new ArrayList<>();
        ArrayList<String> list2 = new ArrayList<>();

        Collections.addAll(list1,"蔡坤坤,24" , "叶齁咸,23", "刘不甜,22", "吴签,24", "谷嘉,30", "肖梁梁,27");
        Collections.addAll(list2,"赵小颖,35" , "杨颖,36", "高元元,43", "张天天,31", "刘诗,35", "杨小幂,33");

        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list,1,2,3,4,5,6,7,8,9,10);

        // 0, 过滤奇数,只留下偶数

        List<Integer> collect = list.stream().filter(integer -> integer % 2 == 0).collect(Collectors.toList());

        System.out.println(collect);

        // 1，男演员只要名字为3个字的前两人

        Stream<String> stream1 = list1.stream().filter(s -> s.split(",")[0].length() == 3).limit(2);

        //  2，女演员只要姓杨的，并且不要第一个

        Stream<String> stream2 = list2.stream().filter(s -> s.startsWith("杨")).skip(1);

        // 3，把过滤后的男演员姓名和女演员姓名合并到一起

        //Stream.concat(stream1,stream2).forEach(s-> System.out.println(s));

        // 4，将上一步的演员信息封装成Actor 对象

        // 类型转换 String-> Actor
        Stream.concat(stream1, stream2).map(new Function<String, Actor>() {
            @Override
            public Actor apply(String s) {
                Actor actor = new Actor();

                actor.setName(s.split(",")[0]);

                actor.setAge(Integer.parseInt(s.split(",")[1]));

                return actor;
            }
        }).forEach(s-> System.out.println(s.getName()+" "+s.getAge()));

        // 5，将所有的演员对象都保存到List集合中。
        List<Actor> list3 = Stream.concat(stream1, stream2).map(s -> new Actor(s.split(",")[0], Integer.parseInt(s.split(",")[1])))
                .collect(Collectors.toList());

        System.out.println(list3);

总结

今天就说到这吧,大家记得做练习哈