展开目录 返回顶部 到达底部

Java8特性2 - StreamApi

Author: Date: 2020-11-15  13:56:21 Category: Java Words:2,381 Times:11min User:

Stream

  • Stream API 关注对数据的运算，属于CPU密集型
  • Collections 关注对数据的存储，属于IO密集型

Stream 自己本身不存储元素
Stream 不会改变元对象，但是他会返回一个持有结果的新Stream
Stream 操作是延时执行的，意味着需要结果时才执行

Stream执行流程

1
执行流程： 实例化 ==> 中间操作 ==> 终止操作

中间操作往往是一个操作链
一旦终止操作，就开始执行中间操作链，并产生结果。【延时执行，终止操作触发执行】

准备数据

为了测试方便，这里写一个学生工具类StudentData.java，用来获取测试数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
public class StudentData {
    public static List<Student> getList(){
        List<Student> list = new ArrayList<>();
        list.add(new Student(1001,"张三",34,50000));
        list.add(new Student(1002,"李四",19,3000));
        list.add(new Student(1003,"王五",14,600));
        list.add(new Student(1004,"赵六",42,30000));
        list.add(new Student(1005,"李明",22,6000));
        list.add(new Student(1006,"张华",32,40000));
        list.add(new Student(1007,"李华",30,9000));
        list.add(new Student(1008,"王二",28,12000));
        return list;
    }
}

class Student{
    private Integer id;
    private String name;
    private Integer age;
    private float salary;

    public Student(Integer id, String name, Integer age, float salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public Integer getId() {
        return id;
    }

    public Student setId(Integer id) {
        this.id = id;
        return this;
    }

    public String getName() {
        return name;
    }

    public Student setName(String name) {
        this.name = name;
        return this;
    }

    public Integer getAge() {
        return age;
    }

    public Student setAge(Integer age) {
        this.age = age;
        return this;
    }

    public float getSalary() {
        return salary;
    }

    public Student setSalary(float salary) {
        this.salary = salary;
        return this;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Float.compare(student.salary, salary) == 0 &&
                Objects.equals(id, student.id) &&
                Objects.equals(name, student.name) &&
                Objects.equals(age, student.age);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name, age, salary);
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                '}';
    }
}

Stream实例化

  • 通过集合
  • 通过数组
  • Stream.of()
  • Stream.iterate() 迭代创建
  • Stream.generate() 生成创建

通过集合创建流

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
List<Student> list = StudentData.getList();
/**
 * 创建一个顺序流（按流的顺序进行中间操作）
 * default Stream<E> stream()
 * {@link Collection#stream()}
 */
Stream<Student> stream = list.stream();



/**
 * 创建一个并行流（并行进行中间操作，无顺序）
 * default Stream<E> parallelStream()
 * {@link Collection#parallelStream()}
 */
Stream<Student> studentStream = list.parallelStream();

通过数组创建流

1
2
3
4
5
int[] arr = new int[]{1,2,3,4,5};
IntStream stream = Arrays.stream(arr);

Student[] students = {new Student(1,"zhang3",15,2000),new Student(2,"li4",25,3000)};
Stream<Student> stream1 = Arrays.stream(students);

通过Stream.of(T t)创建流

1
Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);

通过Stream.generate()生成流

1
2
//生成十个随机数
Stream.generate(Math::random).limit(10).forEach(System.out::println);

为了展示效果，这里用到了终止操作forEach(Consumer c),来打印生成的流，输出如下：

1
2
3
4
5
6
7
8
9
10
0.4110376914730558
0.3859646598602653
0.6615549365050744
0.5086477303367989
0.2614939389108638
0.4766495481509283
0.4378851389809656
0.018579677210072254
0.5217833438932207
0.44390638190496046

通过Stream.iterate()创建流

1
2
//创建前10个偶数
Stream.iterate(0,t->t+2).limit(10).forEach(System.out::println);

输出如下：

1
2
3
4
5
6
7
8
9
10
0
2
4
6
8
10
12
14
16
18

Stream中间操作

  • 1、筛选与切片 filter、limit、skip、distinct
  • 2、映射 map、mapToDouble、mapToInt、mapToLong、flatMap
  • 3、排序 sorted()、sorted(Comparator c)

筛选与切片

筛选流filter

从流中筛选需要的元素

1
2
3
4
List<Student> list = StudentData.getList();
Stream<Student> stream = list.stream();
//filter 筛选出年龄大于40的学生
stream.filter(s -> s.getAge() > 40).forEach(System.out::println);

输出结果如下：

1
Student{id=1004, name='赵六', age=42, salary=30000.0}

截断流limit

从stream中获取指定大小的stream，可以类比sql中的LIMIT

1
2
//limit 截断流
list.stream().limit(4).forEach(System.out::println);

输出如下：

1
2
3
Student{id=1001, name='张三', age=34, salary=50000.0}
Student{id=1002, name='李四', age=19, salary=3000.0}
Student{id=1003, name='王五', age=14, salary=600.0}

跳过元素skip

从stream中跳过指定个数后获取stream

1
2
//skip 跳过2个元素后截取1个元素
list.stream().skip(2).limit(1).forEach(System.out::println);

输出结果如下：

1
Student{id=1003, name='王五', age=14, salary=600.0}

**注意：**当跳过的个数超过stream中元素个数，返回空流

1
2
/*此时的list.stream()中只有8个元素，直接跳过30个元素*/
list.stream().skip(30).forEach(System.out::println);

执行此代码无任何输出，因为此时生成的流为空

去重distinct

去重，根据stream中元素自己的hashcode()和equals()进行判断，效果可以类比sql中的DISTINCT

