com.worksap.fig.lang

Interface Seq<T>

All Known Subinterfaces:

MutableSeq<T>

public interface Seq<T>

Elegant supplement for List in JDK

Method Summary

Modifier and Type	Method and Description
default boolean	all(java.util.function.BiPredicate<T,java.lang.Integer> condition) Check whether all elements of the seq satisfy the condition
default boolean	all(java.util.function.Predicate<T> condition) Check whether all elements of the seq satisfy the condition
default boolean	any(java.util.function.BiPredicate<T,java.lang.Integer> condition) Check whether any element of the seq satisfies the condition
default boolean	any(java.util.function.Predicate<T> condition) Check whether any element of the seq satisfies the condition
Seq<T>	append(java.util.Collection<? extends T> collection) Append values to the seq at the end of it, resulting a new seq.
Seq<T>	append(Seq<? extends T> seq) Append values to the seq at the end of it, resulting a new seq.
Seq<T>	append(T... values) Append values to the seq at the end of it, resulting a new seq.
Seq<T>	append(T value) Append values to the seq at the end of it, resulting a new seq.
Seq<T>	compact() Returns a copy of the seq itself with all null elements removed.
boolean	contains(T t)
default boolean	containsSubSeq(Seq<T> seq) Check whether this seq contains the sub seq, if the given seq is empty, always return true.
default int	count(T element) Returns the number of the specified element.
default int	countIf(java.util.function.BiPredicate<T,java.lang.Integer> condition) Returns the number of elements which satisfy the condition.
default int	countIf(java.util.function.Predicate<T> condition) Returns the number of elements which satisfy the condition.
Seq<T>	difference(Seq<T> seq) Computes the multiset difference between this seq and another seq.
Seq<T>	distinct() Reduce duplicated elements, keeping only the first occurrence, resulting a new seq.
Seq<? extends Seq<T>>	eachCombination(int n) Return a new Seq of all combinations of length n of elements from this seq.
Seq<? extends Seq<T>>	eachCons(int n) Transform the seq, to a seq of each continuous n elements starting from each element.
Seq<? extends Seq<T>>	eachSlice(int n) Slices this seq to construct some slices in the original order, each of slice contains n elements(only the last slice can contain less than n elements).
Seq<T>	filter(java.util.function.BiPredicate<T,java.lang.Integer> condition) Gets elements which satisfy the condition, resulting a new seq without changing the original one.
Seq<T>	filter(java.util.function.Predicate<T> condition) Gets elements which satisfy the condition, resulting a new seq without changing the original one.
Seq<T>	filterWhile(java.util.function.BiPredicate<T,java.lang.Integer> condition) Gets elements at the front of this seq which satisfy the condition, resulting a new seq without changing the original one.
Seq<T>	filterWhile(java.util.function.Predicate<T> condition) Gets elements at the front of this seq which satisfy the condition, resulting a new seq without changing the original one.
default T	findFirst(java.util.function.Predicate<T> condition) Find the first element which satisfy the condition.
default int	findFirstIndex(java.util.function.Predicate<T> condition) Find the index of the first element which satisfy the condition.
default T	findLast(java.util.function.Predicate<T> condition) Find the last element which satisfy the condition.
default int	findLastIndex(java.util.function.Predicate<T> condition) Find the index of the last element which satisfy the condition.
default T	first()
<R> Seq<R>	flatMap(java.util.function.BiFunction<T,java.lang.Integer,Seq<R>> func) Similar to flatMap(Function), with additional parameter "index" as the second parameter of the lambda expression.
<R> Seq<R>	flatMap(java.util.function.Function<T,Seq<R>> func) Transform each element into a seq, and concat all seq together into a new seq.
default void	forEach(java.util.function.BiConsumer<? super T,java.lang.Integer> action) Similar to forEach(Consumer), with additional parameter "index" as the second parameter of the lambda expression.
default void	forEach(java.util.function.Consumer<? super T> action) Iterate each element of the seq.
void	forEachCombination(int n, java.util.function.Consumer<Seq<T>> action) Similar with eachCombination(int), but instead of to return the seq, it iterates the seq and do action.
default void	forEachCons(int n, java.util.function.Consumer<Seq<T>> action) Similar with eachCons(int), but instead of to return the transformed seq, it iterates the transformed seq and do action.
default void	forEachReverse(java.util.function.BiConsumer<? super T,java.lang.Integer> action) Similar to forEachReverse(Consumer), with additional parameter "index" as the second parameter of the lambda expression.
default void	forEachReverse(java.util.function.Consumer<? super T> action) Iterate each element of the seq from the end to the beginning.
default void	forEachSlice(int n, java.util.function.Consumer<Seq<T>> action) Slices the seq to construct some slices and take action on each slice.
T	get(int index) Returns the element at index.
default T	get(int index, T defaultValue) Returns the element at index.
int	indexOf(T t) Returns the index of the first occurrence of the specified element in this list, or -1 if this list does not contain the element.
default int	indexOfSubSeq(Seq<T> seq) Return the first index of the given sub seq, or -1 if the given seq is not a sub seq.
Seq<T>	intersect(Seq<T> seq) Computes the multiset intersection between this seq and another seq.
boolean	isEmpty()
default CharSeq	join() Convert all elements into String, and connect each String together to a single String, following the same order of the seq.
default CharSeq	join(java.lang.CharSequence delimiter) Convert all elements into String, and connect each String together to a single String, following the same order of the seq.
default CharSeq	join(java.lang.CharSequence delimiter, java.lang.CharSequence prefix, java.lang.CharSequence suffix) Convert all elements into String, and connect each String together to a single String, following the same order of the seq.
default T	last()
int	lastIndexOf(T t) Returns the index of the last occurrence of the specified element in this list, or -1 if this list does not contain the element.
default int	lastIndexOfSubSeq(Seq<T> seq) Return the last index of the given sub seq, or -1 if the given seq is not a sub seq.
<R> Seq<R>	map(java.util.function.BiFunction<T,java.lang.Integer,R> func) Similar to map(Function), with additional parameter "index" as the second parameter of the lambda expression.
<R> Seq<R>	map(java.util.function.Function<T,R> func) Transform each element of the seq into another value using the same function, resulting a new seq without changing the original one.
default java.util.Optional<T>	max(java.util.Comparator<? super T> comparator) Returns the maximum element of the seq
default java.util.Optional<T>	min(java.util.Comparator<? super T> comparator) Returns the minimum element of the seq
default boolean	none(java.util.function.BiPredicate<T,java.lang.Integer> condition) Check whether no element of the seq satisfies the condition
default boolean	none(java.util.function.Predicate<T> condition) Check whether no element of the seq satisfies the condition
Seq<T>	prepend(java.util.Collection<? extends T> collection) Prepend values into the seq at the beginning of it.
Seq<T>	prepend(Seq<? extends T> seq) Prepend values into the seq at the beginning of it.
Seq<T>	prepend(T... values) Prepend values into the seq at the beginning of it.
Seq<T>	prepend(T values) Prepend values into the seq at the beginning of it.
default T	reduce(java.util.function.BinaryOperator<T> accumulator) Performs a reduction on the elements of this seq, using the provided binary operation, and returns the reduced value.
default <R> R	reduce(R init, java.util.function.BiFunction<R,T,R> accumulator) Performs a reduction on the elements of this seq, using the provided initial value and a binary function, and returns the reduced value.
Seq<T>	reject(java.util.function.BiPredicate<T,java.lang.Integer> condition) Removes elements which satisfy the condition, resulting a new seq without changing the original one.
Seq<T>	reject(java.util.function.Predicate<T> condition) Removes elements which satisfy the condition, resulting a new seq without changing the original one.
Seq<T>	rejectWhile(java.util.function.BiPredicate<T,java.lang.Integer> condition) Removes elements at the front of this seq which satisfy the condition, resulting a new seq without changing the original one.
Seq<T>	rejectWhile(java.util.function.Predicate<T> condition) Removes elements at the front of this seq which satisfy the condition, resulting a new seq without changing the original one.
Seq<T>	repeat(int times) Returns a new seq built by concatenating the times copies of this seq.
Seq<T>	reverse() Constructs a new seq containing all the elements of this seq in reverse order.
default T	sample() Randomly find an element in the seq.
Seq<T>	sample(int n) Randomly find n elements in the seq.
Seq<T>	shuffle() Randomly shuffle the seq, resulting a new seq.
int	size() Get the number of elements in this seq.
Seq<T>	sort(java.util.Comparator<? super T> comparator) Sort the seq by the comparator, resulting a new seq, without changing the original seq.
Seq<T>	subSeq(int fromIndex, int toIndex) Create a new seq which is the sub seq of the current one.
java.lang.Object[]	toArray()
java.util.ArrayList<T>	toArrayList()

