ListBase (Java Tool 1.20.2 API)

java.lang.Object
- java.util.AbstractCollection<E>
- - java.util.AbstractList<T>
  - - org.osgl.util.ListBase<T>

All Implemented Interfaces:

Iterable<T>, Collection<T>, List<T>, C.Featured, C.List<T>, C.ReversibleSequence<T>, C.Sequence<T>, C.Traversable<T>

Direct Known Subclasses:

CompositeList, Lang.Var, StrBase
```
public abstract class ListBase<T>
extends AbstractList<T>
implements C.List<T>
```

Nested Class Summary
- Nested classes/interfaces inherited from interface org.osgl.util.C.List
  C.List.Cursor<T>
- Nested classes/interfaces inherited from interface org.osgl.util.C.Featured
  C.Featured.Factory

Field Summary
- Fields inherited from class java.util.AbstractList
  modCount

Constructor Summary

Constructors
Constructor and Description

ListBase()

Constructors
Constructor and Description
`ListBase()`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`C.List<T>`	`accept(Lang.IndexedVisitor<Integer,? super T> indexedVisitor)` Loop through the list and for each element, call on the indexedVisitor function specified
`C.List<T>`	`accept(Lang.Visitor<? super T> visitor)` Iterate this `Traversable` with a visitor function.
`C.List<T>`	`acceptLeft(Lang.IndexedVisitor<Integer,? super T> indexedVisitor)` Loop through the list from `0` to `size - 1`.
`C.List<T>`	`acceptLeft(Lang.Visitor<? super T> visitor)` Iterate through this sequence from head to tail with the visitor function specified
`C.List<T>`	`acceptRight(Lang.IndexedVisitor<Integer,? super T> indexedVisitor)` Loop through the list from `size() - 1` to `0`.
`C.List<T>`	`acceptRight(Lang.Visitor<? super T> visitor)` Iterate through this sequence from tail to head with the visitor function specified
`void`	`add(int index, T element)`
`boolean`	`add(T t)`
`boolean`	`addAll(Iterable<? extends T> iterable)` Add all elements from an `Iterable` into this list.
`boolean`	`allMatch(Lang.Function<? super T,Boolean> predicate)` Check if all elements match the predicate specified
`boolean`	`anyMatch(Lang.Function<? super T,Boolean> predicate)` Check if any elements matches the predicate specified
`C.List<T>`	`append(C.List<T> list)` Returns a List contains all elements in this List followed by all elements in the specified List.
`C.ReversibleSequence<T>`	`append(C.ReversibleSequence<T> seq)` Returns an new reversible sequence contains all elements in this sequence followed by all elements in the specified reverse sequence
`C.Sequence<T>`	`append(C.Sequence<? extends T> seq)` Returns a sequence consists of all elements of this sequence followed by all elements of the specified sequence.
`C.List<T>`	`append(Collection<? extends T> collection)`
`C.Sequence<T>`	`append(Enumeration<? extends T> enumeration)` Returns a sequence consists of all elements of this sequence followed by all elements of the specified enumeration.
`C.Sequence<T>`	`append(Iterable<? extends T> iterable)` Returns a sequence consists of all elements of this sequence followed by all elements of the specified iterable.
`C.Sequence<T>`	`append(Iterator<? extends T> iterator)` Returns a sequence consists of all elements of this sequence followed by all elements of the specified iterator.
`C.List<T>`	`append(T t)` Returns a sequence consists of all elements of this sequence followed by the element specified.
`protected C.List<T>`	`appendList(C.List<T> list)`
`protected C.ReversibleSequence<T>`	`appendReversibleSeq(C.ReversibleSequence<T> seq)`
`C.List<T>`	`asList()` Returns a List contains all the elements in this sequence with the same order.
`<R> C.List<R>`	`collect(String path)`
`C.List<T>`	`copy()` Returns a mutable copy of this list
`int`	`count(T t)` Count the element occurence in this sequence
`C.List<T>`	`drop(int n)` Returns a `Sequence` consisting of the elements from this `Sequence` except the first `n` if number `n` is positive and the `Sequence` contains more than `n` elements
`C.List<T>`	`dropWhile(Lang.Function<? super T,Boolean> predicate)` Returns a `Sequence` consisting of the elements from this sequence with leading elements dropped until the predicate returns `true`
`C.List<T>`	`each(Lang.IndexedVisitor<Integer,? super T> indexedVisitor)` Alias of `#accept(Visitor)`
`C.List<T>`	`each(Lang.Visitor<? super T> visitor)` Alias of `C.Traversable.accept(Lang.Visitor)`
`C.List<T>`	`eager()` Returns this traversable and make sure `C.Feature.LAZY` is unset
`protected EnumSet<C.Feature>`	`features_()`
`EnumSet<C.Feature>`	`features()` Get all characteristics in `EnumSet`
`C.List<T>`	`filter(Lang.Function<? super T,Boolean> predicate)` Returns an new traversable that contains all elements in the current traversable except that does not pass the test of the filter function specified.
`Lang.Option<T>`	`findFirst(Lang.Function<? super T,Boolean> predicate)` Apply the predicate specified to the element of this sequence from head to tail.
`Lang.Option<T>`	`findLast(Lang.Function<? super T,Boolean> predicate)` Apply the predicate specified to the element of this sequence from tail to head.
`Lang.Option<T>`	`findOne(Lang.Function<? super T,Boolean> predicate)` Returns an element that matches the predicate specified.
`T`	`first()` Alias of `C.Sequence.head()`
`<R> C.List<R>`	`flatMap(Lang.Function<? super T,? extends Iterable<? extends R>> mapper)` Returns a traversable consisting of the results of replacing each element of this stream with the contents of the iterable produced by applying the provided mapping function to each element.
`C.List<T>`	`forEach(Lang.IndexedVisitor<Integer,? super T> indexedVisitor)` Alias of `#accept(Visitor)`
`C.List<T>`	`forEach(Lang.Visitor<? super T> visitor)` Alias of `C.Traversable.accept(Lang.Visitor)`
`protected void`	`forEachLeft(Lang.IndexedVisitor<Integer,? super T> indexedVisitor)`
`protected void`	`forEachLeft(Lang.Visitor<? super T> visitor)`
`protected void`	`forEachRight(Lang.IndexedVisitor<Integer,? super T> indexedVisitor)`
`protected void`	`forEachRight(Lang.Visitor<? super T> visitor)`
`int`	`hashCode()`
`T`	`head()` Returns an `Lang.Option` of the first element in the `Sequence`
`C.List<T>`	`head(int n)` Alias of `C.Sequence.take(int)`
`protected abstract EnumSet<C.Feature>`	`initFeatures()` Sub class should override this method to provide initial feature set for the feature based instance
`C.List<T>`	`insert(int index, List<T> subList)` Insert a sub list at the position specified by `index`.
`C.List<T>`	`insert(int index, T... ta)` Insert an array of elements at the position specified by `index`.
`C.List<T>`	`insert(int index, T t)` Insert an element at the position specified by `index`.
`boolean`	`is(C.Feature feature)` Check if this object has a certain `C.Feature`
`protected boolean`	`isImmutable()`
`protected boolean`	`isLazy()`
`protected boolean`	`isMutable()`
`protected boolean`	`isReadOnly()`
`Iterator<T>`	`iterator()`
`T`	`last()` Returns the last element from this `Sequence`
`C.List<T>`	`lazy()` Returns this traversable and make sure `C.Feature.LAZY` is set
`abstract ListIterator<T>`	`listIterator(int index)`
`C.List.Cursor<T>`	`locate(Lang.Function<T,Boolean> predicate)` Locate any one element in the list that matches the predicate.
`C.List.Cursor<T>`	`locateFirst(Lang.Function<T,Boolean> predicate)` Find the first element in this list that matches the predicate.
`C.List.Cursor<T>`	`locateLast(Lang.Function<T,Boolean> predicate)` Locate the first element in this list that matches the predicate.
`<R> C.List<R>`	`map(Lang.Function<? super T,? extends R> mapper)` Returns an new traversable with a mapper function specified.
`boolean`	`noneMatch(Lang.Function<? super T,Boolean> predicate)` Check if no elements matches the predicate specified.
`C.List<T>`	`parallel()` Returns this traversable and make sure `C.Feature.PARALLEL` is set
`C.List<T>`	`prepend(C.List<T> list)` This method will NOT change the underline list
`C.ReversibleSequence<T>`	`prepend(C.ReversibleSequence<T> seq)` Returns an new reversible sequence contains all elements in specified reversible sequence followed by all elements in this sequence
`C.Sequence<T>`	`prepend(C.Sequence<? extends T> seq)` Returns a sequence consists of all elements of the sequence specified followed by all elements of this sequence
`C.List<T>`	`prepend(Collection<? extends T> collection)`
`C.Sequence<T>`	`prepend(Enumeration<? extends T> enumeration)` Returns a sequence consists of all elements of the enumeration specified followed by all elements of this sequence
`C.Sequence<T>`	`prepend(Iterable<? extends T> iterable)` Returns a sequence consists of all elements of the iterable specified followed by all elements of this sequence
`C.Sequence<T>`	`prepend(Iterator<? extends T> iterator)` Returns a sequence consists of all elements of the iterator specified followed by all elements of this sequence
`C.List<T>`	`prepend(T t)` Returns a sequence consists of the element specified followed by all elements of this sequence.
`protected C.List<T>`	`prependList(C.List<T> list)`
`protected C.ReversibleSequence<T>`	`prependReversibleSeq(C.ReversibleSequence<T> seq)`
`C.List<T>`	`readOnly()` Returns a view of this list that is readonly.
`Lang.Option<T>`	`reduce(Lang.Func2<T,T,T> accumulator)` Performs a reduction on the elements in this traversable, using provided accumulating function.
`<R> R`	`reduce(R identity, Lang.Func2<R,T,R> accumulator)` Performs a reduction on the elements in this traversable, using the provided identity and accumulating function.
`Lang.Option<T>`	`reduceLeft(Lang.Func2<T,T,T> accumulator)` Run reduction from head to tail.
`<R> R`	`reduceLeft(R identity, Lang.Func2<R,T,R> accumulator)` Run reduction from header side.
`Lang.Option<T>`	`reduceRight(Lang.Func2<T,T,T> accumulator)` Run reduction from tail to head.
`<R> R`	`reduceRight(R identity, Lang.Func2<R,T,R> accumulator)` Run reduction from tail side.
`C.List<T>`	`remove(Lang.Function<? super T,Boolean> predicate)` For mutable list, remove all element that matches the predicate specified from this List and return this list once done.
`C.List<T>`	`reverse()` Returns an new `Sequence` that reverse this `Sequence`.
`Iterator<T>`	`reverseIterator()` Returns an `Iterator` iterate the sequence from tail to head
`C.List<T>`	`sequential()` Returns this traversable and make sure `C.Feature.PARALLEL` is unset
`protected ListBase<T>`	`setFeature(C.Feature feature)`
`C.List<T>`	`snapshot()` Returns an immutable list contains all elements of the current list.
`C.List<T>`	`sorted()` Returns a sorted copy of this list.
`C.List<T>`	`sorted(Comparator<? super T> comparator)` Returns a sorted copy of this list.
`Lang.T2<C.List<T>,C.List<T>>`	`split(Lang.Function<? super T,Boolean> predicate)` Split this list into two list based on the predicate specified.
`C.List<T>`	`subList(int fromIndex, int toIndex)`
`C.List<T>`	`tail()` Returns the rest part of the `Sequence` except the first element
`C.List<T>`	`tail(int n)` Returns a `Sequence` consisting the last `n` elements from this `Sequence` if number `n` is positive and the `Sequence` contains more than `n` elements
`C.List<T>`	`take(int n)` Returns a `Sequence` consisting the first `n` elements from this `Sequence` if number `n` is positive and the `Sequence` contains more than `n` elements
`C.List<T>`	`takeWhile(Lang.Function<? super T,Boolean> predicate)` Returns an new `Sequence` that takes the head of this `Sequence` until the predicate evaluate to `false`:
`<K,V> C.Map<K,V>`	`toMap(Lang.Function<? super T,? extends K> keyExtractor, Lang.Function<? super T,? extends V> valExtractor)` Create a `Map` from this list using a key extract function and a value extract function
`<V> C.Map<T,V>`	`toMapByKey(Lang.Function<? super T,? extends V> valExtractor)` Create a `Map` from this list using a value extract function.
`<K> C.Map<K,T>`	`toMapByVal(Lang.Function<? super T,? extends K> keyExtractor)` Create a `Map` from this list using a key extract function.
`C.List<T>`	`unique()` Return a list that contains unique set of this list and keep the orders.
`C.List<T>`	`unique(Comparator<T> comp)` Return a list that contains unique set as per the comparator specified of this list and keep the orders.
`protected ListBase<T>`	`unsetFeature(C.Feature feature)`
`C.List<T>`	`without(Collection<? super T> col)` Returns a List contains all elements in this List and not in the `col` collection specified
`C.List<T>`	`without(T element)` Returns a list contains all elements in the list except the one specified
`C.List<T>`	`without(T element, T... elements)` Returns a list contains all elements in the list except the ones specified
`<T2> C.ReversibleSequence<Lang.Binary<T,T2>>`	`zip(C.ReversibleSequence<T2> rseq)`
`<T2> C.Sequence<? extends Lang.Binary<T,T2>>`	`zip(Iterable<T2> iterable)` Returns a sequence formed from this sequence and another iterable collection by combining corresponding elements in pairs.
`<T2> C.List<Lang.Binary<T,T2>>`	`zip(List<T2> list)` Returns a list formed from this list and another iterable collection by combining corresponding elements in pairs.
`<T2> C.ReversibleSequence<Lang.Binary<T,T2>>`	`zipAll(C.ReversibleSequence<T2> rseq, T def1, T2 def2)`
`<T2> C.Sequence<? extends Lang.Binary<T,T2>>`	`zipAll(Iterable<T2> iterable, T def1, T2 def2)` Returns a sequence formed from this sequence and another iterable collection by combining corresponding elements in pairs.
`<T2> C.List<Lang.Binary<T,T2>>`	`zipAll(List<T2> list, T def1, T2 def2)` Returns a list formed from this list and another iterable collection by combining corresponding elements in pairs.
`C.Sequence<Lang.Binary<T,Integer>>`	`zipWithIndex()` Zip this sequence with its indices

