MutableSeq (icefig 0.2.4 API)

All Superinterfaces:

Seq<T>
```
public interface MutableSeq<T>
extends Seq<T>
```
An interface extending Seq (which is immutable), with additional in-place methods to change the seq itself. Those methods are generally named xxxInPlace

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`MutableSeq<T>`	`append(java.util.Collection<? extends T> collection)` Append values to the seq at the end of it, resulting a new seq.
`MutableSeq<T>`	`append(Seq<? extends T> seq)` Append values to the seq at the end of it, resulting a new seq.
`MutableSeq<T>`	`append(T... values)` Append values to the seq at the end of it, resulting a new seq.
`MutableSeq<T>`	`append(T value)` Append values to the seq at the end of it, resulting a new seq.
`MutableSeq<T>`	`appendInPlace(java.util.Collection<? extends T> collection)` In-place method of `append(Collection)`
`MutableSeq<T>`	`appendInPlace(Seq<? extends T> seq)` In-place method of `append(Seq)`
`MutableSeq<T>`	`appendInPlace(T... values)` In-place method of `#append(T...)`
`MutableSeq<T>`	`appendInPlace(T value)` In-place method of `append(Object)`
`MutableSeq<T>`	`clear()` Remove all elements in the seq.
`default MutableSeq<T>`	`compact()` Returns a copy of the seq itself with all null elements removed.
`MutableSeq<T>`	`compactInPlace()` In-place method of `compact()`
`MutableSeq<T>`	`distinct()` Reduce duplicated elements, keeping only the first occurrence, resulting a new seq.
`MutableSeq<T>`	`distinctInPlace()` In-place method of `distinct()`
`MutableSeq<MutableSeq<T>>`	`eachCombination(int n)` Return a new Seq of all combinations of length n of elements from this seq.
`MutableSeq<MutableSeq<T>>`	`eachCons(int n)` Transform the seq, to a seq of each continuous n elements starting from each element.
`MutableSeq<MutableSeq<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).
`MutableSeq<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.
`MutableSeq<T>`	`filter(java.util.function.Predicate<T> condition)` Gets elements which satisfy the condition, resulting a new seq without changing the original one.
`MutableSeq<T>`	`filterInPlace(java.util.function.BiPredicate<T,java.lang.Integer> condition)` In-place method of `filter(BiPredicate)`
`MutableSeq<T>`	`filterInPlace(java.util.function.Predicate<T> condition)` In-place method of `filter(Predicate)`
`MutableSeq<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.
`MutableSeq<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.
`MutableSeq<T>`	`filterWhileInPlace(java.util.function.BiPredicate<T,java.lang.Integer> condition)` In-place method of `filterWhile(BiPredicate)`
`MutableSeq<T>`	`filterWhileInPlace(java.util.function.Predicate<T> condition)` In-place method of `filterWhile(Predicate)`
`<R> MutableSeq<R>`	`flatMap(java.util.function.BiFunction<T,java.lang.Integer,Seq<R>> func)` Similar to `Seq.flatMap(Function)`, with additional parameter "index" as the second parameter of the lambda expression.
`<R> MutableSeq<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.
`<R> MutableSeq<R>`	`map(java.util.function.BiFunction<T,java.lang.Integer,R> func)` Similar to `Seq.map(Function)`, with additional parameter "index" as the second parameter of the lambda expression.
`<R> MutableSeq<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.
`MutableSeq<T>`	`prepend(java.util.Collection<? extends T> collection)` Prepend values into the seq at the beginning of it.
`MutableSeq<T>`	`prepend(Seq<? extends T> seq)` Prepend values into the seq at the beginning of it.
`MutableSeq<T>`	`prepend(T... values)` Prepend values into the seq at the beginning of it.
`MutableSeq<T>`	`prepend(T value)` Prepend values into the seq at the beginning of it.
`MutableSeq<T>`	`prependInPlace(java.util.Collection<? extends T> collection)` In-place method of `prepend(Collection)`
`MutableSeq<T>`	`prependInPlace(Seq<? extends T> seq)` In-place method of `prepend(Seq)`
`MutableSeq<T>`	`prependInPlace(T... values)` In-place method of `#prepend(T...)`
`MutableSeq<T>`	`prependInPlace(T value)` In-place method of `prepend(Object)`
`MutableSeq<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.
`MutableSeq<T>`	`reject(java.util.function.Predicate<T> condition)` Removes elements which satisfy the condition, resulting a new seq without changing the original one.
`MutableSeq<T>`	`rejectInPlace(java.util.function.BiPredicate<T,java.lang.Integer> condition)` In-place method of `reject(BiPredicate)`
`MutableSeq<T>`	`rejectInPlace(java.util.function.Predicate<T> condition)` In-place method of `reject(Predicate)`
`MutableSeq<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.
`MutableSeq<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.
`MutableSeq<T>`	`rejectWhileInPlace(java.util.function.BiPredicate<T,java.lang.Integer> condition)` In-place method of `rejectWhile(BiPredicate)`
`MutableSeq<T>`	`rejectWhileInPlace(java.util.function.Predicate<T> condition)` In-place method of `rejectWhile(Predicate)`
`MutableSeq<T>`	`repeat(int times)` Returns a new seq built by concatenating the `times` copies of this seq.
`MutableSeq<T>`	`repeatInPlace(int times)` In-place method of `repeat(int)`
`MutableSeq<T>`	`reverse()` Constructs a new seq containing all the elements of this seq in reverse order.
`MutableSeq<T>`	`reverseInPlace()` In-place method of `reverse()`
`MutableSeq<T>`	`sample(int n)` Randomly find n elements in the seq.
`MutableSeq<T>`	`set(int i, T t)` Update the element at the index.
`MutableSeq<T>`	`shuffle()` Randomly shuffle the seq, resulting a new seq.
`MutableSeq<T>`	`shuffleInPlace()` In-place method of `shuffle()`
`MutableSeq<T>`	`sort(java.util.Comparator<? super T> comparator)` Sort the seq by the comparator, resulting a new seq, without changing the original seq.
`MutableSeq<T>`	`sortInPlace(java.util.Comparator<? super T> comparator)` In-place method of `sort(Comparator)`
`MutableSeq<T>`	`subSeq(int fromIndex, int toIndex)` Create a new seq which is the sub seq of the current one.

Methods inherited from interface com.worksap.icefig.lang.Seq
all, all, any, any, contains, containsSubSeq, count, countIf, countIf, difference, findFirst, findFirstIndex, findLast, findLastIndex, first, forEach, forEach, forEachCombination, forEachCons, forEachReverse, forEachReverse, forEachSlice, get, get, indexOf, indexOfSubSeq, intersect, isEmpty, join, join, join, last, lastIndexOf, lastIndexOfSubSeq, max, min, none, none, reduce, reduce, sample, size, toArray, toArrayList

- Method Detail
  - map
```
<R> MutableSeq<R> map(java.util.function.Function<T,R> func)
```
    Description copied from interface: Seq
    
    Transform each element of the seq into another value using the same function, resulting a new seq without changing the original one.
    
    Specified by:
    
    map in interface Seq<T>
    
    Returns:
    
    The new seq after transformation.
  - map
```
<R> MutableSeq<R> map(java.util.function.BiFunction<T,java.lang.Integer,R> func)
```
    Description copied from interface: Seq
    
    Similar to Seq.map(Function), with additional parameter "index" as the second parameter of the lambda expression.
    
    Specified by:
    
    map in interface Seq<T>
  - flatMap
```
<R> MutableSeq<R> flatMap(java.util.function.Function<T,Seq<R>> func)
```
    Description copied from interface: Seq
    
    Transform each element into a seq, and concat all seq together into a new seq.
    
    Specified by:
    
    flatMap in interface Seq<T>
    
    Returns:
    
    The new seq after transformation.
  - flatMap
```
<R> MutableSeq<R> flatMap(java.util.function.BiFunction<T,java.lang.Integer,Seq<R>> func)
```
    Description copied from interface: Seq
    
    Similar to Seq.flatMap(Function), with additional parameter "index" as the second parameter of the lambda expression.
    
    Specified by:
    
    flatMap in interface Seq<T>
  - sample
```
MutableSeq<T> sample(int n)
```
    Description copied from interface: Seq
    
    Randomly find n elements in the seq.
    
    Specified by:
    
    sample in interface Seq<T>
    
    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.
  - shuffle
```
MutableSeq<T> shuffle()
```
    Description copied from interface: Seq
    
    Randomly shuffle the seq, resulting a new seq.
    
    Specified by:
    
    shuffle in interface Seq<T>
  - eachCons
```
MutableSeq<MutableSeq<T>> eachCons(int n)
```
    Description copied from interface: Seq
    
    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.
    
    Specified by:
    
    eachCons in interface Seq<T>
  - sort
```
MutableSeq<T> sort(java.util.Comparator<? super T> comparator)
```
    Description copied from interface: Seq
    
    Sort the seq by the comparator, resulting a new seq, without changing the original seq.
    
    Specified by:
    
    sort in interface Seq<T>
    
    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
```
MutableSeq<T> distinct()
```
    Description copied from interface: Seq
    
    Reduce duplicated elements, keeping only the first occurrence, resulting a new seq.
    
    Specified by:
    
    distinct in interface Seq<T>
    
    Returns:
    
    A new seq reduced
  - append
```
MutableSeq<T> append(T value)
```
    Description copied from interface: Seq
    
    Append values to the seq at the end of it, resulting a new seq.
    Note: This method does NOT change the seq.
    
    Specified by:
    
    append in interface Seq<T>
    
    Returns:
    
    A new seq after the change
  - append
```
MutableSeq<T> append(T... values)
```
    Description copied from interface: Seq
    
    Append values to the seq at the end of it, resulting a new seq.
    Note: This method does NOT change the seq.
    
    Specified by:
    
    append in interface Seq<T>
    
    Returns:
    
    A new seq after the change
  - append
```
MutableSeq<T> append(java.util.Collection<? extends T> collection)
```
    Description copied from interface: Seq
    
    Append values to the seq at the end of it, resulting a new seq.
    Note: This method does NOT change the seq.
    
    Specified by:
    
    append in interface Seq<T>
    
    Returns:
    
    A new seq after the change
  - append
```
MutableSeq<T> append(Seq<? extends T> seq)
```
    Description copied from interface: Seq
    
    Append values to the seq at the end of it, resulting a new seq.
    Note: This method does NOT change the seq.
    
    Specified by:
    
    append in interface Seq<T>
    
    Returns:
    
    A new seq after the change
  - prepend
```
MutableSeq<T> prepend(T value)
```
    Description copied from interface: Seq
    
    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.
    
    Specified by:
    
    prepend in interface Seq<T>
    
    Returns:
    
    A new seq after the change
  - prepend
```
MutableSeq<T> prepend(T... values)
```
    Description copied from interface: Seq
    
    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.
    
    Specified by:
    
    prepend in interface Seq<T>
    
    Returns:
    
    A new seq after the change
  - prepend
```
MutableSeq<T> prepend(java.util.Collection<? extends T> collection)
```
    Description copied from interface: 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.
    
    Specified by:
    
    prepend in interface Seq<T>
    
    Returns:
    
    A new seq after the change
  - prepend
```
MutableSeq<T> prepend(Seq<? extends T> seq)
```
    Description copied from interface: 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.
    
    Specified by:
    
    prepend in interface Seq<T>
    
    Returns:
    
    A new seq after the change
  - subSeq
```
MutableSeq<T> subSeq(int fromIndex,
                     int toIndex)