Method Detail

map

<R> Seq<R> map(java.util.function.Function<T,R> func)

Transform each element of the seq into another value using the same function, resulting a new seq without changing the original one.

Returns:

The new seq after transformation.

Throws:

java.lang.NullPointerException - if func is null

map

<R> Seq<R> map(java.util.function.BiFunction<T,java.lang.Integer,R> func)

Similar to map(Function), with additional parameter "index" as the second parameter of the lambda expression.

Throws:

java.lang.NullPointerException - if func is null

flatMap

<R> Seq<R> flatMap(java.util.function.Function<T,Seq<R>> func)

Transform each element into a seq, and concat all seq together into a new seq.

Returns:

The new seq after transformation.

Throws:

java.lang.NullPointerException - if func is null

flatMap

<R> Seq<R> flatMap(java.util.function.BiFunction<T,java.lang.Integer,Seq<R>> func)

Similar to flatMap(Function), with additional parameter "index" as the second parameter of the lambda expression.

Throws:

java.lang.NullPointerException - if func is null

first

default T first()

Returns:

The beginning element of the seq.

Throws:

java.lang.IndexOutOfBoundsException - if the seq is empty

last

default T last()

Returns:

The ending element of the seq.

Throws:

java.lang.IndexOutOfBoundsException - if the seq is empty