Methods inherited from class java.util.AbstractList
addAll, clear, equals, get, indexOf, lastIndexOf, listIterator, remove, removeRange, set

Methods inherited from class java.util.AbstractCollection
addAll, contains, containsAll, isEmpty, remove, removeAll, retainAll, size, toArray, toArray, toString

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.List
addAll, addAll, clear, contains, containsAll, equals, get, indexOf, isEmpty, lastIndexOf, listIterator, remove, remove, removeAll, replaceAll, retainAll, set, size, sort, spliterator, toArray, toArray

Methods inherited from interface java.util.Collection
parallelStream, removeIf, stream

Methods inherited from interface org.osgl.util.C.Traversable
isEmpty, size

Methods inherited from interface java.lang.Iterable
forEach

- Constructor Detail
  - ListBase
```
public ListBase()
```
- Method Detail
  - isLazy
```
protected final boolean isLazy()
```
  - isImmutable
```
protected final boolean isImmutable()
```
  - isReadOnly
```
protected final boolean isReadOnly()
```
  - isMutable
```
protected final boolean isMutable()
```
  - forEachLeft
```
protected void forEachLeft(Lang.Visitor<? super T> visitor)
                    throws Lang.Break
```
    Throws:
    
    Lang.Break
  - forEachLeft
```
protected void forEachLeft(Lang.IndexedVisitor<Integer,? super T> indexedVisitor)
                    throws Lang.Break
```
    Throws:
    
    Lang.Break
  - forEachRight
```
protected void forEachRight(Lang.Visitor<? super T> visitor)
                     throws Lang.Break
```
    Throws:
    
    Lang.Break
  - forEachRight
```
protected void forEachRight(Lang.IndexedVisitor<Integer,? super T> indexedVisitor)
                     throws Lang.Break
```
    Throws:
    
    Lang.Break
  - parallel
```
public C.List<T> parallel()
```
    Description copied from interface: C.List
    
    Returns this traversable and make sure C.Feature.PARALLEL is set
    
    Specified by:
    
    parallel in interface C.List<T>
    
    Specified by:
    
    parallel in interface C.ReversibleSequence<T>
    
    Specified by:
    
    parallel in interface C.Sequence<T>
    
    Specified by:
    
    parallel in interface C.Traversable<T>
    
    Returns:
    
    this reference with parallel turned on
  - sequential
```
public C.List<T> sequential()
```
    Description copied from interface: C.List
    
    Returns this traversable and make sure C.Feature.PARALLEL is unset
    
    Specified by:
    
    sequential in interface C.List<T>
    
    Specified by:
    
    sequential in interface C.ReversibleSequence<T>
    
    Specified by:
    
    sequential in interface C.Sequence<T>
    
    Specified by:
    
    sequential in interface C.Traversable<T>
    
    Returns:
    
    this reference with parallel turned off
  - lazy
```
public C.List<T> lazy()
```
    Description copied from interface: C.List
    
    Returns this traversable and make sure C.Feature.LAZY is set
    
    Specified by:
    
    lazy in interface C.List<T>
    
    Specified by:
    
    lazy in interface C.ReversibleSequence<T>
    
    Specified by:
    
    lazy in interface C.Sequence<T>
    
    Specified by:
    
    lazy in interface C.Traversable<T>
    
    Returns:
    
    this reference with lazy turned on
  - eager