```
    Description copied from interface: Seq
    
    Create a new seq which is the sub seq of the current one.
    
    Specified by:
    
    subSeq in interface Seq<T>
    
    Parameters:
    
    fromIndex - The start index, inclusive.
    
    toIndex - The end index, exclusive.
  - reject
```
MutableSeq<T> reject(java.util.function.Predicate<T> condition)
```
    Description copied from interface: Seq
    
    Removes elements which satisfy the condition, resulting a new seq without changing the original one.
    
    Specified by:
    
    reject in interface Seq<T>
    
    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
  - reject
```
MutableSeq<T> reject(java.util.function.BiPredicate<T,java.lang.Integer> condition)
```
    Description copied from interface: Seq
    
    Removes elements which satisfy the condition, resulting a new seq without changing the original one.
    Similar to Seq.reject(Predicate), with additional parameter "index" as the second parameter of the lambda expression
    
    Specified by:
    
    reject in interface Seq<T>
    
    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
  - rejectWhile
```
MutableSeq<T> rejectWhile(java.util.function.Predicate<T> condition)
```
    Description copied from interface: Seq
    
    Removes elements at the front of this seq which satisfy the condition, resulting a new seq without changing the original one.
    
    Specified by:
    
    rejectWhile in interface Seq<T>
    
    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
  - rejectWhile
```
MutableSeq<T> rejectWhile(java.util.function.BiPredicate<T,java.lang.Integer> condition)
```
    Description copied from interface: Seq
    
    Removes elements at the front of this seq which satisfy the condition, resulting a new seq without changing the original one.
    Similar to Seq.reject(Predicate), with additional parameter "index" as the second parameter of the lambda expression
    
    Specified by:
    
    rejectWhile in interface Seq<T>
    
    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
  - filter
```
MutableSeq<T> filter(java.util.function.Predicate<T> condition)
```
    Description copied from interface: Seq
    
    Gets elements which satisfy the condition, resulting a new seq without changing the original one.
    
    Specified by:
    
    filter in interface Seq<T>
    
    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
  - filter
```
MutableSeq<T> filter(java.util.function.BiPredicate<T,java.lang.Integer> condition)
```
    Description copied from interface: Seq
    
    Gets elements which satisfy the condition, resulting a new seq without changing the original one.
    Similar to Seq.filter(Predicate), with additional parameter "index" as the second parameter of the lambda expression.
    
    Specified by:
    
    filter in interface Seq<T>
    
    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
  - filterWhile
```
MutableSeq<T> filterWhile(java.util.function.Predicate<T> condition)
```
    Description copied from interface: Seq
    
    Gets elements at the front of this seq which satisfy the condition, resulting a new seq without changing the original one.
    
    Specified by:
    
    filterWhile in interface Seq<T>
    
    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
  - filterWhile
```
MutableSeq<T> filterWhile(java.util.function.BiPredicate<T,java.lang.Integer> condition)
```
    Description copied from interface: Seq
    
    Gets elements at the front of this seq which satisfy the condition, resulting a new seq without changing the original one.
    Similar to Seq.filter(Predicate), with additional parameter "index" as the second parameter of the lambda expression.
    
    Specified by:
    
    filterWhile in interface Seq<T>
    
    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
  - repeat
```
MutableSeq<T> repeat(int times)
```
    Description copied from interface: Seq
    
    Returns a new seq built by concatenating the times copies of this seq.
    
    Specified by:
    
    repeat in interface Seq<T>
    
    Parameters:
    
    times - times to repeat
    
    Returns:
    
    the new seq
  - compact
```
default MutableSeq<T> compact()
```
    Description copied from interface: Seq
    
    Returns a copy of the seq itself with all null elements removed.
    
    Specified by:
    
    compact in interface Seq<T>
    
    Returns:
    
    the new seq with all null elements removed
  - eachSlice
```
MutableSeq<MutableSeq<T>> eachSlice(int n)
```
    Description copied from interface: Seq
    
    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).
    
    Specified by:
    
    eachSlice in interface Seq<T>
    
    Parameters:
    
    n - the number of elements in each slice except the last one
    
    Returns:
    
    the collection of these slices
  - reverse
```
MutableSeq<T> reverse()
```
    Description copied from interface: Seq
    
    Constructs a new seq containing all the elements of this seq in reverse order.
    
    Specified by:
    
    reverse in interface Seq<T>
    
    Returns:
    
    the new seq with elements in reverse order
  - eachCombination
```
MutableSeq<MutableSeq<T>> eachCombination(int n)
```
    Description copied from interface: Seq
    
    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 Seq.distinct() before calling this method.
    
    Specified by:
    
    eachCombination in interface Seq<T>
  - appendInPlace
```
MutableSeq<T> appendInPlace(T value)
```
    In-place method of append(Object)
  - appendInPlace
```
MutableSeq<T> appendInPlace(T... values)
```
    In-place method of #append(T...)
  - appendInPlace
```
MutableSeq<T> appendInPlace(java.util.Collection<? extends T> collection)
```
    In-place method of append(Collection)
  - appendInPlace
```
MutableSeq<T> appendInPlace(Seq<? extends T> seq)
```
    In-place method of append(Seq)
  - prependInPlace
```
MutableSeq<T> prependInPlace(T value)
```
    In-place method of prepend(Object)
  - prependInPlace
```
MutableSeq<T> prependInPlace(T... values)
```
    In-place method of #prepend(T...)
  - prependInPlace
```
MutableSeq<T> prependInPlace(java.util.Collection<? extends T> collection)
```
    In-place method of prepend(Collection)
  - prependInPlace
```
MutableSeq<T> prependInPlace(Seq<? extends T> seq)
```
    In-place method of prepend(Seq)
  - clear
```
MutableSeq<T> clear()
```
    Remove all elements in the seq.
    
    Returns:
    
    The seq itself after changed.
  - set
```
MutableSeq<T> set(int i,
                  T t)