join

default CharSeq join()

Convert all elements into String, and connect each String together to a single String, following the same order of the seq.

join

default CharSeq join(java.lang.CharSequence delimiter)

Convert all elements into String, and connect each String together to a single String, following the same order of the seq. Insert a delimiter at each connection point.

join

default CharSeq join(java.lang.CharSequence delimiter,
                     java.lang.CharSequence prefix,
                     java.lang.CharSequence suffix)

Convert all elements into String, and connect each String together to a single String, following the same order of the seq. Insert a delimiter at each connection point. Add prefix and suffix to the final result.

sample

default T sample()

Randomly find an element in the seq.

Returns:

The selected element, or null if the seq is empty.

sample

Seq<T> sample(int n)

Randomly find n elements in the seq.

Returns:

A new seq of the selected elements. If the size of seq is lower than n, return all elements. Return empty result if the seq is empty. The order of selected elements may be changed.

size

int size()

Get the number of elements in this seq.

contains

boolean contains(T t)

shuffle

Seq<T> shuffle()

Randomly shuffle the seq, resulting a new seq.

toArrayList

java.util.ArrayList<T> toArrayList()

forEach

default void forEach(java.util.function.Consumer<? super T> action)

Iterate each element of the seq.

Throws:

java.lang.NullPointerException - if action is null

forEach

default void forEach(java.util.function.BiConsumer<? super T,java.lang.Integer> action)

Similar to forEach(Consumer), with additional parameter "index" as the second parameter of the lambda expression.

Throws:

java.lang.NullPointerException - if action is null

forEachReverse

default void forEachReverse(java.util.function.Consumer<? super T> action)

Iterate each element of the seq from the end to the beginning.

Throws:

java.lang.NullPointerException - if action is null

forEachReverse

default void forEachReverse(java.util.function.BiConsumer<? super T,java.lang.Integer> action)

Similar to forEachReverse(Consumer), with additional parameter "index" as the second parameter of the lambda expression.