```
public C.List<T> eager()
```
    Description copied from interface: C.List
    
    Returns this traversable and make sure C.Feature.LAZY is unset
    
    Specified by:
    
    eager in interface C.List<T>
    
    Specified by:
    
    eager in interface C.ReversibleSequence<T>
    
    Specified by:
    
    eager in interface C.Sequence<T>
    
    Specified by:
    
    eager in interface C.Traversable<T>
    
    Returns:
    
    this reference with lazy turned off
  - snapshot
```
public C.List<T> snapshot()
```
    Description copied from interface: C.List
    
    Returns an immutable list contains all elements of the current list. If the current list is immutable, then return the current list itself.
    
    Specified by:
    
    snapshot in interface C.List<T>
    
    Returns:
    
    an immutable list.
    
    See Also:
    
    C.List.readOnly()
  - readOnly
```
public C.List<T> readOnly()
```
    Description copied from interface: C.List
    
    Returns a view of this list that is readonly. If the current list is readonly or immutable then return the current list itself
    
    Specified by:
    
    readOnly in interface C.List<T>
    
    Returns:
    
    a readonly view of this list
  - copy
```
public C.List<T> copy()
```
    Description copied from interface: C.List
    
    Returns a mutable copy of this list
    
    Specified by:
    
    copy in interface C.List<T>
    
    Returns:
    
    a mutable list contains all elements of this list
  - sorted
```
public C.List<T> sorted()
```
    Description copied from interface: C.List
    
    Returns a sorted copy of this list.
    Note if the element type T is not a Comparable then this method returns a copy of this list without any order changes
    
    Specified by:
    
    sorted in interface C.List<T>
    
    Returns:
    
    a sorted copy of this list
  - sorted
```
public C.List<T> sorted(Comparator<? super T> comparator)
```
    Description copied from interface: C.List
    
    Returns a sorted copy of this list. The order is specified by the comparator provided
    
    Specified by:
    
    sorted in interface C.List<T>
    
    Parameters:
    
    comparator - specify the order of elements in the result list
    
    Returns:
    
    an ordered copy of this list
  - unique
```
public C.List<T> unique()
```
    Description copied from interface: C.List
    
    Return a list that contains unique set of this list and keep the orders. If this list doesn’t have duplicated items, it could return this list directly or choose to return an new copy of this list depends on the sub class implementation
    
    Specified by:
    
    unique in interface C.List<T>
    
    Returns:
    
    a list contains only unique elements in this list
  - unique
```
public C.List<T> unique(Comparator<T> comp)
```
    Description copied from interface: C.List
    
    Return a list that contains unique set as per the comparator specified of this list and keep the orders. If this list doesn’t have duplicated items, it could return this list directly or choose to return an new copy of this list depends on the sub class implementation
    
    Specified by:
    
    unique in interface C.List<T>
    
    Parameters:
    
    comp - the comparator check the duplicate elements
    
    Returns:
    
    a list contains unique element as per the comparator
  - subList
```
public C.List<T> subList(int fromIndex,
                         int toIndex)
```
    Specified by:
    
    subList in interface List<T>
    
    Specified by:
    
    subList in interface C.List<T>
    
    Overrides:
    
    subList in class AbstractList<T>
  - add
```
public boolean add(T t)
```
    Specified by:
    
    add in interface Collection<T>
    
    Specified by:
    
    add in interface List<T>
    
    Overrides:
    
    add in class AbstractList<T>
  - add
```
public void add(int index,
                T element)
```
    Specified by:
    
    add in interface List<T>
    
    Overrides:
    
    add in class AbstractList<T>
  - addAll
```
public boolean addAll(Iterable<? extends T> iterable)
```
    Description copied from interface: C.List
    
    Add all elements from an Iterable into this list. Return true if the list has changed as a result of call.
    Note if this list is immutable or readonly, UnsupportedOperationException will be thrown out with this call
    
    Specified by:
    
    addAll in interface C.List<T>
    
    Parameters:
    
    iterable - the iterable provides the elements to be added into the list
    
    Returns:
    
    true if this list changed as result of addd
  - hashCode
```
public int hashCode()
```
    Specified by:
    
    hashCode in interface Collection<T>
    
    Specified by:
    
    hashCode in interface List<T>
    
    Overrides:
    
    hashCode in class AbstractList<T>
  - features_
```
protected final EnumSet<C.Feature> features_()
```
  - initFeatures
```
protected abstract EnumSet<C.Feature> initFeatures()
```
    Sub class should override this method to provide initial feature set for the feature based instance
    
    Returns:
    
    the initial feature set configuration
  - features
```
public final EnumSet<C.Feature> features()
```
    Description copied from interface: C.Featured
    
    Get all characteristics in EnumSet
    
    Specified by:
    
    features in interface C.Featured
    
    Returns:
    
    an EnumSet of all characteristics hold by this object
  - is
```
public final boolean is(C.Feature feature)
```
    Description copied from interface: C.Featured
    
    Check if this object has a certain C.Feature
    
    Specified by:
    
    is in interface C.Featured
    
    Parameters:
    
    feature - the characteristic to be tested
    
    Returns:
    
    true if this object has the characteristic, or false otherwise
  - setFeature
```
protected ListBase<T> setFeature(C.Feature feature)
```
  - unsetFeature
```
protected ListBase<T> unsetFeature(C.Feature feature)
```
  - allMatch
```
public boolean allMatch(Lang.Function<? super T,Boolean> predicate)
```
    Description copied from interface: C.Traversable
    
    Check if all elements match the predicate specified
    
    Specified by:
    
    allMatch in interface C.Traversable<T>
    
    Parameters:
    
    predicate - the function to test the element
    
    Returns:
    
    true if all elements match the predicate
  - anyMatch
```
public boolean anyMatch(Lang.Function<? super T,Boolean> predicate)
```
    Description copied from interface: C.Traversable
    
    Check if any elements matches the predicate specified
    
    Specified by:
    
    anyMatch in interface C.Traversable<T>
    
    Parameters:
    
    predicate - the function to test the element
    
    Returns:
    
    true if any element matches the predicate
  - noneMatch
```
public boolean noneMatch(Lang.Function<? super T,Boolean> predicate)
```
    Description copied from interface: C.Traversable
    Check if no elements matches the predicate specified. This should be equivalent to:
```
  this.allMatch(_.F.negate(predicate)); 
```
    Specified by:
    
    noneMatch in interface C.Traversable<T>
    
    Parameters:
    
    predicate - the function to test the element
    
    Returns:
    
    true if none element matches the predicate
  - findOne
```
public Lang.Option<T> findOne(Lang.Function<? super T,Boolean> predicate)
```
    Description copied from interface: C.Traversable
    
    Returns an element that matches the predicate specified. The interface does not indicate if it should be the first element matches the predicate be returned or in case of parallel computing, whatever element matches found first is returned. It’s all up to the implementation to refine the semantic of this method
    
    Specified by:
    
    findOne in interface C.Traversable<T>
    
    Parameters:
    
    predicate - the function map element to Boolean
    
    Returns:
    
    an element in this traversal that matches the predicate or Lang.NONE if no element matches
  - asList
```
public C.List<T> asList()
```
    Description copied from interface: C.Sequence
    
    Returns a List contains all the elements in this sequence with the same order.
    
    Specified by:
    
    asList in interface C.Sequence<T>
    
    Returns:
    
    the list as described above
  - iterator
```
public Iterator<T> iterator()
```
    Specified by:
    
    iterator in interface Iterable<T>
    
    Specified by:
    
    iterator in interface Collection<T>
    
    Specified by:
    
    iterator in interface List<T>
    
    Overrides:
    
    iterator in class AbstractList<T>
  - listIterator
```
public abstract ListIterator<T> listIterator(int index)
```
    Specified by:
    
    listIterator in interface List<T>
    
    Overrides:
    
    listIterator in class AbstractList<T>
  - reverseIterator
```
public Iterator<T> reverseIterator()
```
    Description copied from interface: C.ReversibleSequence
    
    Returns an Iterator iterate the sequence from tail to head
    
    Specified by:
    
    reverseIterator in interface C.ReversibleSequence<T>
    
    Returns:
    
    the iterator
  - first
```
public final T first()
              throws NoSuchElementException
```
    Description copied from interface: C.Sequence
    
    Alias of C.Sequence.head()
    
    Specified by:
    
    first in interface C.Sequence<T>
    
    Returns:
    
    the first element in the sequence
    
    Throws:
    
    NoSuchElementException
  - head
```
public T head()
       throws NoSuchElementException
```
    Description copied from interface: C.Sequence
    
    Returns an Lang.Option of the first element in the Sequence
    
    Specified by:
    
    head in interface C.Sequence<T>
    
    Returns:
    
    the first element from the Sequence
    
    Throws:
    
    NoSuchElementException - if the Sequence is empty
    
    See Also:
    
    C.Sequence.tail(), C.Sequence.first()
  - last
