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
 * <p>
 * 演示 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 + '\'' +
                '}';
    }
}

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

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