Throws:

java.lang.NullPointerException - if action is null

eachCons

Seq<? extends Seq<T>> eachCons(int n)

Transform the seq, to a seq of each continuous n elements starting from each element.

[1, 2, 3, 4] with n=2 will result to [[1, 2], [2, 3], [3, 4]]

If the size of seq is lower than n, result will be empty.

Throws:

java.lang.IllegalArgumentException - if n <= 0

forEachCons

default void forEachCons(int n,
                         java.util.function.Consumer<Seq<T>> action)

Similar with eachCons(int), but instead of to return the transformed seq, it iterates the transformed seq and do action.

Throws:

java.lang.NullPointerException - if action is null

java.lang.IllegalArgumentException - if n <= 0

isEmpty

boolean isEmpty()

toArray

java.lang.Object[] toArray()

sort

Seq<T> sort(java.util.Comparator<? super T> comparator)

Sort the seq by the comparator, resulting a new seq, without changing the original seq.

Parameters:

comparator - the comparator to determine the order of the seq. A null value indicates that the elements' natural ordering should be used.

Returns:

A new seq sorted

distinct

Seq<T> distinct()

Reduce duplicated elements, keeping only the first occurrence, resulting a new seq.

Returns:

A new seq reduced

findFirst

default T findFirst(java.util.function.Predicate<T> condition)

Find the first element which satisfy the condition.

Returns:

The element, or null if no element found.

Throws:

java.lang.NullPointerException - if condition is null

findLast

default T findLast(java.util.function.Predicate<T> condition)

Find the last element which satisfy the condition.

Returns:

The element, or null if no element found.

Throws:

java.lang.NullPointerException - if condition is null

findFirstIndex

default int findFirstIndex(java.util.function.Predicate<T> condition)

Find the index of the first element which satisfy the condition.

Returns:

The index, or -1 if no element found.

Throws:

java.lang.NullPointerException - if condition is null

findLastIndex

default int findLastIndex(java.util.function.Predicate<T> condition)

Find the index of the last element which satisfy the condition.

Returns:

The index, or -1 if no element found.

Throws:

java.lang.NullPointerException - if condition is null

append

Seq<T> append(T value)

Append values to the seq at the end of it, resulting a new seq.

Note: This method does NOT change the seq.

Returns:

A new seq after the change

Throws:

java.lang.NullPointerException - is values is null

append

Seq<T> append(T... values)

Append values to the seq at the end of it, resulting a new seq.

Note: This method does NOT change the seq.

Returns:

A new seq after the change

Throws:

java.lang.NullPointerException - is values is null

append

Seq<T> append(java.util.Collection<? extends T> collection)

Append values to the seq at the end of it, resulting a new seq.

Note: This method does NOT change the seq.

Returns:

A new seq after the change

Throws:

java.lang.NullPointerException - is collection is null

append

Seq<T> append(Seq<? extends T> seq)

Append values to the seq at the end of it, resulting a new seq.

Note: This method does NOT change the seq.

Returns:

A new seq after the change

Throws:

java.lang.NullPointerException - is collection is null

prepend

Seq<T> prepend(T values)

Prepend values into the seq at the beginning of it. Values keep the parameter order after being prepended.

Note: This method does NOT change the seq.

Returns:

A new seq after the change

Throws:

java.lang.NullPointerException - is values is null

prepend

Seq<T> prepend(T... values)

Prepend values into the seq at the beginning of it. Values keep the parameter order after being prepended.

Note: This method does NOT change the seq.

Returns:

A new seq after the change

Throws:

java.lang.NullPointerException - is values is null

prepend

Seq<T> prepend(java.util.Collection<? extends T> collection)

Prepend values into the seq at the beginning of it. Values keep the order after being merged into the seq.

Note: This method does NOT change the seq.

Returns:

A new seq after the change

Throws:

java.lang.NullPointerException - is collection is null

prepend

Seq<T> prepend(Seq<? extends T> seq)

Prepend values into the seq at the beginning of it. Values keep the order after being merged into the seq.

