Steam的学习

程序员文章站 2022-05-22 20:36:04

...

Steam的学习

1.Stream介绍

一、什么是Java Stream API？

Java Stream函数式编程接口最初是在Java 8中引入的，并且与lambda一起成为Java开发的里程碑式的功能特性，它极大的方便了开放人员处理集合类数据的效率。Java Stream就是一个数据流经的管道，并且在管道中对数据进行操作，然后流入下一个管道。在没有Java Stram之前，对于集合类的操作，更多的是通过for循环。Java Stream相对于for 循环更加简洁、易用、快捷。

管道的功能包括：Filter（过滤）、Map(映射)、sort(排序）等，集合数据通过Java Stream管道处理之后，转化为另一组集合或数据输出。

二、Stream API代替for循环

例子：

List<String> nameStrs = Arrays.asList("Monkey", "Lion", "Giraffe","Lemur");

List<String> list = nameStrs.stream()
        .filter(s -> s.startsWith("L"))
        .map(String::toUpperCase)
        .sorted()
        .collect(toList());
System.out.println(list);

首先，我们使用Stream()函数，将一个List转换为管道流
调用filter函数过滤数组元素，过滤方法使用lambda表达式，以L开头的元素返回true被保留，其他的List元素被过滤掉
然后调用Map函数对管道流中每个元素进行处理，字母全部转换为大写
然后调用sort函数，对管道流中数据进行排序
最后调用collect函数toList，将管道流转换为List返回

最终的输出结果是：[LEMUR, LION]。

三、将数组转换为管道流

使用Stream.of()方法，将数组转换为管道流。

String[] array = {"Monkey", "Lion", "Giraffe", "Lemur"};
Stream<String> nameStrs2 = Stream.of(array);
Stream<String> nameStrs3 = Stream.of("Monkey", "Lion", "Giraffe", "Lemur");

四、将集合类对象转换为管道流

通过调用集合类的stream()方法，将集合类对象转换为管道流。

List<String> list = Arrays.asList("Monkey", "Lion", "Giraffe", "Lemur");
Stream<String> streamFromList = list.stream();

Set<String> set = new HashSet<>(list);
Stream<String> streamFromSet = set.stream();

五、将文本文件转换为管道流

通过Files.lines方法将文本文件转换为管道流，下图中的Paths.get()方法作用就是获取文件，是Java NIO的API！

也就是说：我们可以很方便的使用Java Stream加载文本文件，然后逐行的对文件内容进行处理。

Stream<String> lines = Files.lines(Paths.get("file.txt"));

2.Stream的filter与谓语逻辑

一、基础代码准备

建立一个实体类，该实体类有五个属性。

@Data
@AllArgsConstructor
public class Employee {

   private Integer id;
   private Integer age;   //年龄
   private String gender;  //性别
   private String firstName;  
   private String lastName;
}

写一个测试类，新建十个Employee 对象

public class StreamFilterPredicate {
    
    public static void main(String[] args){
        Employee e1 = new Employee(1,23,"M","Rick","Beethovan");
        Employee e2 = new Employee(2,13,"F","Martina","Hengis");
        Employee e3 = new Employee(3,43,"M","Ricky","Martin");
        Employee e4 = new Employee(4,26,"M","Jon","Lowman");
        Employee e5 = new Employee(5,19,"F","Cristine","Maria");
        Employee e6 = new Employee(6,15,"M","David","Feezor");
        Employee e7 = new Employee(7,68,"F","Melissa","Roy");
        Employee e8 = new Employee(8,79,"M","Alex","Gussin");
        Employee e9 = new Employee(9,15,"F","Neetu","Singh");
        Employee e10 = new Employee(10,45,"M","Naveen","Jain");


        List<Employee> employees = Arrays.asList(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10);

        List<Employee> filtered = employees.stream()
                .filter(e -> e.getAge() > 70 && e.getGender().equals("M"))
                .collect(Collectors.toList());

        System.out.println(filtered);

    }

}

需要注意的是上面的filter传入了lambda表达式，表达过滤年龄大于70并且男性的Employee员工。输出如下：

[Employee(id=8, age=79, gender=M, firstName=Alex, lastName=Gussin)]

二、什么是谓词逻辑？

我们知道lambda表达式表达的是一个匿名接口函数的实现。那具体到Stream.filter()中，它表达的是什么呢？看下代码：可以看出它表达的是一个Predicate接口，在英语中这个单词的意思是：谓词。也被称为断言式接口。

Stream<T> filter(Predicate<? super T> predicate);

什么是谓词？

谓语是对主语的陈述或说明,指出“做什么”、“是什么”或“怎么样.

什么是谓词逻辑？

WHERE 和 AND 限定了主语employee是什么，那么WHERE和AND语句所代表的逻辑就是谓词逻辑

SELECT *
FROM employee
WHERE age > 70
AND gender = 'M'

三、谓词逻辑的复用

通常情况下，filter函数中lambda表达式为一次性使用的谓词逻辑。如果我们的谓词逻辑需要被多处、多场景、多代码中使用，通常将它抽取出来单独定义到它所限定的主语实体中。
比如：将下面的谓词逻辑定义在Employee实体class中。

   public static Predicate<Employee> ageGreaterThan70 = x -> x.getAge() >70;
   public static Predicate<Employee> genderM = x -> x.getGender().equals("M");

2.1.and语法（并集）

List<Employee> filtered = employees.stream()
        .filter(Employee.ageGreaterThan70.and(Employee.genderM))
        .collect(Collectors.toList());

输出如下：

[Employee(id=8, age=79, gender=M, firstName=Alex, lastName=Gussin)]

2.2.or语法（交集）

List<Employee> filtered = employees.stream()
        .filter(Employee.ageGreaterThan70.or(Employee.genderM))
        .collect(Collectors.toList());

输出如下：实际上就是年龄大于70的或者性别是男性

[Employee(id=1, age=23, gender=M, firstName=Rick, lastName=Beethovan), Employee(id=3, age=43, gender=M, firstName=Ricky, lastName=Martin), Employee(id=4, age=26, gender=M, firstName=Jon, lastName=Lowman), Employee(id=6, age=15, gender=M, firstName=David, lastName=Feezor), Employee(id=8, age=79, gender=M, firstName=Alex, lastName=Gussin), Employee(id=10, age=45, gender=M, firstName=Naveen, lastName=Jain)]

2.3.negate语法（取反）

List<Employee> filtered = employees.stream()
        .filter(Employee.ageGreaterThan70.or(Employee.genderM).negate())
        .collect(Collectors.toList());

输出如下：把上一小节代码的结果取反，实际上就是所有的女性

[Employee(id=2, age=13, gender=F, firstName=Martina, lastName=Hengis), Employee(id=5, age=19, gender=F, firstName=Cristine, lastName=Maria), Employee(id=7, age=68, gender=F, firstName=Melissa, lastName=Roy), Employee(id=9, age=15, gender=F, firstName=Neetu, lastName=Singh)]

3.Stream管道流的map操作

一、回顾Stream管道流map的基础用法

最简单的需求：将集合中的每一个字符串，全部转换成大写！

List<String> alpha = Arrays.asList("Monkey", "Lion", "Giraffe", "Lemur");

//不使用Stream管道流
List<String> alphaUpper = new ArrayList<>();
for (String s : alpha) {
    alphaUpper.add(s.toUpperCase());
}
System.out.println(alphaUpper); //[MONKEY, LION, GIRAFFE, LEMUR]

// 使用Stream管道流
List<String> collect = alpha.stream().map(String::toUpperCase).collect(Collectors.toList());
//上面使用了方法引用，和下面的lambda表达式语法效果是一样的
//List<String> collect = alpha.stream().map(s -> s.toUpperCase()).collect(Collectors.toList());

System.out.println(collect); //[MONKEY, LION, GIRAFFE, LEMUR]

所以map函数的作用就是针对管道流中的每一个数据元素进行转换操作。
Steam的学习

二、处理非字符串类型集合元素

map()函数不仅可以处理数据，还可以转换数据的类型。如下：

List<Integer> lengths = alpha.stream()
        .map(String::length)
        .collect(Collectors.toList());

System.out.println(lengths); //[6, 4, 7, 5]

Stream.of("Monkey", "Lion", "Giraffe", "Lemur")
        .mapToInt(String::length)
        .forEach(System.out::println);

输出如下：

除了mapToInt。还有maoToLong，mapToDouble等等用法

三、再复杂一点：处理对象数据格式转换

还是使用Employee类，创建10个对象。需求如下

将每一个Employee的年龄增加一岁
将性别中的“M”换成“male”，F换成Female。

public static void main(String[] args){
    Employee e1 = new Employee(1,23,"M","Rick","Beethovan");
    Employee e2 = new Employee(2,13,"F","Martina","Hengis");
    Employee e3 = new Employee(3,43,"M","Ricky","Martin");
    Employee e4 = new Employee(4,26,"M","Jon","Lowman");
    Employee e5 = new Employee(5,19,"F","Cristine","Maria");
    Employee e6 = new Employee(6,15,"M","David","Feezor");
    Employee e7 = new Employee(7,68,"F","Melissa","Roy");
    Employee e8 = new Employee(8,79,"M","Alex","Gussin");
    Employee e9 = new Employee(9,15,"F","Neetu","Singh");
    Employee e10 = new Employee(10,45,"M","Naveen","Jain");


    List<Employee> employees = Arrays.asList(e1, e2, e3, e4, e5, e6, e7, e8, e9, e10);

    /*List<Employee> maped = employees.stream()
            .map(e -> {
                e.setAge(e.getAge() + 1);
                e.setGender(e.getGender().equals("M")?"male":"female");
                return e;
            }).collect(Collectors.toList());*/

    List<Employee> maped = employees.stream()
            .peek(e -> {
                e.setAge(e.getAge() + 1);
                e.setGender(e.getGender().equals("M")?"male":"female");
            }).collect(Collectors.toList());

    System.out.println(maped);

}

由于map的参数e就是返回值，所以可以用peek函数。peek函数是一种特殊的map函数，当函数没有返回值或者参数就是返回值的时候可以使用peek函数。

四、flatMap

map可以对管道流中的数据进行转换操作，但是如果管道中还有管道该如何处理？即：如何处理二维数组及二维集合类。实现一个简单的需求：将“hello”，“world”两个字符串组成的集合，元素的每一个字母打印出来。如果不用Stream我们怎么写？写2层for循环,第一层遍历字符串，并且将字符串拆分成char数组，第二层for循环遍历char数组。

List<String> words = Arrays.asList("hello", "word");
words.stream()
        .map(w -> Arrays.stream(w.split("")))    //[[h,e,l,l,o],[w,o,r,l,d]]
        .forEach(System.out::println);

输出打印结果：

aaa@qq.com
aaa@qq.com

用map方法是做不到的，这个需求用map方法无法实现。map只能针对一维数组进行操作，数组里面还有数组，管道里面还有管道，它是处理不了每一个元素的。
Steam的学习

flatMap可以理解为将若干个子管道中的数据全都，平面展开到父管道中进行处理。
Steam的学习

words.stream()
        .flatMap(w -> Arrays.stream(w.split(""))) // [h,e,l,l,o,w,o,r,l,d]
        .forEach(System.out::println);

输出打印结果：

h
e
l
l
o
w
o
r
d

4.Stream的状态与并行操作

一、回顾Stream管道流操作

Steam的学习

Stream管道流的基本操作:

源操作：可以将数组、集合类、行文本文件转换成管道流Stream进行数据处理
中间操作：对Stream流中的数据进行处理，比如：过滤、数据转换等等
终端操作：作用就是将Stream管道流转换为其他的数据类型。

看下面的脑图，可以有更清晰的理解：
Steam的学习

二、中间操作：有状态与无状态

其实在程序员编程中，经常会接触到“有状态”，“无状态”，绝大部分的人都比较蒙。而且在不同的场景下，“状态”这个词的含义似乎有所不同。但是“万变不离其宗”，理解“状态”这个词在编程领域的含义

状态通常代表公用数据，有状态就是有“公用数据”
因为有公用的数据，状态通常需要额外的存储。
状态通常被多人、多用户、多线程、多次操作，这就涉及到状态的管理及变更操作。

是不是更蒙了？举个例子，你就明白了

web开发session就是一种状态，访问者的多次请求关联同一个session，这个session需要存储到内存或者redis。多次请求使用同一个公用的session，这个session就是状态数据。
vue的vuex的store就是一种状态，首先它是多组件公用的，其次是不同的组件都可以修改它，最后它需要独立于组件单独存储。所以store就是一种状态。

回到我们的Stream管道流

filter与map操作，不需要管道流的前面后面元素相关，所以不需要额外的记录元素之间的关系。输入一个元素，获得一个结果。
sorted是排序操作、distinct是去重操作。像这种操作都是和别的元素相关的操作，我自己无法完成整体操作。就像班级点名就是无状态的，喊到你你就答到就可以了。如果是班级同学按大小个排序，那就不是你自己的事了，你得和周围的同学比一下身高并记住，你记住的这个身高比较结果就是一种“状态”。所以这种操作就是有状态操作。

三、Limit与Skip管道数据截取

List<String> limitN = Stream.of("Monkey", "Lion", "Giraffe", "Lemur")
        .limit(2)
        .collect(Collectors.toList());
List<String> skipN = Stream.of("Monkey", "Lion", "Giraffe", "Lemur")
        .skip(2)
        .collect(Collectors.toList());

limt方法传入一个整数n，用于截取管道中的前n个元素。经过管道处理之后的数据是：[Monkey, Lion]。
skip方法与limit方法的使用相反，用于跳过前n个元素，截取从n到末尾的元素。经过管道处理之后的数据是： [Giraffe, Lemur]

四、Distinct元素去重

我们还可以使用distinct方法对管道中的元素去重，涉及到去重就一定涉及到元素之间的比较，distinct方法时调用Object的equals方法进行对象的比较的，如果你有自己的比较规则，可以重写equals方法。

List<String> uniqueAnimals = Stream.of("Monkey", "Lion", "Giraffe", "Lemur", "Lion")
        .distinct()
        .collect(Collectors.toList());

五、Sorted排序

默认的情况下，sorted是按照字母的自然顺序进行排序。如下代码的排序结果是：[Giraffe, Lemur, Lion, Monkey]，字数按顺序G在L前面，L在M前面。第一位无法区分顺序，就比较第二位字母。

List<String> alphabeticOrder = Stream.of("Monkey", "Lion", "Giraffe", "Lemur")
        .sorted()
        .collect(Collectors.toList());

六、串行、并行与顺序

通常情况下，有状态和无状态操作不需要我们去关心。除非？：你使用了并行操作。

还是用班级按身高排队为例：班级有一个人负责排序，这个排序结果最后就会是正确的。那如果有2个、3个人负责按大小个排队呢？最后可能就乱套了。一个人只能保证自己排序的人的顺序，他无法保证其他人的排队顺序。

串行的好处是可以保证顺序，但是通常情况下处理速度慢一些
并行的好处是对于元素的处理速度快一些（通常情况下），但是顺序无法保证。这可能会导致进行一些有状态操作的时候，最后得到的不是你想要的结果。

Stream.of("Monkey", "Lion", "Giraffe", "Lemur", "Lion")
        .parallel()
        .forEach(System.out::println);

parallel()函数表示对管道中的元素进行并行处理，而不是串行处理。但是这样就有可能导致管道流中后面的元素先处理，前面的元素后处理，也就是元素的顺序无法保证。
如果数据量比较小的情况下，不太能观察到，数据量大的话，就能观察到数据顺序是无法保证的。

通常情况下，parallel()能够很好的利用CPU的多核处理器，达到更好的执行效率和性能，建议使用。但是有些特殊的情况下，parallel并不适合

该文章中几个观点，说明并行操作的适用场景：

数据源易拆分：从处理性能的角度，parallel()更适合处理ArrayList，而不是LinkedList。因为ArrayList从数据结构上讲是基于数组的，可以根据索引很容易的拆分为多个。
适用于无状态操作：每个元素的计算都不得依赖或影响任何其他元素的计算，的运算场景。
基础数据源无变化：从文本文件里面边读边处理的场景，不适合parallel()并行处理。parallel()一开始就容量固定的集合，这样能够平均的拆分、同步处理。

，而不是串行处理。但是这样就有可能导致管道流中后面的元素先处理，前面的元素后处理，也就是元素的顺序无法保证。

如果数据量比较小的情况下，不太能观察到，数据量大的话，就能观察到数据顺序是无法保证的。

通常情况下，parallel()能够很好的利用CPU的多核处理器，达到更好的执行效率和性能，建议使用。但是有些特殊的情况下，parallel并不适合

该文章中几个观点，说明并行操作的适用场景：

数据源易拆分：从处理性能的角度，parallel()更适合处理ArrayList，而不是LinkedList。因为ArrayList从数据结构上讲是基于数组的，可以根据索引很容易的拆分为多个。
适用于无状态操作：每个元素的计算都不得依赖或影响任何其他元素的计算，的运算场景。
基础数据源无变化：从文本文件里面边读边处理的场景，不适合parallel()并行处理。parallel()一开始就容量固定的集合，这样能够平均的拆分、同步处理。

Steam的学习

1.Stream介绍

一、什么是Java Stream API？

二、Stream API代替for循环

三、将数组转换为管道流

四、将集合类对象转换为管道流

五、将文本文件转换为管道流

2.Stream的filter与谓语逻辑

一、基础代码准备

二、什么是谓词逻辑？

什么是谓词？

什么是谓词逻辑？

三、谓词逻辑的复用

2.1.and语法（并集）

2.2.or语法（交集）

2.3.negate语法（取反）

3.Stream管道流的map操作

一、回顾Stream管道流map的基础用法

二、处理非字符串类型集合元素

三、再复杂一点：处理对象数据格式转换

四、flatMap

4.Stream的状态与并行操作

一、回顾Stream管道流操作

二、中间操作：有状态与无状态

三、Limit与Skip管道数据截取

四、Distinct元素去重

五、Sorted排序

六、串行、并行与顺序

微软确认：新一代Windows已经在来的路上！

Checbox的操作含已选、未选及判断代码

谷歌Pixel 4a真机照曝光：颜值上佳的单手小屏新机型

潘云鹤：视觉知识是人工智能有待探索的富饶“无人区”

css 透明度完全兼容的写法

2020学生党性价比高的电脑：荣耀上榜，第二适合女生

css 透明度完全兼容的写法

充电速度最快的骁龙888手机！iQOO 7开启预约

百度针对低质量站点风暴后的自省 SEO对号入座话属性

十种手机赚钱的方法：手机也可以直播，游戏陪玩成热门