```
public T last()
       throws NoSuchElementException
```
    Description copied from interface: C.ReversibleSequence
    
    Returns the last element from this Sequence
    
    Specified by:
    
    last in interface C.ReversibleSequence<T>
    
    Returns:
    
    the last element
    
    Throws:
    
    NoSuchElementException - if the Sequence is empty
    
    See Also:
    
    C.Traversable.isEmpty(), C.Feature.LIMITED, C.Featured.is(org.osgl.util.C.Feature)
  - take
```
public C.List<T> take(int n)
```
    Description copied from interface: C.List
    Returns a Sequence consisting the first n elements from this Sequence if number n is positive and the Sequence contains more than n elements
    If this Sequence contains less than n elements, then a Sequence consisting the whole elements of this Sequence is returned. Note it might return this Sequence itself if the Sequence is immutable.
    
    If the number n is zero, then an empty Sequence is returned in reverse order
    
    If the number n is negative, then the last -n elements from this Sequence is returned in an new Sequence, or throw UnsupportedOperationException if this operation is not supported
```
  Sequence seq = C.list(1, 2, 3, 4);  assertEquals(C.list(1, 2), seq.take(2));  assertEquals(C.list(1, 2, 3, 4), seq.take(100));  assertEquals(C.list(), seq.take(0));  assertEquals(C.list(3, 4), seq.take(-2));  assertEquals(C.list(1, 2, 3, 4), seq.take(-200)); 
```
    This method does not alter the underline list
    Specified by:
    
    take in interface C.List<T>
    
    Specified by:
    
    take in interface C.ReversibleSequence<T>
    
    Specified by:
    
    take in interface C.Sequence<T>
    
    Parameters:
    
    n - specify the number of elements to be taken from the head of this Sequence
    
    Returns:
    
    A list contains first n items in this list
    
    See Also:
    
    C.Sequence.head(int)
  - takeWhile
```
public C.List<T> takeWhile(Lang.Function<? super T,Boolean> predicate)
```
    Description copied from interface: C.List
    Returns an new Sequence that takes the head of this Sequence until the predicate evaluate to false:
```
  C.Sequence seq = C.list(1, 2, 3, 4, 5, 4, 3, 2, 1);  assertEquals(C.list(C.list(1, 2, 3), seq.takeWhile(_.F.lt(4)));  assertEquals(C.list(C.list(1, 2, 3, 3, 2, 1), seq.filter(_.F.lt(4))); 
```
    This method does not alter the underline list
    Specified by:
    
    takeWhile in interface C.List<T>
    
    Specified by:
    
    takeWhile in interface C.ReversibleSequence<T>
    
    Specified by:
    
    takeWhile in interface C.Sequence<T>
    
    Parameters:
    
    predicate - specify which the elements in this Sequence will put into the new Sequence
    
    Returns:
    
    an new reversible sequence contains the elements in this sequence until predicate evaluate to false
  - drop
```
public C.List<T> drop(int n)
               throws IndexOutOfBoundsException
```
    Description copied from interface: C.List
    Returns a Sequence consisting of the elements from this Sequence except the first n if number n is positive and the Sequence contains more than n elements
    If this Sequence contains less than n elements, then an empty Sequence is returned
    
    If the number n is zero, then a copy of this Sequence or this Sequence itself is returned depending on the implementation
    
    If the number n is negative, then either IllegalArgumentException should be thrown out if this sequence is not C.Feature.LIMITED or it drop -n element starts from the tail side
```
  C.Sequence seq = C.list(1, 2, 3, 4, 5);  assertEquals(C.list(3, 4, 5), seq.drop(2));  assertEquals(C.list(1, 2, 3, 4, 5), seq.drop(0));  assertEquals(C.list(), seq.drop(100)); 
```
    Note this method does NOT modify the current sequence, instead it returns an new sequence structure containing the elements as required
    
    This method does not alter the underline list
    Specified by:
    
    drop in interface C.List<T>
    
    Specified by:
    
    drop in interface C.ReversibleSequence<T>
    
    Specified by:
    
    drop in interface C.Sequence<T>
    
    Parameters:
    
    n - specify the number of elements to be taken from the head of this Sequence or the -n number of elements to be taken from the tail of this sequence if n is an negative number
    
    Returns:
    
    a List contains all elements of this list except the first n number
    
    Throws:
    
    IndexOutOfBoundsException
  - dropWhile
```
public C.List<T> dropWhile(Lang.Function<? super T,Boolean> predicate)
```
    Description copied from interface: C.List
    Returns a Sequence consisting of the elements from this sequence with leading elements dropped until the predicate returns true
```
  Sequence seq = C.list(1, 2, 3, 4, 3, 2, 1);  assertTrue(C.list(), seq.dropWhile(_.F.gt(100)));  assertTrue(C.list(4, 3, 2, 1), seq.dropWhile(_.F.lt(3))); 
```
    Note this method does NOT modify the current sequence, instead it returns an new sequence structure containing the elements as required
    
    This method does not alter the underline list
    Specified by:
    
    dropWhile in interface C.List<T>
    
    Specified by:
    
    dropWhile in interface C.ReversibleSequence<T>
    
    Specified by:
    
    dropWhile in interface C.Sequence<T>
    
    Parameters:
    
    predicate - the predicate function
    
    Returns:
    
    the sequence after applying the drop operations
  - remove
```
public C.List<T> remove(Lang.Function<? super T,Boolean> predicate)
```
    Description copied from interface: C.List
    
    For mutable list, remove all element that matches the predicate specified from this List and return this list once done.
    For immutable or readonly list, an new List contains all element from this list that does not match the predicate specified is returned
    
    Specified by:
    
    remove in interface C.List<T>
    
    Parameters:
    
    predicate - test whether an element should be removed frmo return list
    
    Returns:
    
    a list contains all element that does not match the predicate specified
  - map
```
public <R> C.List<R> map(Lang.Function<? super T,? extends R> mapper)
```
    Description copied from interface: C.Sequence
    Returns an new traversable with a mapper function specified. The element in the new traversal is the result of the mapper function applied to this traversal element.
```
  Traversable traversable = C.list(23, .NONE, null);  assertEquals(C.list(true, false, false), traversal.map(.F.NOT_NULL));  assertEquals(C.list(“23”, "“, ”"), traversal.map(_.F.AS_STRING)); 
```
    For Lazy Traversable, it must use lazy evaluation for this method. Otherwise it is up to implementation to decide whether use lazy evaluation or not
    Specified by:
    
    map in interface C.List<T>
    
    Specified by:
    
    map in interface C.ReversibleSequence<T>
    
    Specified by:
    
    map in interface C.Sequence<T>
    
    Specified by:
    
    map in interface C.Traversable<T>
    
    Type Parameters:
    
    R - the element type of the new traversal
    
    Parameters:
    
    mapper - the function that applied to element in this traversal and returns element in the result traversal
    
    Returns:
    
    a Sequence of R that are mapped from this sequence
  - flatMap
```
public <R> C.List<R> flatMap(Lang.Function<? super T,? extends Iterable<? extends R>> mapper)
```
    Description copied from interface: C.List
    
    Returns a traversable consisting of the results of replacing each element of this stream with the contents of the iterable produced by applying the provided mapping function to each element. If the result of the mapping function is null, this is treated as if the result is an empty traversable.
    
    Specified by:
    
    flatMap in interface C.List<T>
    
    Specified by:
    
    flatMap in interface C.ReversibleSequence<T>
    
    Specified by:
    
    flatMap in interface C.Sequence<T>
    
    Specified by:
    
    flatMap in interface C.Traversable<T>
    
    Type Parameters:
    
    R - the element type of the the new traversable
    
    Parameters:
    
    mapper - the function produce an iterable when applied to an element
    
    Returns:
    
    a List of R type element that are mapped from this sequences
  - collect
```
public <R> C.List<R> collect(String path)
```
    Specified by:
    
    collect in interface C.List<T>
    
    Specified by:
    
    collect in interface C.Sequence<T>
    
    Specified by:
    
    collect in interface C.Traversable<T>
  - filter
```
public C.List<T> filter(Lang.Function<? super T,Boolean> predicate)
```
    Description copied from interface: C.Sequence
    Returns an new traversable that contains all elements in the current traversable except that does not pass the test of the filter function specified.
```
  Traversable traversable = C.list(-1, 0, 1, -3, 7);  Traversable filtered = traversable.filter(_.F.gt(0));  assertTrue(filtered.contains(1));  assertFalse(filtered.contains(-3)); 
```
    Specified by:
    
    filter in interface C.List<T>
    
    Specified by:
    
    filter in interface C.ReversibleSequence<T>
    
    Specified by:
    
    filter in interface C.Sequence<T>
    
    Specified by:
    
    filter in interface C.Traversable<T>
    
    Parameters:
    
    predicate - the function that test if the element in the traversable should be kept in the resulting traversable. When applying the filter function to the element, if the result is true then the element will be kept in the resulting traversable.
    
    Returns:
    
    An new Sequence consists of elements that passed the predicate
  - split