Note: This method does NOT change the seq.

Returns:

A new seq after the change

Throws:

java.lang.NullPointerException - is collection is null

subSeq

Seq<T> subSeq(int fromIndex,
              int toIndex)

Create a new seq which is the sub seq of the current one.

Parameters:

fromIndex - The start index, inclusive.

toIndex - The end index, exclusive.

Throws:

java.lang.IndexOutOfBoundsException - if an endpoint index value is out of range (fromIndex < 0 || toIndex > size)

java.lang.IllegalArgumentException - if the endpoint indices are out of order (fromIndex > toIndex)

reject

Seq<T> reject(java.util.function.Predicate<T> condition)

Removes elements which satisfy the condition, resulting a new seq without changing the original one.

Parameters:

condition - the condition used to filter elements by passing the element, returns true if the element satisfies the condition, otherwise returns false.

Returns:

the new seq without elements which satisfy the condition

Throws:

java.lang.NullPointerException - if condition is null

reject

Seq<T> reject(java.util.function.BiPredicate<T,java.lang.Integer> condition)

Removes elements which satisfy the condition, resulting a new seq without changing the original one.

Similar to reject(Predicate), with additional parameter "index" as the second parameter of the lambda expression

Parameters:

condition - the condition used to filter elements by passing the element and its index, returns true if the element satisfies the condition, otherwise returns false.

Returns:

the new seq without elements which satisfy the condition

Throws:

java.lang.NullPointerException - if condition is null

rejectWhile

Seq<T> rejectWhile(java.util.function.Predicate<T> condition)

Removes elements at the front of this seq which satisfy the condition, resulting a new seq without changing the original one.

Parameters:

condition - the condition used to filter elements by passing the element, returns true if the element satisfies the condition, otherwise returns false.

Returns:

the new seq without elements which satisfy the condition

Throws:

java.lang.NullPointerException - if condition is null

rejectWhile

Seq<T> rejectWhile(java.util.function.BiPredicate<T,java.lang.Integer> condition)

Removes elements at the front of this seq which satisfy the condition, resulting a new seq without changing the original one.

Similar to reject(Predicate), with additional parameter "index" as the second parameter of the lambda expression

Parameters:

condition - the condition used to filter elements by passing the element and its index, returns true if the element satisfies the condition, otherwise returns false.

Returns:

the new seq without elements which satisfy the condition

Throws:

java.lang.NullPointerException - if condition is null

filter

Seq<T> filter(java.util.function.Predicate<T> condition)

Gets elements which satisfy the condition, resulting a new seq without changing the original one.

Parameters:

condition - the condition used to filter elements by passing the element's index, returns true if the element satisfies the condition, otherwise returns false

Returns:

the new seq containing only the elements satisfying the condition

Throws:

java.lang.NullPointerException - if condition is null

filter

Seq<T> filter(java.util.function.BiPredicate<T,java.lang.Integer> condition)

Gets elements which satisfy the condition, resulting a new seq without changing the original one.

Similar to filter(Predicate), with additional parameter "index" as the second parameter of the lambda expression.

Parameters:

condition - the condition used to filter elements by passing the element and its index, returns true if the element satisfies the condition, otherwise returns false

Returns:

the new seq containing only the elements satisfying the condition

Throws:

java.lang.NullPointerException - if condition is null

filterWhile

Seq<T> filterWhile(java.util.function.Predicate<T> condition)

Gets elements at the front of this seq which satisfy the condition, resulting a new seq without changing the original one.

Parameters:

condition - the condition used to filter elements by passing the element's index, returns true if the element satisfies the condition, otherwise returns false

Returns:

the new seq containing only the elements satisfying the condition

Throws:

java.lang.NullPointerException - if condition is null

filterWhile

Seq<T> filterWhile(java.util.function.BiPredicate<T,java.lang.Integer> condition)

Gets elements at the front of this seq which satisfy the condition, resulting a new seq without changing the original one.

Similar to filter(Predicate), with additional parameter "index" as the second parameter of the lambda expression.