```
    Update the element at the index.
    
    Returns:
    
    The seq itself after changed.
  - shuffleInPlace
```
MutableSeq<T> shuffleInPlace()
```
    In-place method of shuffle()
  - reverseInPlace
```
MutableSeq<T> reverseInPlace()
```
    In-place method of reverse()
  - distinctInPlace
```
MutableSeq<T> distinctInPlace()
```
    In-place method of distinct()
  - repeatInPlace
```
MutableSeq<T> repeatInPlace(int times)
```
    In-place method of repeat(int)
  - compactInPlace
```
MutableSeq<T> compactInPlace()
```
    In-place method of compact()
  - sortInPlace
```
MutableSeq<T> sortInPlace(java.util.Comparator<? super T> comparator)
```
    In-place method of sort(Comparator)
  - filterInPlace
```
MutableSeq<T> filterInPlace(java.util.function.Predicate<T> condition)
```
    In-place method of filter(Predicate)
  - filterInPlace
```
MutableSeq<T> filterInPlace(java.util.function.BiPredicate<T,java.lang.Integer> condition)
```
    In-place method of filter(BiPredicate)
  - filterWhileInPlace
```
MutableSeq<T> filterWhileInPlace(java.util.function.Predicate<T> condition)
```
    In-place method of filterWhile(Predicate)
  - filterWhileInPlace
```
MutableSeq<T> filterWhileInPlace(java.util.function.BiPredicate<T,java.lang.Integer> condition)
```
    In-place method of filterWhile(BiPredicate)
  - rejectInPlace
```
MutableSeq<T> rejectInPlace(java.util.function.Predicate<T> condition)
```
    In-place method of reject(Predicate)
  - rejectInPlace
```
MutableSeq<T> rejectInPlace(java.util.function.BiPredicate<T,java.lang.Integer> condition)
```
    In-place method of reject(BiPredicate)
  - rejectWhileInPlace
```
MutableSeq<T> rejectWhileInPlace(java.util.function.Predicate<T> condition)
```
    In-place method of rejectWhile(Predicate)
  - rejectWhileInPlace
```
MutableSeq<T> rejectWhileInPlace(java.util.function.BiPredicate<T,java.lang.Integer> condition)
```
    In-place method of rejectWhile(BiPredicate)

Interface MutableSeq<T>

Method Summary

Methods inherited from interface com.worksap.icefig.lang.Seq

Method Detail

map

map

flatMap

flatMap

sample

shuffle

eachCons

sort

distinct

append

append

append

append

prepend

prepend

prepend

prepend

subSeq

reject

reject

rejectWhile

rejectWhile

filter

filter

filterWhile

filterWhile

repeat

compact

eachSlice

reverse

eachCombination

appendInPlace

appendInPlace

appendInPlace

appendInPlace

prependInPlace

prependInPlace

prependInPlace

prependInPlace

clear

set

shuffleInPlace

reverseInPlace

distinctInPlace

repeatInPlace

compactInPlace

sortInPlace

filterInPlace

filterInPlace

filterWhileInPlace

filterWhileInPlace

rejectInPlace

rejectInPlace

rejectWhileInPlace

rejectWhileInPlace