Java8新特性：流式计算

1. 什么是流式计算

大数据的计算模式主要分为：

• 批量计算 (batch computing)
• 流式计算 (stream computing)
• 交互计算 (interactive computing)
• 图计算 (graph computing) 等

其中，流式计算和批量计算是两种主要的大数据计算模式，分别适用于不同的大数据应用场景
流式计算，顾名思义，就是对数据流进行处理，是实时计算

2. Java中对于流式计算的实现

所在包： java.util.stream
应用场景：主要是对 集合数据 进行操作，其很多操作方法和sql的作用和类似
常用的一些方法：

• filter（对数据进行过滤）
• map（对数据进行映射操作）
• limit（限制数据条数）
• count（求取数据量）
• sorted(排序)
• collect (收集集合)

3. 代码演示

package com.xjs.xjsliving;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @Author: 谢家升
 * @Version: 1.0
 * 

 * 演示 Stream API / 流式计算
 */
public class TestStream {
    public static void main(String[] args) {
        //创建5个 Person对象
        Person person1 = new Person(1, "a", 18);
        Person person2 = new Person(2, "b", 12);
        Person person3 = new Person(3, "c", 30);
        Person person4 = new Person(4, "d", 88);
        Person person5 = new Person(5, "e", 22);

        //放入到 list 集合
        List<Person> list = Arrays.asList(person1, person2, person3, person4, person5);
        System.out.println("list= " + list);
        //list= [Person{id=1, name='a', age=18, cat=null}, Person{id=2, name='b', age=12, cat=null}, Person{id=3, name='c', age=30, cat=null}, Person{id=4, name='d', age=88, cat=null}, Person{id=5, name='e', age=22, cat=null}]

        /**
         * 演示 filter
         * 需求：从 list 中过滤出 person.id % 2 != 0 的对象
         *
         * 解读：
         * 1. list.stream() 把 list 转成 流对象，目的是为了使用流的方法 => 这样就可以处理一些比较复杂的业务
         * 2. filter() 传入的是 Predicate -断言 ，要求返回 boolean
         * 3. collect() 传入 Collector 将数据收集到 集合-list2
         * 4. map 操作：希望给 过滤得到的 Person对象 加入 Cat对象
         * 5. sorted 操作 传入 Comparator
         */

        List<Person> list2 = list.stream().filter(person -> {
            return person.getId() % 2 != 0;
        }).map(person -> { //希望给 过滤得到的 Person对象 加入 Cat对象
            Cat cat = new Cat(person.getId() + 100, "小花猫", "花色");
            person.setCat(cat);
            return person;
        }).sorted((p1, p2) -> {
            //return p1.getId() - p2.getId(); //按照 id 升序排列
            //return p2.getId() - p1.getId(); //按照 id 降序排列
            return p2.getAge() - p1.getAge(); //按照 年龄 降序排列
        }).collect(Collectors.toList());

        //细节说明：
        //1. 如果只有 filter ，sorted 操作，不会对原来的 list 产生影响
        //2. 如果有了 map 操作，就会对原来的 list 集合数据产生影响
        System.out.println("list2= " + list2);
        System.out.println("list= " + list);
        //list2= [Person{id=1, name='a', age=18, cat=Cat{id=101, name='小花猫', color='花色'}}, Person{id=3, name='c', age=30, cat=Cat{id=103, name='小花猫', color='花色'}}, Person{id=5, name='e', age=22, cat=Cat{id=105, name='小花猫', color='花色'}}]
        //list= [Person{id=1, name='a', age=18, cat=Cat{id=101, name='小花猫', color='花色'}}, Person{id=2, name='b', age=12, cat=null}, Person{id=3, name='c', age=30, cat=Cat{id=103, name='小花猫', color='花色'}}, Person{id=4, name='d', age=88, cat=null}, Person{id=5, name='e', age=22, cat=Cat{id=105, name='小花猫', color='花色'}}]

        //============ 这里还有几个常用的 Stream API ============
        /**
         * limit 使用
         * 需求：显示 list 集合的前两个
         */
        list.stream().limit(2).forEach(person -> { //遍历输出
            System.out.println(person);
        });

        /**
         * count 使用
         */
        long count = list.stream().count();
        System.out.println("count= " + count); //count= 5

        /**
         * 先 filter 再 count
         */
        long count2 = list.stream().filter(person -> {
            return person.getAge() > 20;
        }).count();
        System.out.println("count2= " + count2); //count= 3

    }
}

//Person类 - entity
class Person {
    private Integer id;
    private String name;
    private Integer age;
    private Cat cat;

    public Person(Integer id, String name, Integer age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public Cat getCat() {
        return cat;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }

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

//猫类
class Cat {
    private Integer id;
    private String name;
    private String color;

    public Cat(Integer id, String name, String color) {
        this.id = id;
        this.name = name;
        this.color = color;
    }

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", color='" + color + '\'' +
                '}';
    }
}
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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185

4. Java中对于流式计算的实现的本质

按照流式计算的定义，其实我们普通的编程操作 (即普通的对数据的处理也是流式计算)，只是语言对这样的操作进行了封装，使其用起来更为简便，所以才特意称其这一部分为 “Java中对于流式计算的实现”