```
public Lang.T2<C.List<T>,C.List<T>> split(Lang.Function<? super T,Boolean> predicate)
```
    Description copied from interface: C.List
    
    Split this list into two list based on the predicate specified.
    The function use the predicate to test all elements in this list. If test passed then it add the element into left side list, otherwise the element will be added into right side list. The result is returned as a tuple contains the left and right side lift
    
    Specified by:
    
    split in interface C.List<T>
    
    Parameters:
    
    predicate - the function to test the elements in this list
    
    Returns:
    
    a tuple of two lists
  - locateFirst
```
public C.List.Cursor<T> locateFirst(Lang.Function<T,Boolean> predicate)
```
    Description copied from interface: C.List
    
    Find the first element in this list that matches the predicate. Return a cursor point to the location of the element. If no such element is found then a cursor that point to -1 is returned.
    
    Specified by:
    
    locateFirst in interface C.List<T>
    
    Parameters:
    
    predicate - test the element
    
    Returns:
    
    the reference to the list itself or an new List without the first element matches the predicate if this is a readonly list
  - locate
```
public C.List.Cursor<T> locate(Lang.Function<T,Boolean> predicate)
```
    Description copied from interface: C.List
    
    Locate any one element in the list that matches the predicate. Returns the cursor point to the element found, or a cursor that is not defined if no such element found in the list. In a parallel locating the element been found might not be the first element matches the predicate
    
    Specified by:
    
    locate in interface C.List<T>
    
    Parameters:
    
    predicate - the function that used to check the element at the cursor
    
    Returns:
    
    the reference to the list itself or an new List without and element matches the predicate if this is a readonly list
  - locateLast
```
public C.List.Cursor<T> locateLast(Lang.Function<T,Boolean> predicate)
```
    Description copied from interface: C.List
    
    Locate the first element in this list that matches the predicate. Return a cursor point to the location of the element. If no such element is found then a cursor that point to -1 is returned.
    
    Specified by:
    
    locateLast in interface C.List<T>
    
    Parameters:
    
    predicate - test the element
    
    Returns:
    
    the reference to the list itself or an new List without the first element matches the predicate if this is a readonly list
  - insert
```
public C.List<T> insert(int index,
                        T t)
                 throws IndexOutOfBoundsException
```
    Description copied from interface: C.List
    
    Insert an element at the position specified by index.
    If this list is readonly or immutable, then an new list should be created with all elements in this list and the new element inserted at the specified position. The new list should have the same feature as this list
    
    If index is less than zero then it will insert at (size() + index)
    
    Specified by:
    
    insert in interface C.List<T>
    
    Parameters:
    
    index - specify the position where the element should be inserted
    
    t - the element to be inserted
    
    Returns:
    
    a list as specified above
    
    Throws:
    
    IndexOutOfBoundsException - Math.abs(index) > size()
  - insert
```
public C.List<T> insert(int index,
                        T... ta)
                 throws IndexOutOfBoundsException
```
    Description copied from interface: C.List
    
    Insert an array of elements at the position specified by index.
    If this list is readonly or immutable, then an new list should be created with all elements in this list and the new element inserted at the specified position. The new list should have the same feature as this list
    
    If index is less than zero then it will insert at (size() + index)
    
    Specified by:
    
    insert in interface C.List<T>
    
    Parameters:
    
    index - specify the position where the element should be inserted
    
    ta - the array of elements to be inserted
    
    Returns:
    
    a list as specified above
    
    Throws:
    
    IndexOutOfBoundsException - Math.abs(index) > size()
  - insert
```
public C.List<T> insert(int index,
                        List<T> subList)
                 throws IndexOutOfBoundsException
```
    Description copied from interface: C.List
    
    Insert a sub list at the position specified by index.
    If this list is readonly or immutable, then an new list should be created with all elements in this list and the elements of sub list inserted at the specified position. The new list should have the same feature as this list
    
    If index is less than zero then it will insert at (size() + index)
    
    Specified by:
    
    insert in interface C.List<T>
    
    Parameters:
    
    index - specify the position where the element should be inserted
    
    subList - the sub list contains elements to be inserted
    
    Returns:
    
    a list as specified above
    
    Throws:
    
    IndexOutOfBoundsException - Math.abs(index) > size()
  - reverse
```
public C.List<T> reverse()
```
    Description copied from interface: C.ReversibleSequence
    
    Returns an new Sequence that reverse this Sequence.
    
    Specified by:
    
    reverse in interface C.List<T>
    
    Specified by:
    
    reverse in interface C.ReversibleSequence<T>
    
    Returns:
    
    a reversed Sequence
    
    See Also:
    
    C.Feature.LIMITED, C.Featured.is(org.osgl.util.C.Feature)
  - without
```
public C.List<T> without(Collection<? super T> col)
```
    Description copied from interface: C.List
    
    Returns a List contains all elements in this List and not in the col collection specified
    
    Specified by:
    
    without in interface C.List<T>
    
    Parameters:
    
    col - the collection in which elements should be excluded from the result List
    
    Returns:
    
    a List contains elements only in this list
  - without
```
public C.List<T> without(T element)
```
    Description copied from interface: C.List
    
    Returns a list contains all elements in the list except the one specified
    
    Specified by:
    
    without in interface C.List<T>
    
    Parameters:
    
    element - the element that should not be in the resulting list
    
    Returns:
    
    a list without the element specified
  - without
```
public C.List<T> without(T element,
                         T... elements)
```
    Description copied from interface: C.List
    
    Returns a list contains all elements in the list except the ones specified
    
    Specified by:
    
    without in interface C.List<T>
    
    Parameters:
    
    element - the element that should not be in the resulting list
    
    elements - the array contains elements that should not be in the resulting list
    
    Returns:
    
    a list without the element specified
  - accept
```
public C.List<T> accept(Lang.Visitor<? super T> visitor)
```
    Description copied from interface: C.Traversable
    
    Iterate this Traversable with a visitor function. This method does not specify the approach to iterate through this structure. The implementation might choose iterate from left to right, or vice versa. It might even choose to split the structure into multiple parts, and iterate through them in parallel
    
    Specified by:
    
    accept in interface C.List<T>
    
    Specified by:
    
    accept in interface C.ReversibleSequence<T>
    
    Specified by:
    
    accept in interface C.Sequence<T>
    
    Specified by:
    
    accept in interface C.Traversable<T>
    
    Parameters:
    
    visitor - a function that apply to element in this Traversable. The return value of the function is ignored
    
    Returns:
    
    this Traversable instance for chained call
  - each
```
public C.List<T> each(Lang.Visitor<? super T> visitor)
```
    Description copied from interface: C.Traversable
    
    Alias of C.Traversable.accept(Lang.Visitor)
    
    Specified by:
    
    each in interface C.List<T>
    
    Specified by:
    
    each in interface C.ReversibleSequence<T>
    
    Specified by:
    
    each in interface C.Sequence<T>
    
    Specified by:
    
    each in interface C.Traversable<T>
    
    Parameters:
    
    visitor - the visitor to tranverse the elements
    
    Returns:
    
    this Traversable instance
  - forEach
```
public C.List<T> forEach(Lang.Visitor<? super T> visitor)
```
    Description copied from interface: C.Traversable
    
    Alias of C.Traversable.accept(Lang.Visitor)
    
    Specified by:
    
    forEach in interface C.List<T>
    
    Specified by:
    
    forEach in interface C.ReversibleSequence<T>
    
    Specified by:
    
    forEach in interface C.Sequence<T>
    
    Specified by:
    
    forEach in interface C.Traversable<T>
    
    Parameters:
    
    visitor - the visitor function
    
    Returns:
    
    this Traversable instance
  - acceptLeft
```
public C.List<T> acceptLeft(Lang.Visitor<? super T> visitor)
```
    Description copied from interface: C.Sequence
    
    Iterate through this sequence from head to tail with the visitor function specified
    
    Specified by:
    
    acceptLeft in interface C.List<T>
    
    Specified by:
    
    acceptLeft in interface C.ReversibleSequence<T>
    
    Specified by:
    
    acceptLeft in interface C.Sequence<T>
    
    Parameters:
    
    visitor - the function to visit elements in this sequence
    
    Returns:
    
    this sequence
    
    See Also:
    
    C.Traversable.accept(Lang.Visitor), C.ReversibleSequence.acceptRight(Lang.Visitor)
  - acceptRight