Parameters:

condition - the condition used to filter elements by passing the element and its index, returns true if the element satisfies the condition, otherwise returns false

Returns:

the new seq containing only the elements satisfying the condition

Throws:

java.lang.NullPointerException - if condition is null

repeat

Seq<T> repeat(int times)

Returns a new seq built by concatenating the times copies of this seq.

Parameters:

times - times to repeat

Returns:

the new seq

Throws:

java.lang.IllegalArgumentException - if times <= 0

compact

Seq<T> compact()

Returns a copy of the seq itself with all null elements removed.

Returns:

the new seq with all null elements removed

count

default int count(T element)

Returns the number of the specified element.

Parameters:

element - the element to countIf

Returns:

the number of the specified element

countIf

default int countIf(java.util.function.Predicate<T> condition)

Returns the number of elements which satisfy the condition.

Parameters:

condition - the condition used to filter elements by passing the element, returns true if the element satisfies the condition, otherwise returns false.

Returns:

the number of elements which satisfy the condition

Throws:

java.lang.NullPointerException - if condition is null

countIf

default int countIf(java.util.function.BiPredicate<T,java.lang.Integer> condition)

Returns the number of elements which satisfy the condition.

Similar to countIf(Predicate), with additional parameter "index" as the second parameter of the lambda expression.

Parameters:

condition - the condition used to filter elements by passing the element and its index, returns true if the element satisfies the condition, otherwise returns false.

Returns:

the number of elements which satisfy the condition

Throws:

java.lang.NullPointerException - if condition is null

get

T get(int index)

Returns the element at index. A negative index counts from the end of self.

Parameters:

index - index of the element to return

Returns:

the element at the specified position in this seq

Throws:

java.lang.IndexOutOfBoundsException - if the index is out of range (index >= size() || index < -size())

get

default T get(int index,
              T defaultValue)

Returns the element at index. A negative index counts from the end of self. If the index is out of range(index < -size() || index >= size()), a default value is returned.

Similar to get(int). The difference between these two functions is how to solve the situation of illegal index.
get(int, Object) returns a default value when the index is illegal.
get(int) throws an exception(IndexOutOfBoundsException) when the index is illegal.

Parameters:

index - index of the element to return

defaultValue - default value to return when the index is out of range

Returns:

The element at the specified position in this seq, or default value if the index is out of range

eachSlice

Seq<? extends Seq<T>> eachSlice(int n)

Slices this seq to construct some slices in the original order, each of slice contains n elements(only the last slice can contain less than n elements).

Parameters:

n - the number of elements in each slice except the last one

Returns:

the collection of these slices

Throws:

java.lang.IllegalArgumentException - if n <= 0

forEachSlice

default void forEachSlice(int n,
                          java.util.function.Consumer<Seq<T>> action)

Slices the seq to construct some slices and take action on each slice.

Similar to eachSlice(int), but instead of returning the slice collection, it iterates the slice collection and takes action on each slice.

Parameters:

n - the number of elements in each slice except the last one

action - the action to take on each slice

Throws:

java.lang.IllegalArgumentException - if n <= 0

java.lang.NullPointerException - if action is null

reduce

default T reduce(java.util.function.BinaryOperator<T> accumulator)

Performs a reduction on the elements of this seq, using the provided binary operation, and returns the reduced value.

Parameters:

accumulator - the binary operation for combining two values

Returns:

the result of the reduction, or null if the seq is empty

Throws:

java.lang.NullPointerException - if accumulator is null

reduce

default <R> R reduce(R init,
                     java.util.function.BiFunction<R,T,R> accumulator)

Performs a reduction on the elements of this seq, using the provided initial value and a binary function, and returns the reduced value.

Similar to reduce(BinaryOperator), with an additional parameter "init" as the initial value of the reduction

Parameters:

init - the initial value for the accumulating function

accumulator - the binary function for combining two values

Returns:

the result of the reduction

Throws:

java.lang.NullPointerException - if accumulator is null

reverse

Seq<T> reverse()

Constructs a new seq containing all the elements of this seq in reverse order.

