Seq (icefig 0.2.4 API)

All Known Subinterfaces:

MutableSeq<T>
```
public interface Seq<T>
```
Elegant supplement for List in JDK

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
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

Interface Seq<T>

Method Summary

Method Detail

map

map

flatMap

flatMap

first

last

join

join

join

sample

sample

size

contains

shuffle

toArrayList

forEach

forEach

forEachReverse

forEachReverse

eachCons

forEachCons

isEmpty

toArray

sort

distinct

findFirst

findLast

findFirstIndex

findLastIndex

append

append

append

append

prepend

prepend

prepend

prepend

subSeq

reject

reject

rejectWhile

rejectWhile

filter

filter

filterWhile

filterWhile

repeat

compact

count

countIf

countIf

get

get

eachSlice

forEachSlice

reduce

reduce

reverse

forEachCombination

eachCombination

any

any

indexOf

lastIndexOf

containsSubSeq

indexOfSubSeq

lastIndexOfSubSeq

intersect

difference

all

all

none

none

max

min