```
public C.List<T> acceptRight(Lang.Visitor<? super T> visitor)
```
    Description copied from interface: C.ReversibleSequence
    
    Iterate through this sequence from tail to head with the visitor function specified
    
    Specified by:
    
    acceptRight in interface C.List<T>
    
    Specified by:
    
    acceptRight in interface C.ReversibleSequence<T>
    
    Parameters:
    
    visitor - the function to visit elements in this sequence
    
    Returns:
    
    this sequence
    
    See Also:
    
    C.Traversable.accept(Lang.Visitor), C.Sequence.acceptLeft(Lang.Visitor)
  - accept
```
public C.List<T> accept(Lang.IndexedVisitor<Integer,? super T> indexedVisitor)
```
    Description copied from interface: C.List
    
    Loop through the list and for each element, call on the indexedVisitor function specified
    
    Specified by:
    
    accept in interface C.List<T>
    
    Parameters:
    
    indexedVisitor - the function to be called on each element along with the index
    
    Returns:
    
    this list
  - each
```
public C.List<T> each(Lang.IndexedVisitor<Integer,? super T> indexedVisitor)
```
    Description copied from interface: C.List
    
    Alias of #accept(Visitor)
    
    Specified by:
    
    each in interface C.List<T>
    
    Parameters:
    
    indexedVisitor - the function to be called on each element along with the index
    
    Returns:
    
    this list
  - forEach
```
public C.List<T> forEach(Lang.IndexedVisitor<Integer,? super T> indexedVisitor)
```
    Description copied from interface: C.List
    
    Alias of #accept(Visitor)
    
    Specified by:
    
    forEach in interface C.List<T>
    
    Parameters:
    
    indexedVisitor - the function to be called on each element along with the index
    
    Returns:
    
    this list
  - acceptLeft
```
public C.List<T> acceptLeft(Lang.IndexedVisitor<Integer,? super T> indexedVisitor)
```
    Description copied from interface: C.List
    
    Loop through the list from 0 to size - 1. Call the indexedVisitor function on each element along with the index
    
    Specified by:
    
    acceptLeft in interface C.List<T>
    
    Parameters:
    
    indexedVisitor - the function to be called on each element along with the index
    
    Returns:
    
    this list
  - acceptRight
```
public C.List<T> acceptRight(Lang.IndexedVisitor<Integer,? super T> indexedVisitor)
```
    Description copied from interface: C.List
    
    Loop through the list from size() - 1 to 0. Call the indexedVisitor function on each element along with the index
    
    Specified by:
    
    acceptRight in interface C.List<T>
    
    Parameters:
    
    indexedVisitor - the function to be called on each element along with the index
    
    Returns:
    
    this list
  - head
```
public C.List<T> head(int n)
```
    Description copied from interface: C.List
    
    Alias of C.Sequence.take(int)
    
    Specified by:
    
    head in interface C.List<T>
    
    Specified by:
    
    head in interface C.ReversibleSequence<T>
    
    Specified by:
    
    head in interface C.Sequence<T>
    
    Parameters:
    
    n - specify the number of elements to be included in the return list
    
    Returns:
    
    A List contains first n items in this List
  - tail
```
public C.List<T> tail()
```
    Description copied from interface: C.List
    
    Returns the rest part of the Sequence except the first element
    
    Specified by:
    
    tail in interface C.List<T>
    
    Specified by:
    
    tail in interface C.ReversibleSequence<T>
    
    Specified by:
    
    tail in interface C.Sequence<T>
    
    Returns:
    
    A list contains all elements in this list except the first one
    
    See Also:
    
    C.Sequence.head(), C.ReversibleSequence.tail(int)
  - tail
```
public C.List<T> tail(int n)
```
    Description copied from interface: C.List
    Returns a Sequence consisting the last n elements from this Sequence if number n is positive and the Sequence contains more than n elements
    If this Sequence contains less than n elements, then a Sequence consisting the whole elements of this Sequence is returned. Note it might return this Sequence itself if the Sequence is immutable.
    
    If the number n is zero, then an empty Sequence is returned in reverse order
    
    If the number n is negative, then the first -n elements from this Sequence is returned in an new Sequence
```
  Sequence seq = C1.list(1, 2, 3, 4);  assertEquals(C1.list(3, 4), seq.tail(2));  assertEquals(C1.list(1, 2, 3, 4), seq.tail(100));  assertEquals(C1.list(), seq.tail(0));  assertEquals(C1.list(1, 2, 3), seq.tail(-3));  assertEquals(C1.list(1, 2, 3, 4), seq.tail(-200)); 
```
    This method does not mutate the underline container
    
    This method does not alter the underline list
    Specified by:
    
    tail in interface C.List<T>
    
    Specified by:
    
    tail in interface C.ReversibleSequence<T>
    
    Parameters:
    
    n - specify the number of elements to be taken from the tail of this Sequence
    
    Returns:
    
    A list contains last n items in this list
    
    See Also:
    
    C.Feature.LIMITED, C.Featured.is(org.osgl.util.C.Feature)
  - append
```
public C.Sequence<T> append(Iterable<? extends T> iterable)
```
    Description copied from interface: C.Sequence
    
    Returns a sequence consists of all elements of this sequence followed by all elements of the specified iterable.
    An immutable Sequence must return an new Sequence; while a mutable Sequence implementation might append specified seq to this sequence instance directly
    
    Specified by:
    
    append in interface C.Sequence<T>
    
    Parameters:
    
    iterable - the iterable in which elements will be append to this sequence
    
    Returns:
    
    the sequence after append the iterable
  - append
```
public C.List<T> append(Collection<? extends T> collection)
```
    Description copied from interface: C.List
    
    Specified by:
    
    append in interface C.List<T>
    
    Parameters:
    
    collection - the iterable from which elements will be appended to this list
    
    Returns:
    
    a List contains all elements of this list followed by all elements in the iterable
  - append
```
public C.Sequence<T> append(C.Sequence<? extends T> seq)
```
    Description copied from interface: C.Sequence
    
    Returns a sequence consists of all elements of this sequence followed by all elements of the specified sequence.
    An immutable Sequence must return an new Sequence; while a mutable Sequence implementation might append specified seq to this sequence instance directly
    
    Specified by:
    
    append in interface C.Sequence<T>
    
    Parameters:
    
    seq - the sequence to be appended
    
    Returns:
    
    a sequence consists of elements of both sequences
  - append
```
public C.Sequence<T> append(Iterator<? extends T> iterator)
```
    Description copied from interface: C.Sequence
    
    Returns a sequence consists of all elements of this sequence followed by all elements of the specified iterator.
    An immutable Sequence must return an new Sequence; while a mutable Sequence implementation might append specified seq to this sequence instance directly
    
    Specified by:
    
    append in interface C.Sequence<T>
    
    Parameters:
    
    iterator - the iterator in which elements will be append to the returned sequence
    
    Returns:
    
    a sequence consists of elements of this sequence and the elements in the iterator
  - append
```
public C.Sequence<T> append(Enumeration<? extends T> enumeration)
```
    Description copied from interface: C.Sequence
    
    Returns a sequence consists of all elements of this sequence followed by all elements of the specified enumeration.
    An immutable Sequence must return an new Sequence; while a mutable Sequence implementation might append specified seq to this sequence instance directly
    
    Specified by:
    
    append in interface C.Sequence<T>
    
    Parameters:
    
    enumeration - the enumeration in which elements will be append to the returned sequence
    
    Returns:
    
    a sequence consists of elements of this sequence and the elements in the iterator
  - appendReversibleSeq
```
protected C.ReversibleSequence<T> appendReversibleSeq(C.ReversibleSequence<T> seq)
```
  - append
```
public C.ReversibleSequence<T> append(C.ReversibleSequence<T> seq)
```
    Description copied from interface: C.ReversibleSequence
    
    Returns an new reversible sequence contains all elements in this sequence followed by all elements in the specified reverse sequence
    
    Specified by:
    
    append in interface C.ReversibleSequence<T>
    
    Parameters:
    
    seq - another reversible sequence
    
    Returns:
    
    an new reversible sequence contains both seq’s elements
  - appendList
```
protected C.List<T> appendList(C.List<T> list)
```
  - append
```
public C.List<T> append(C.List<T> list)
```
    Description copied from interface: C.List
    
    Returns a List contains all elements in this List followed by all elements in the specified List.
    A mutable List implementation might choose to add elements from the specified list directly to this list and return this list directly
    
    For a read only or immutable list, it must create an new list to avoid update this list
    
    Specified by:
    
    append in interface C.List<T>
    
    Parameters:
    
    list - the list in which elements will be appended to this list
    
    Returns:
    
    a list contains elements of both list
  - append
