1‐流的定义
在其他所有语言里你能见到的流的实现，本质上都是一元流。二元流、三元流是本框架独一无二的特性。它们在本质都是一个consumer of callback，根据consumer的参数个数不同，流可以自然的分为一元，二元，以及理论上任意正整数维度的多元。
public interface Seq<T> {
void consume(Consumer<T> consumer);
}二元流天生对应Map，有许多衍生特性
public interface Seq2<K, V> {
void consume(BiConsumer<K, V> consumer);
}本项目最高实现到三元流，使用场景比较少
public interface Seq3<A, B, C> {
void consume(Consumer3<A, B, C> consumer);
}
public interface Consumer3<A, B, C> {
void accept(A a, B b, C c);
}在定义了一元流、二元流的基础上，可以进一步推导出许多衍生的接口或实现，这些衍生类型能与Java原生数据结构进行完美的融合，为它们赋予强大的流式特性。
上图为Seq相关衍生类型的继承关系图，椭圆为interface，方形为class，具体介绍见下文
可迭代流，既是Iterable，也是Seq，并提供一个额外的默认zip方法
public interface ItrSeq<T> extends Iterable<T>, Seq<T> {
// (1, 2, 3, 4) -> zip(0) -> (1, 0, 2, 0, 3, 0, 4, 0)
default ItrSeq<T> zip(T t) {...}
}可数流，在ItrSeq基础上更进一步，同时提供size和isEmpty方法，以及默认的isNotEmpty方法，可以直接对应Collection，后面的众多衍生实现类都直接继承SizedSeq。
public interface SizedSeq<T> extends ItrSeq<T> {
// (1, 2, 3, 4) -> size() -> 4
int size();
// (1, 2, 3, 4) -> isEmpty() -> false
boolean isEmpty();
// (1, 2, 3, 4) -> isNotEmpty() -> true
default boolean isNotEmpty() {...}
}既是List也是SizedSeq，是对JDK原生List的极大扩展
public interface SeqList<T> extends SizedSeq<T>, List<T> {}既是Set也是SizedSeq，是对JDK原生Set的极大扩展
public interface SeqSet<T> extends SizedSeq<T>, Set<T> {}既是Queue也是SizedSeq，是对JDK原生Queue的极大扩展
public interface SeqQueue<T> extends SizedSeq<T>, Queue<T> {}JDK内置ArrayList的流式扩展，自带它的全部方法和功能，同时也是个SizedSeq。除了能提供全部流式特性外，还可以添加一些额外方法
两两元素交换
// [1, 2, 3, 4] -> swap(1, 2) -> (1, 3, 2, 4)
public void swap(int i, int j) {...}全排列，参数inplace代表是否原位修改
// [1, 2, 3] -> permute(false) -> ([1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1])
public Seq<ArraySeq<T>> permute(boolean inplace) {...}JDK内置LinkedList的流式扩展
public class LinkedSeq<T> extends LinkedList<T> implements SeqList<T>, SeqQueue<T> {...}JDK内置LinkedHashSet的流式扩展
用于toSet, distinct
public class LinkedSeqSet<T> extends LinkedHashSet<T> implements SeqSet<T> {...}JDK内置ConcurrentLinkedQueue的流式扩展，用于在多线程环境下进行聚合操作
用于toConcurrent
public class ConcurrentSeq<T> extends ConcurrentLinkedQueue<T> implements SizedSeq<T> {...}除了可以利用上述的JDK原生集合类型的扩展，很多时候用户拿到的已经是一个现成的List或者Set了，这种情况，将它们变成流式API的最佳办法并不是创建一个新的Seq，而是使用代理
// SeqCollection
static <T> SeqCollection<T> of(Collection<T> collection) {...}
// SeqList
static <T> SeqList<T> of(List<T> list) {...}
// SeqQueue
static <T> SeqQueue<T> of(Queue<T> queue) {...}
// SeqSet
static <T> SeqSet<T> of(Set<T> set) {...}既是Map也是Seq2，是对JDK原生Map的极大扩展
public interface SeqMap<K, V> extends Seq2<K, V>, Map<K, V> {...}除了Seq2自带的流式API外，SeqMap还有以下许多额外的扩展方法
类似于Map自带的keySet但返回一个SeqSet
SeqSet<K> seqKeySet();类似于Map自带的values但返回一个SeqCollection
SeqCollection<V> seqValues();类似于Map自带的entrySet但返回一个SeqSet
SeqSet<Entry<K, V>> seqEntrySet();替换当前的keys，得到一个新的SeqMap
// 由key和value共同映射
default <E> SeqMap<E, V> mapByKey(BiFunction<K, V, E> function) {...}
// 由key单独映射
default <E> SeqMap<E, V> mapByKey(Function<K, E> function) {...}替换当前的values，得到一个新的SeqMap
// 由key和value共同映射
default <E> SeqMap<K, E> mapByValue(BiFunction<K, V, E> function) {...}
// 由value单独映射
default <E> SeqMap<K, E> mapByValue(Function<V, E> function) {...}和mapByValue类似，但在原SeqMap上原位替换value，不会产生新的SeqMap对象，需慎用
default <E> SeqMap<K, E> replaceValue(BiFunction<K, V, E> function) {...}
default <E> SeqMap<K, E> replaceValue(Function<V, E> function) {...}可以对Map直接进行排序，得到ArraySeq<Entry>
default <E extends Comparable<E>> ArraySeq<Entry<K, V>> sort(BiFunction<K, V, E> function) {...}
default <E extends Comparable<E>> ArraySeq<Entry<K, V>> sortDesc(BiFunction<K, V, E> function) {...}也可以方便的直接针对key或value进行排序
default ArraySeq<Entry<K, V>> sortByKey(Comparator<K> comparator) {...}
default ArraySeq<Entry<K, V>> sortByValue(Comparator<V> comparator) {...}
default ArraySeq<Entry<K, V>> sortDescByKey(Comparator<K> comparator) {...}
default ArraySeq<Entry<K, V>> sortDescByValue(Comparator<V> comparator) {...}既是LinkedHashMap也是SeqMap，继承前者的主要构造方法
public class LinkedSeqMap<K, V> extends LinkedHashMap<K, V> implements SeqMap<K, V> {...}