package stream;

import function.*;

/**

* @Author xiongyx

* on 2019/3/5.

*

* 流的接口

*/

public interface Stream<T> {

/**

* 映射 lazy 惰性求值

* @param mapper 转换逻辑 T->R

* @return 一个新的流

* */

<R> MyStream<R> map(Function<R,T> mapper);

/**

* 扁平化 映射 lazy 惰性求值

* @param mapper 转换逻辑 T->MyStream<R>

* @return 一个新的流(扁平化之后)

* */

<R> MyStream<R> flatMap(Function<? extends MyStream<R>, T> mapper);

/**

* 过滤 lazy 惰性求值

* @param predicate 谓词判断

* @return 一个新的流，其中元素是满足predicate条件的

* */

MyStream<T> filter(Predicate<T> predicate);

/**

* 截断 lazy 惰性求值

* @param n 截断流，只获取部分

* @return 一个新的流，其中的元素不超过 n

* */

MyStream<T> limit(int n);

/**

* 去重操作 lazy 惰性求值

* @return 一个新的流，其中的元素不重复(!equals）

* */

MyStream<T> distinct();

/**

* 窥视 lazy 惰性求值

* @return 一个新的流，其中的元素不重复(!equals）

* */

MyStream<T> peek(ForEach<T> consumer);

/**

* 遍历 eval 强制求值

* @param consumer 遍历逻辑

* */

void forEach(ForEach<T> consumer);

/**

* 浓缩 eval 强制求值

* @param initVal 浓缩时的初始值

* @param accumulator 浓缩时的 累加逻辑

* @return 浓缩之后的结果

* */

<R> R reduce(R initVal, BiFunction<R, R, T> accumulator);

/**

* 收集 eval 强制求值

* @param collector 传入所需的函数组合子，生成高阶函数

* @return 收集之后的结果

* */

<R, A> R collect(Collector<T,A,R> collector);

/**

* 最大值 eval 强制求值

* @param comparator 大小比较逻辑

* @return 流中的最大值

* */

T max(Comparator<T> comparator);

/**

* 最小值 eval 强制求值

* @param comparator 大小比较逻辑

* @return 流中的最小值

* */

T min(Comparator<T> comparator);

/**

* 计数 eval 强制求值

* @return 当前流的个数

* */

int count();

/**

* 流中是否存在满足predicate的项

* @return true 存在 匹配项

* false 不存在 匹配项

* */

boolean anyMatch(Predicate<? super T> predicate);

/**

* 流中的元素是否全部满足predicate

* @return true 全部满足

* false 不全部满足

* */

boolean allMatch(Predicate<? super T> predicate);

/**

* 返回空的 stream

* @return 空stream

* */

static <T> MyStream<T> makeEmptyStream(){

// isEnd = true

return new MyStream.Builder<T>().isEnd(true).build();

}

}