```
public C.List<T> append(T t)
```
    Description copied from interface: C.List
    
    Returns a sequence consists of all elements of this sequence followed by the element specified.
    an immutable Sequence must return an new Sequence; while a mutable Sequence implementation might append the element to this sequence instance directly
    
    Specified by:
    
    append in interface C.List<T>
    
    Specified by:
    
    append in interface C.ReversibleSequence<T>
    
    Specified by:
    
    append in interface C.Sequence<T>
    
    Parameters:
    
    t - the element to be appended to this sequence
    
    Returns:
    
    a list contains elements in this list followed by t
  - prepend
```
public C.List<T> prepend(Collection<? extends T> collection)
```
    Specified by:
    
    prepend in interface C.List<T>
  - prepend
```
public C.Sequence<T> prepend(Iterable<? extends T> iterable)
```
    Description copied from interface: C.Sequence
    
    Returns a sequence consists of all elements of the iterable specified followed by all elements of this sequence
    An immutable Sequence must return an new Sequence; while a mutable Sequence implementation might prepend specified seq to this sequence instance directly
    
    Specified by:
    
    prepend in interface C.Sequence<T>
    
    Parameters:
    
    iterable - the iterable to be prepended
    
    Returns:
    
    a sequence consists of elements of both sequences
  - prepend
```
public C.Sequence<T> prepend(Iterator<? extends T> iterator)
```
    Description copied from interface: C.Sequence
    
    Returns a sequence consists of all elements of the iterator specified followed by all elements of this sequence
    An immutable Sequence must return an new Sequence; while a mutable Sequence implementation might prepend specified seq to this sequence instance directly
    
    Specified by:
    
    prepend in interface C.Sequence<T>
    
    Parameters:
    
    iterator - the iterator to be prepended
    
    Returns:
    
    a sequence consists of elements of both sequences
  - prepend
```
public C.Sequence<T> prepend(Enumeration<? extends T> enumeration)
```
    Description copied from interface: C.Sequence
    
    Returns a sequence consists of all elements of the enumeration specified followed by all elements of this sequence
    An immutable Sequence must return an new Sequence; while a mutable Sequence implementation might prepend specified seq to this sequence instance directly
    
    Specified by:
    
    prepend in interface C.Sequence<T>
    
    Parameters:
    
    enumeration - the enumeration to be prepended
    
    Returns:
    
    a sequence consists of elements of both sequences
  - prepend
```
public C.Sequence<T> prepend(C.Sequence<? extends T> seq)
```
    Returns a sequence consists of all elements of the sequence specified followed by all elements of this sequence
    An immutable Sequence must return an new Sequence; while a mutable Sequence implementation might prepend specified seq to this sequence instance directly
    This method will NOT change the underline list
    
    Specified by:
    
    prepend in interface C.Sequence<T>
    
    Parameters:
    
    seq - the sequence to be prepended
    
    Returns:
    
    the prepended sequence
  - prependReversibleSeq
```
protected C.ReversibleSequence<T> prependReversibleSeq(C.ReversibleSequence<T> seq)
```
  - prepend
```
public C.ReversibleSequence<T> prepend(C.ReversibleSequence<T> seq)
```
    Description copied from interface: C.ReversibleSequence
    
    Returns an new reversible sequence contains all elements in specified reversible sequence followed by all elements in this sequence
    
    Specified by:
    
    prepend in interface C.ReversibleSequence<T>
    
    Parameters:
    
    seq - another reversible sequence
    
    Returns:
    
    an new reversible sequence contains both seq’s elements
  - prependList
```
protected C.List<T> prependList(C.List<T> list)
```
  - prepend
```
public C.List<T> prepend(C.List<T> list)
```
    This method will NOT change the underline list
    
    Specified by:
    
    prepend in interface C.List<T>
  - prepend
```
public C.List<T> prepend(T t)
```
    Returns a sequence consists of the element specified followed by all elements of this sequence.
    an immutable Sequence must return an new Sequence; while a mutable Sequence implementation might append the element to this sequence instance directly
    For mutable list, this method will insert the element at 0 position.
    
    Specified by:
    
    prepend in interface C.List<T>
    
    Specified by:
    
    prepend in interface C.ReversibleSequence<T>
    
    Specified by:
    
    prepend in interface C.Sequence<T>
    
    Parameters:
    
    t - the element to be appended to this sequence
    
    Returns:
    
    a reversible sequence contains by t followed this seq’s element
  - reduce
```
public <R> R reduce(R identity,
                    Lang.Func2<R,T,R> accumulator)
```
    Description copied from interface: C.Sequence
    Performs a reduction on the elements in this traversable, using the provided identity and accumulating function. This might be equivalent to:
```
  R result = identity;  for (T element: this traversable) {  result = accumulator.apply(result, element);  }  return result; 
```
    The above shows a typical left side reduce. However depending on the implementation, it might choose another way to do the reduction, including reduction in a parallel way
    This method does not specify how to run the accumulator. It might be C.Sequence#reduceLeft(Object, Func2) or ReversibleSequence#reduceRight(Object, Func2), or even run reduction in parallel, it all depending on the implementation.
    For a guaranteed reduce from left to right, use C.Sequence#reduceLeft(Object, Func2) instead
    Specified by:
    
    reduce in interface C.Sequence<T>
    
    Specified by:
    
    reduce in interface C.Traversable<T>
    
    Type Parameters:
    
    R - the type of identity and the return value
    
    Parameters:
    
    identity - the identity value for the accumulating function
    
    accumulator - the function the combine two values
    
    Returns:
    
    the result of reduction
  - reduceLeft
```
public <R> R reduceLeft(R identity,
                        Lang.Func2<R,T,R> accumulator)
```
    Description copied from interface: C.Sequence
    Run reduction from header side. This is equivalent to:
```
  R result = identity;  for (T element: this sequence) {  result = accumulator.apply(result, element);  }  return result; 
```
    Specified by:
    
    reduceLeft in interface C.Sequence<T>
    
    Type Parameters:
    
    R - the aggregation result type
    
    Parameters:
    
    identity - the identity value for the accumulating function
    
    accumulator - the function to accumulate two values
    
    Returns:
    
    the reduced result
  - reduceRight
```
public <R> R reduceRight(R identity,
                         Lang.Func2<R,T,R> accumulator)
```
    Description copied from interface: C.ReversibleSequence
    Run reduction from tail side. This is equivalent to:
```
  R result = identity;  for (T element: this sequence.reverse()) {  result = accumulator.apply(result, element);  }  return result; 
```
    Specified by:
    
    reduceRight in interface C.ReversibleSequence<T>
    
    Type Parameters:
    
    R - the accumulation result
    
    Parameters:
    
    identity - the initial value
    
    accumulator - the function performs accumulation from T an R to anthoer R
    
    Returns:
    
    the aggregation result
    
    See Also:
    
    #reduce(Object, Func2)
  - reduce
```
public Lang.Option<T> reduce(Lang.Func2<T,T,T> accumulator)
```
    Description copied from interface: C.Sequence
    Performs a reduction on the elements in this traversable, using provided accumulating function. This might be equivalent to:
```
  boolean found = false;  T result = null;  for (T element: this traversable) {  if (found) {  result = accumulator.apply(result, element);  } else {  found = true;  result = element;  }  }  return found ? _.some(result) : _.none(); 
```
    The above shows a typical left side reduction. However depending on the implementation, it might choose another way to do the reduction, including reduction in a parallel way
    This method does not specify the approach to run reduction. For a guaranteed reduction from head to tail, use #reduceLeft(Func2) instead
    Specified by:
    
    reduce in interface C.Sequence<T>
    
    Specified by:
    
    reduce in interface C.Traversable<T>
    
    Parameters:
    
    accumulator - the function takes previous accumulating result and the current element being iterated
    
    Returns:
    
    an option describing the accumulating result or Lang.none() if the structure is empty
  - reduceLeft
```
public Lang.Option<T> reduceLeft(Lang.Func2<T,T,T> accumulator)
```
    Description copied from interface: C.Sequence
    Run reduction from head to tail. This is equivalent to
```
  if (isEmpty()) {  return _.none();  }  T result = head();  for (T element: this traversable.tail()) {  result = accumulator.apply(result, element);  }  return _.some(result); 
```
    Specified by:
    
    reduceLeft in interface C.Sequence<T>
    
    Parameters:
    
    accumulator - the function accumulate each element to the final result
    
    Returns:
    
    an Lang.Option describing the accumulating result
  - reduceRight
```
public Lang.Option<T> reduceRight(Lang.Func2<T,T,T> accumulator)
```
    Description copied from interface: C.ReversibleSequence
    Run reduction from tail to head. This is equivalent to
```
  if (isEmpty()) {  return _.none();  }  T result = last();  for (T element: this sequence.reverse.tail()) {  result = accumulator.apply(result, element);  }  return _.some(result); 
```
    Specified by:
    
    reduceRight in interface C.ReversibleSequence<T>
    
    Parameters:
    
    accumulator - the function accumulate each element to the final result
    
    Returns:
    
    an Lang.Option describing the accumulating result
  - findFirst