Returns:

the new seq with elements in reverse order

forEachCombination

void forEachCombination(int n,
                        java.util.function.Consumer<Seq<T>> action)

Similar with eachCombination(int), but instead of to return the seq, it iterates the seq and do action.

eachCombination

Seq<? extends Seq<T>> eachCombination(int n)

Return a new Seq of all combinations of length n of elements from this seq. The implementation makes no guarantees about the order in which the combinations are returned. This method uses the index as the identity of each element, thus it may return a combination with duplicated elements inside. If you want to avoid this, use distinct() before calling this method.

any

default boolean any(java.util.function.Predicate<T> condition)

Check whether any element of the seq satisfies the condition

Throws:

java.lang.NullPointerException - if condition is null

any

default boolean any(java.util.function.BiPredicate<T,java.lang.Integer> condition)

Check whether any element of the seq satisfies the condition

Throws:

java.lang.NullPointerException - if condition is null

indexOf

int indexOf(T t)

Returns the index of the first occurrence of the specified element in this list, or -1 if this list does not contain the element. More formally, returns the lowest index i such that (o==null ? get(i)==null : o.equals(get(i))), or -1 if there is no such index.

lastIndexOf

int lastIndexOf(T t)

Returns the index of the last occurrence of the specified element in this list, or -1 if this list does not contain the element. More formally, returns the highest index i such that (o==null ? get(i)==null : o.equals(get(i))), or -1 if there is no such index.

containsSubSeq

default boolean containsSubSeq(Seq<T> seq)

Check whether this seq contains the sub seq, if the given seq is empty, always return true.

Throws:

java.lang.NullPointerException - if seq is null

indexOfSubSeq

default int indexOfSubSeq(Seq<T> seq)

Return the first index of the given sub seq, or -1 if the given seq is not a sub seq. If the given seq is empty, always return 0.

Throws:

java.lang.NullPointerException - if seq is null

lastIndexOfSubSeq

default int lastIndexOfSubSeq(Seq<T> seq)

Return the last index of the given sub seq, or -1 if the given seq is not a sub seq. If the given seq is empty, always return 0.

Throws:

java.lang.NullPointerException - if seq is null

intersect

Seq<T> intersect(Seq<T> seq)

Computes the multiset intersection between this seq and another seq.

Returns:

A new seq which contains all elements of this seq which also appear in that, keeping the order of this seq. If an element value x appears n times in that, then the first n occurrences of x will be retained in the result, but any following occurrences will be omitted.

Throws:

java.lang.NullPointerException - if the parameter seq is null

difference

Seq<T> difference(Seq<T> seq)

Computes the multiset difference between this seq and another seq.

Returns:

A new seq which contains all elements of this seq except some of occurrences of elements that also appear in that, keeping the order of this seq. If an element value x appears n times in that, then the first n occurrences of x will not form part of the result, but any following occurrences will.

Throws:

java.lang.NullPointerException - if the parameter seq is null

all

default boolean all(java.util.function.Predicate<T> condition)

Check whether all elements of the seq satisfy the condition

Throws:

java.lang.NullPointerException - if condition is null

all

default boolean all(java.util.function.BiPredicate<T,java.lang.Integer> condition)

Check whether all elements of the seq satisfy the condition

Throws:

java.lang.NullPointerException - if condition is null

none

default boolean none(java.util.function.Predicate<T> condition)

Check whether no element of the seq satisfies the condition

Throws:

java.lang.NullPointerException - if condition is null

none

default boolean none(java.util.function.BiPredicate<T,java.lang.Integer> condition)

Check whether no element of the seq satisfies the condition

Throws:

java.lang.NullPointerException - if condition is null

max

default java.util.Optional<T> max(java.util.Comparator<? super T> comparator)

Returns the maximum element of the seq

Throws:

java.lang.NullPointerException - if comparator is null

min

default java.util.Optional<T> min(java.util.Comparator<? super T> comparator)

Returns the minimum element of the seq

Throws:

java.lang.NullPointerException - if comparator is null