Skip to content

1‐流的定义

Jump to bottom
wolray edited this page Oct 11, 2023 · 3 revisions

定义

一元流

在其他所有语言里你能见到的流的实现，本质上都是一元流。二元流、三元流是本框架独一无二的特性。它们在本质都是一个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-classes

上图为Seq相关衍生类型的继承关系图，椭圆为interface，方形为class，具体介绍见下文

衍生接口

ItrSeq

可迭代流，既是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) {...}
}

SizedSeq

可数流，在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() {...}
}

SeqList

既是List也是SizedSeq，是对JDK原生List的极大扩展

public interface SeqList<T> extends SizedSeq<T>, List<T> {}

SeqSet

既是Set也是SizedSeq，是对JDK原生Set的极大扩展

public interface SeqSet<T> extends SizedSeq<T>, Set<T> {}

SeqQueue

既是Queue也是SizedSeq，是对JDK原生Queue的极大扩展

public interface SeqQueue<T> extends SizedSeq<T>, Queue<T> {}

JDK集合类的流式扩展

ArraySeq

JDK内置ArrayList的流式扩展，自带它的全部方法和功能，同时也是个SizedSeq。除了能提供全部流式特性外，还可以添加一些额外方法，例如swap

用于toList

public class ArraySeq<T> extends ArrayList<T> implements SizedSeq<T> {
    // (1, 2, 3, 4) -> swap(1, 2) -> (1, 3, 2, 4)
    public void swap(int i, int j) {...}
}

LinkedSeq

JDK内置LinkedList的流式扩展

public class LinkedSeq<T> extends LinkedList<T> implements SeqList<T>, SeqQueue<T> {...}

LinkedSeqSet

JDK内置LinkedHashSet的流式扩展

用于toSet, distinct

public class LinkedSeqSet<T> extends LinkedHashSet<T> implements SeqSet<T> {...}

ConcurrentSeq

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) {...}

二元流衍生类型

SeqMap

既是Map也是Seq2，是对JDK原生Map的极大扩展

public interface SeqMap<K, V> extends Seq2<K, V>, Map<K, V> {...}

除了Seq2自带的流式API外，SeqMap还有以下许多额外的扩展方法

seqKeySet

类似于Map自带的keySet但返回一个SeqSet

SeqSet<K> seqKeySet();

seqValues

类似于Map自带的values但返回一个SeqCollection

SeqCollection<V> seqValues();

seqEntrySet

类似于Map自带的entrySet但返回一个SeqSet

SeqSet<Entry<K, V>> seqEntrySet();

mapByKey

替换当前的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) {...}

mapByValue

替换当前的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) {...}

replaceValue

和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) {...}

sort(Desc)

可以对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) {...}

sort(Desc)ByKey/ByValue

也可以方便的直接针对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) {...}

LinkedSeqMap

既是LinkedHashMap也是SeqMap，继承前者的主要构造方法

public class LinkedSeqMap<K, V> extends LinkedHashMap<K, V> implements SeqMap<K, V> {...}
Clone this wiki locally