```
public Lang.Option<T> findFirst(Lang.Function<? super T,Boolean> predicate)
```
    Description copied from interface: C.Sequence
    
    Apply the predicate specified to the element of this sequence from head to tail. Stop at the element that returns true, and returns an Lang.Option describing the element. If none of the element applications in the sequence returns true then Lang.none() is returned
    
    Specified by:
    
    findFirst in interface C.Sequence<T>
    
    Parameters:
    
    predicate - the function map the element to Boolean
    
    Returns:
    
    an option describe the first element matches the predicate or Lang.none()
  - findLast
```
public Lang.Option<T> findLast(Lang.Function<? super T,Boolean> predicate)
```
    Description copied from interface: C.ReversibleSequence
    
    Apply the predicate specified to the element of this sequence from tail to head. Stop at the element that returns true, and returns an Lang.Option describing the element. If none of the element applications in the sequence returns true then Lang.none() is returned
    
    Specified by:
    
    findLast in interface C.ReversibleSequence<T>
    
    Parameters:
    
    predicate - the function map the element to Boolean
    
    Returns:
    
    an option describe the first element matches the predicate or Lang.none()
  - zip
```
public <T2> C.List<Lang.Binary<T,T2>> zip(List<T2> list)
```
    Description copied from interface: C.List
    
    Returns a list formed from this list and another iterable collection by combining corresponding elements in pairs. If one of the two collections is longer than the other, its remaining elements are ignored.
    
    Specified by:
    
    zip in interface C.List<T>
    
    Type Parameters:
    
    T2 - the type of the iterable
    
    Parameters:
    
    list - the part B to be zipped with this list
    
    Returns:
    
    an new list containing pairs consisting of corresponding elements of this sequence and that. The length of the returned collection is the minimum of the lengths of this sequence and that.
  - zipAll
```
public <T2> C.List<Lang.Binary<T,T2>> zipAll(List<T2> list,
                                             T def1,
                                             T2 def2)
```
    Description copied from interface: C.List
    
    Returns a list formed from this list and another iterable collection by combining corresponding elements in pairs. If one of the two collections is longer than the other, placeholder elements are used to extend the shorter collection to the length of the longer.
    
    Specified by:
    
    zipAll in interface C.List<T>
    
    Type Parameters:
    
    T2 - the type of the iterable
    
    Parameters:
    
    list - the part B to be zipped with this list
    
    def1 - the element to be used to fill up the result if this sequence is shorter than that iterable
    
    def2 - the element to be used to fill up the result if the iterable is shorter than this sequence
    
    Returns:
    
    a new list containing pairs consisting of corresponding elements of this list and that. The length of the returned collection is the maximum of the lengths of this list and that.
  - zipWithIndex
```
public C.Sequence<Lang.Binary<T,Integer>> zipWithIndex()
```
    Description copied from interface: C.List
    
    Zip this sequence with its indices
    
    Specified by:
    
    zipWithIndex in interface C.List<T>
    
    Specified by:
    
    zipWithIndex in interface C.Sequence<T>
    
    Returns:
    
    A new list containing pairs consisting of all elements of this list paired with their index. Indices start at 0.
  - zip
```
public <T2> C.Sequence<? extends Lang.Binary<T,T2>> zip(Iterable<T2> iterable)
```
    Description copied from interface: C.Sequence
    
    Returns a sequence formed from this sequence and another iterable collection by combining corresponding elements in pairs. If one of the two collections is longer than the other, its remaining elements are ignored.
    
    Specified by:
    
    zip in interface C.Sequence<T>
    
    Type Parameters:
    
    T2 - the type of the iterable
    
    Parameters:
    
    iterable - the part B to be zipped with this sequence
    
    Returns:
    
    a new sequence containing pairs consisting of corresponding elements of this sequence and that. The length of the returned collection is the minimum of the lengths of this sequence and that.
  - zipAll
```
public <T2> C.Sequence<? extends Lang.Binary<T,T2>> zipAll(Iterable<T2> iterable,
                                                           T def1,
                                                           T2 def2)
```
    Description copied from interface: C.Sequence
    
    Returns a sequence formed from this sequence and another iterable collection by combining corresponding elements in pairs. If one of the two collections is longer than the other, placeholder elements are used to extend the shorter collection to the length of the longer.
    
    Specified by:
    
    zipAll in interface C.Sequence<T>
    
    Type Parameters:
    
    T2 - the type of the iterable
    
    Parameters:
    
    iterable - the part B to be zipped with this sequence
    
    def1 - the element to be used to fill up the result if this sequence is shorter than that iterable
    
    def2 - the element to be used to fill up the result if the iterable is shorter than this sequence
    
    Returns:
    
    a new sequence containing pairs consisting of corresponding elements of this sequence and that. The length of the returned collection is the maximum of the lengths of this sequence and that.
  - zip
```
public <T2> C.ReversibleSequence<Lang.Binary<T,T2>> zip(C.ReversibleSequence<T2> rseq)
```
    Specified by:
    
    zip in interface C.ReversibleSequence<T>
  - zipAll
```
public <T2> C.ReversibleSequence<Lang.Binary<T,T2>> zipAll(C.ReversibleSequence<T2> rseq,
                                                           T def1,
                                                           T2 def2)
```
    Specified by:
    
    zipAll in interface C.ReversibleSequence<T>
  - count
```
public int count(T t)
```
    Description copied from interface: C.Sequence
    
    Count the element occurence in this sequence
    
    Specified by:
    
    count in interface C.Sequence<T>
    
    Parameters:
    
    t - the element
    
    Returns:
    
    the number of times the element be presented in this sequence
  - toMap
```
public <K,V> C.Map<K,V> toMap(Lang.Function<? super T,? extends K> keyExtractor,
                              Lang.Function<? super T,? extends V> valExtractor)
```
    Description copied from interface: C.List
    
    Create a Map from this list using a key extract function and a value extract function
    
    The key extractor will take the element stored in this list and calculate a key, and then store the element being used along with the key calculated into the map to be returned.
    
    The value extractor will take the element stored in this list and calculate a value, and then store the element as the key along with the outcome as the value
    
    Specified by:
    
    toMap in interface C.List<T>
    
    Type Parameters:
    
    K - the generic type of key in the map
    
    V - the generic type of value in the map
    
    Parameters:
    
    keyExtractor - the function that generate map key from the element in this list
    
    valExtractor - the function that generate map value from the element in this list
    
    Returns:
    
    a map as described above
  - toMapByVal
```
public <K> C.Map<K,T> toMapByVal(Lang.Function<? super T,? extends K> keyExtractor)
```
    Description copied from interface: C.List
    
    Create a Map from this list using a key extract function.
    
    The key extractor will take the element stored in this list and calculate a key, and then store the element being used along with the key calculated into the map to be returned.
    
    Specified by:
    
    toMapByVal in interface C.List<T>
    
    Type Parameters:
    
    K - the generic type of key in the map
    
    Parameters:
    
    keyExtractor - the function that generate map key from the element in this list
    
    Returns:
    
    a map that indexed by key generated by the function from the element in this list
  - toMapByKey
```
public <V> C.Map<T,V> toMapByKey(Lang.Function<? super T,? extends V> valExtractor)
```
    Description copied from interface: C.List
    
    Create a Map from this list using a value extract function.
    
    The value extractor will take the element stored in this list and calculate a value, and then store the element as the key along with the outcome as the value
    
    Specified by:
    
    toMapByKey in interface C.List<T>
    
    Type Parameters:
    
    V - the generic type of value in the map
    
    Parameters:
    
    valExtractor - the function that generate map value from the element in this list
    
    Returns:
    
    a map that stores the value calculated along with the corresponding element as the key

Class ListBase<T>

Nested Class Summary

Nested classes/interfaces inherited from interface org.osgl.util.C.List

Nested classes/interfaces inherited from interface org.osgl.util.C.Featured

Field Summary

Fields inherited from class java.util.AbstractList

Constructor Summary

Method Summary

Methods inherited from class java.util.AbstractList

Methods inherited from class java.util.AbstractCollection

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.List

Methods inherited from interface java.util.Collection

Methods inherited from interface org.osgl.util.C.Traversable

Methods inherited from interface java.lang.Iterable

Constructor Detail

ListBase

Method Detail

isLazy

isImmutable

isReadOnly

isMutable

forEachLeft

forEachLeft

forEachRight

forEachRight

parallel

sequential

lazy

eager

snapshot

readOnly

copy

sorted

sorted

unique

unique

subList

add

add

addAll

hashCode

features_

initFeatures

features

is

setFeature

unsetFeature

allMatch

anyMatch

noneMatch

findOne

asList

iterator

listIterator

reverseIterator

first

head

last

take

takeWhile

drop

dropWhile

remove

map

flatMap

collect

filter

split

locateFirst

locate

locateLast

insert

insert

insert

reverse

without

without

without

accept