流式计算

流式计算

不以计算机的时间去模拟现实世界的时间，而是采用一种类似延迟计算的方式来实现模拟现实世界。即，使用你操作的时间来模拟时间的流动。

下面根据IntStream的示例操作，构建了属于自己的IntegerStream模拟一下流的计算。

package stream;

import java.util.OptionalInt;
import java.util.function.IntPredicate;

public class IntegerStream {
    IntPredicate predicate;
    Range range;

    /**
     * 创建一个范围内的流
     * @param start 起始
     * @param end 结束
     * @return 返回对象
     */
    public static IntegerStream rangeClosed(int start, int end) {
        IntegerStream res = new IntegerStream();
        res.range = new Range(start, end);
        return res;
    }

    /**
     * 通过一定条件过滤
     * @param predicate 需要预测的条件
     * @return 返回对象，并不计算，延迟计算
     */
    public IntegerStream filter(IntPredicate predicate) {
        this.predicate = predicate;
        return this;
    }

    /**
     * 跳过几个元素，重新构建流
     * @param num 跳过的数量
     * @return 跳过之后的流，属于中间计算
     */
    public IntegerStream skip(int num) {
        // 获取值
        OptionalInt v = range.getValue();
        // 如果有的话
        if (v.isPresent()) {
            // 循环num次，去掉前n个值
            for (int i = 0; i < num; i++) {
                findAny();
                range.increment();
            }
            // 重新构建流
            return IntegerStream.rangeClosed(range.getValue().getAsInt(), range.end)
                    .filter(this.predicate);
        }

        throw new RuntimeException("没有符合条件的元素");
    }

    /**
     * 找到任何符合条件的结果
     * @return 封装后的结果对象
     */
    public OptionalInt findAny() {
        // 获取当前值
        OptionalInt v = range.getValue();

        // 有值
        while (v.isPresent()) {
            // 符合条件的话，直接返回
            if (predicate.test(v.getAsInt())) {
                return v;
            }
            // 自增
            range.increment();
            // 获取最新值
            v = range.getValue();
        }

        return OptionalInt.empty();
    }

    public static void main(String[] args) {
        IntegerStream intStream = IntegerStream.rangeClosed(10_000, 1_000_000);
        IntPredicate predicate = i -> i % 2 != 0;

        OptionalInt first = intStream.filter(predicate)
                .skip(3)
                .findAny();

        System.out.println(first.isPresent()? first.getAsInt(): null);
    }

    static class Range {
        private int begin;
        private int end;
        private int step;

        public Range(int begin, int end, int step) {
            this.begin = begin;
            this.end = end;
            this.step = step;
        }

        public Range(int begin, int end) {
            this(begin, end, 1);
        }

        OptionalInt getValue() {
            if (begin > end) {
                return OptionalInt.empty();
            }

            return OptionalInt.of(begin);
        }

        void increment() {
            begin++;
        }
    }
}