1
2
3
4
//distinct 可以看到list中有两个Tony老师，出现重复
list.add(new Student(1009, "Tony", 18, 50000));
list.add(new Student(1009, "Tony", 18, 50000));
list.stream().distinct().forEach(System.out::println);

输出结果

1
2
3
4
5
6
7
8
9
Student{id=1001, name='张三', age=34, salary=50000.0}
Student{id=1002, name='李四', age=19, salary=3000.0}
Student{id=1003, name='王五', age=14, salary=600.0}
Student{id=1004, name='赵六', age=42, salary=30000.0}
Student{id=1005, name='李明', age=22, salary=6000.0}
Student{id=1006, name='张华', age=32, salary=40000.0}
Student{id=1007, name='李华', age=30, salary=9000.0}
Student{id=1008, name='王二', age=28, salary=12000.0}
Student{id=1009, name='Tony', age=18, salary=50000.0}

去重后仅保留一个Tony对象

映射

映射就是 a -> b 的过程，比如把水放进冰箱一段时间就会变成冰块，把水果放进榨汁机榨汁就会变成果汁等等，这些都是映射，只不过他们的映射规则不同。

在Stream中映射有两种

  • map(Function f)
  • flatMap(Function f)

map(Function f)

1
2
将一个流中元素转换成其他形式，或者提取其中信息，最终产生一个新的流
其中这个Function就是映射规则，该函数会被应用到流中每一个元素上，并将其映射成一个新的元素

举个例子说明下：

**信息提取：**提取流中前3个元素的姓名属性, 映射成新的元素，最终生成一个新的流，

为了好理解，这里用了终止操作forEach(),并将Stream实例化、中间操作、终止操作分开写。

1
2
3
4
//Stream<Student> --------> Stream<String>
Stream<Student> stream = list.stream();
Stream<String> limit = stream.map(Student::getName).limit(3);
limit.forEach(System.out::println);

输出信息为：

1
2
3
张三
李四
王五

可以看到经过了map，原本的Student流最终映射为String流

再举个例子：

**格式转换：**截取流中前三个元素的姓名和年龄，产生一个新的字符串，格式为姓名:年龄，以次产生一个新的流

1
2
3
4
//Stream<Student> --------> Stream<String>
Stream<Student> stream1 = list.stream();
Stream<String> limit1 = stream1.map(student -> student.getName() + " : " + student.getAge()).limit(3);
limit1.forEach(System.out::println);

打印结果如下：

1
2
3
张三 : 34
李四 : 19
王五 : 14

可以看到了，通过map，将Student流映射成指定格式的String流

FlatMap(Function f)

1
接收一个函数作为映射规则，该函数把流中的每个元素都转换成一个新的流，最后再把这些流连接成一个流

说人话就是，flatmap会把每一个元素都映射成一个流，最终把多个流整合成一个流

举个例子

将这个字符串数组创建的Stream中的每个元素都用,分割后生成一个流，最终整合为一个完整的流

1
2
String[] strings = {"a","b,c,d","A,B"};
Stream.of(strings).flatMap((s)->Stream.of(s.split(","))).forEach(System.out::println);

输出结果：

1
2
3
4
5
6
a
b
c
d
A
B

map与flatmap的区别

可能你觉得map与flatmap好像没啥区别，都是在映射，都是把一个流变成另一个流

但其实大有不同！！！

  • 注意他们的参数Function
  • map是对每个元素进行映射，把所有映射后元素转为一个新的流
  • flatmap是对每个元素进行映射后，每个元素都转变成一个流，最终把产生的多个流整合为一个流

先看两个Api的参数

1
2
3
4
5
//map
<R> Stream<R> map(Function<? super T, ? extends R> mapper);

//flatMap
<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);

很明显flatMap的返回值R是Stream类型，这正对应了之前说的flatMap会把每个元素转换成Stream

如果把上一个例子中的flatmap换成map，试试会如何

1
2
String[] strings = {"a","b,c,d","A,B"};
Stream.of(strings).map((s)->Stream.of(s.split(","))).forEach(System.out::println);

输出结果：

1
2
3
java.util.stream.ReferencePipeline$Head@1963006a
java.util.stream.ReferencePipeline$Head@7fbe847c
java.util.stream.ReferencePipeline$Head@41975e01

打印了3个对象，说明使用了map之后，最终生成的流中的3个元素都是流，并没有像flatmap进行整合操作

简单的总结下就如下：

1
2
map: 1个流 ----> 1个流
flatmap: 1个流 ----> n个流 ----> 1个流

排序

Stream中间操作中有两种排序

  • sorted()
  • sorted(Comparator c)

sorted()自然排序

1
2
3
//sorted() 自然排序
IntStream sorted = Arrays.stream(new int[]{1, 20, 3, 99,11}).sorted();
sorted.forEach(System.out::println);

输出结果

1
2
3
4
5
1
3
11
20
99

sorted(Comparator c)

自定义排序，参数即为排序规则

1
2
3
4
5
//根据对象中的年龄属性排序
List<Student> list = StudentData.getList();
list.stream()
    .sorted((s1,s2)>Integer.compare(s1.getAge(),s2.getAge()))
    .limit(3).forEach(System.out::println);

输出结果

1
2
3
Student{id=1003, name='王五', age=14, salary=600.0}
Student{id=1002, name='李四', age=19, salary=3000.0}
Student{id=1005, name='李明', age=22, salary=6000.0}
---------- 😏本文结束  感谢您的阅读😏 ----------
标签: Java
返回    /   首页
评论