GapList

java.lang.Object
- java.util.AbstractCollection<E>
- - java.util.AbstractList<E>
  - - org.magicwerk.brownies.collections.GapList<E>

Type Parameters:
E - type of elements stored in the list

All Implemented Interfaces:

java.io.Serializable, java.lang.Cloneable, java.lang.Iterable<E>, java.util.Collection<E>, java.util.Deque<E>, java.util.List<E>, java.util.Queue<E>, java.util.RandomAccess

Direct Known Subclasses:

BooleanObjGapList, ByteObjGapList, CharObjGapList, DoubleObjGapList, FloatObjGapList, IntObjGapList, KeyListImpl, LongObjGapList, ShortObjGapList
```
public class GapList<E>
extends java.util.AbstractList<E>
implements java.util.List<E>, java.util.RandomAccess, java.lang.Cloneable, java.io.Serializable, java.util.Deque<E>
```
GapList combines the strengths of both ArrayList and LinkedList. It is implemented to offer both efficient random access to elements by index (as ArrayList does) and at the same time efficient adding and removing elements to and from beginning and end (as LinkedList does). It also exploits the locality of reference often seen in applications to further improve performance, e.g. for iterating over the list.
Note that this implementation is not synchronized.

Version:

$Id: GapList.java 2098 2014-01-13 00:37:08Z origo $

Author:

Thomas Mauch

See Also:
List, ArrayList, LinkedList, Serialized Form

Constructor Summary

Constructors
Constructor and Description
`GapList()` Construct a list with the default initial capacity.
`GapList(java.util.Collection<? extends E> coll)` Construct a list to contain the specified elements.
`GapList(E... elems)` Construct a list to contain the specified elements.
`GapList(int capacity)` Construct a list with specified initial capacity.

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`add(E elem)`
`void`	`add(int index, E elem)`
`boolean`	`addAll(java.util.Collection<? extends E> coll)` Adds all of the elements in the specified collection into this list.
`boolean`	`addAll(E... elems)` Adds all specified elements into this list.
`boolean`	`addAll(GapList<? extends E> list)` Adds all of the elements in the specified list into this list.
`boolean`	`addAll(int index, java.util.Collection<? extends E> coll)` Inserts all of the elements in the specified collection into this list, starting at the specified position.
`boolean`	`addAll(int index, E... elems)` Inserts the specified elements into this list, starting at the specified position.
`boolean`	`addAll(int index, GapList<? extends E> list)` Inserts all of the elements in the specified list into this list, starting at the specified position.
`void`	`addFirst(E elem)`
`void`	`addLast(E elem)`
`<K> int`	`binarySearch(int index, int len, K key, java.util.Comparator<? super K> comparator)` Searches the specified range for an object using the binary search algorithm.
`<K> int`	`binarySearch(K key, java.util.Comparator<? super K> comparator)` Searches the specified range for an object using the binary search algorithm.
`int`	`capacity()` Returns capacity of this GapList.
`void`	`clear()`
`java.lang.Object`	`clone()` Returns a shallow copy of this `GapList` instance (The elements themselves are not copied).
`boolean`	`contains(java.lang.Object elem)`
`boolean`	`containsAll(java.util.Collection<?> coll)`
`boolean`	`containsAny(java.util.Collection<?> coll)` Returns true if any of the elements of the specified collection is contained in the list.
`GapList<E>`	`copy()` Returns a shallow copy of this `GapList` instance (the new list will contain the same elements as the source list, i.e. the elements themselves are not copied).
`static <E> void`	`copy(GapList<? extends E> src, int srcIndex, GapList<E> dst, int dstIndex, int len)` Copies elements from one GapList to another.
`void`	`copy(int srcIndex, int dstIndex, int len)` Copy specified elements.
`static <E> GapList<E>`	`create()` Create new list.
`static <E> GapList<E>`	`create(java.util.Collection<? extends E> coll)` Create new list with specified elements.
`static <E> GapList<E>`	`create(E... elems)` Create new list with specified elements.
`static <E> GapList<E>`	`create(int capacity)` Create new list with specified capacity.
`java.util.Iterator<E>`	`descendingIterator()`
`E`	`element()`
`static <EE> GapList<EE>`	`EMPTY()`
`void`	`ensureCapacity(int minCapacity)` Increases the capacity of this `GapList` instance, if necessary, to ensure that it can hold at least the number of elements specified by the minimum capacity argument.
`boolean`	`equals(java.lang.Object obj)`
`void`	`fill(E elem)` Fill list.
`void`	`fill(int index, int len, E elem)` Fill specified elements.
`E`	`get(int index)`
`GapList<E>`	`getAll(int index, int len)` Returns specified range of elements from list.
`E[]`	`getArray(int index, int len)` Returns specified range of elements from list.
`E`	`getFirst()`
`E`	`getLast()`
`int`	`hashCode()`
`int`	`indexOf(java.lang.Object elem)`
`void`	`init()` Initialize the list to be empty.
`void`	`init(java.util.Collection<? extends E> coll)` Initialize the list to contain the specified elements only.
`void`	`init(E... elems)` Initialize the list to contain the specified elements only.
`void`	`init(int capacity)` Initialize the list to be empty with specified initial capacity.
`void`	`init(int len, E elem)` Initializes the list so it will afterwards have a size of `len` and contain only the element `elem`.
`boolean`	`isEmpty()`
`java.util.Iterator<E>`	`iterator()`
`int`	`lastIndexOf(java.lang.Object elem)`
`java.util.ListIterator<E>`	`listIterator()`
`java.util.ListIterator<E>`	`listIterator(int index)`
`static <E> void`	`move(GapList<? extends E> src, int srcIndex, GapList<E> dst, int dstIndex, int len)` Moves elements from one GapList to another.
`void`	`move(int srcIndex, int dstIndex, int len)` Move specified elements.
`boolean`	`offer(E elem)`
`boolean`	`offerFirst(E elem)`
`boolean`	`offerLast(E elem)`
`E`	`peek()`
`E`	`peekFirst()`
`E`	`peekLast()`
`E`	`poll()`
`E`	`pollFirst()`
`E`	`pollLast()`
`E`	`pop()`
`void`	`push(E elem)`
`E`	`remove()`
`E`	`remove(int index)`
`void`	`remove(int index, int len)` Remove specified range of elements from list.
`boolean`	`remove(java.lang.Object elem)`
`boolean`	`removeAll(java.util.Collection<?> coll)`
`boolean`	`removeAll(GapList<?> coll)`
`E`	`removeFirst()`
`boolean`	`removeFirstOccurrence(java.lang.Object elem)`
`E`	`removeLast()`
`boolean`	`removeLastOccurrence(java.lang.Object elem)`
`void`	`resize(int len, E elem)` Resizes the list so it will afterwards have a size of `len`.
`boolean`	`retainAll(java.util.Collection<?> coll)`
`boolean`	`retainAll(GapList<?> coll)`
`void`	`reverse()` Reverses the order of all elements in the specified list.
`void`	`reverse(int index, int len)` Reverses the order of the specified elements in the list.
`void`	`rotate(int distance)` Rotate specified elements in the list.
`void`	`rotate(int index, int len, int distance)` Rotate specified elements in the list.
`E`	`set(int index, E elem)`
`void`	`setAll(int index, java.util.Collection<? extends E> coll)` Replaces the specified elements.
`void`	`setAll(int index, E... elems)` Replaces the specified elements.
`void`	`setAll(int index, GapList<? extends E> list)` Replaces the specified elements.
`int`	`size()`
`void`	`sort(java.util.Comparator<? super E> comparator)` Sort elements in the list using the specified comparator.
`void`	`sort(int index, int len, java.util.Comparator<? super E> comparator)` Sort specified elements in the list using the specified comparator.
`static <E> void`	`swap(GapList<E> src, int srcIndex, GapList<E> dst, int dstIndex, int len)` Swaps elements from two GapLists.
`void`	`swap(int index1, int index2, int len)` Swap the specified elements in the list.
`java.lang.Object[]`	`toArray()`
`java.lang.Object[]`	`toArray(int index, int len)` Returns an array containing the specified elements in this list.
`<T> T[]`	`toArray(T[] array)`
`java.lang.String`	`toString()`
`void`	`trimToSize()` Trims the capacity of this `GapList` instance to be the list's current size.
`GapList<E>`	`unmodifiableList()` Returns an unmodifiable view of this list.

Methods inherited from class java.util.AbstractList
subList

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

Methods inherited from interface java.util.List
subList

- Constructor Detail
  - GapList
```
public GapList()
```
    Construct a list with the default initial capacity.
  - GapList
```
public GapList(int capacity)
```
    Construct a list with specified initial capacity.
    
    Parameters:
    capacity - capacity
  - GapList
```
public GapList(java.util.Collection<? extends E> coll)
```
    Construct a list to contain the specified elements. The list will have an initial capacity to hold these elements.
    
    Parameters:
    coll - collection with elements
  - GapList
```
public GapList(E... elems)
```
    Construct a list to contain the specified elements. The list will have an initial capacity to hold these elements.
    
    Parameters:
    elems - array with elements
- Method Detail
  - EMPTY
```
public static <EE> GapList<EE> EMPTY()
```
    Returns:
    unmodifiable empty instance
  - create
```
public static <E> GapList<E> create()
```
    Create new list.
    
    Type Parameters:
    E - type of elements stored in the list
    
    Returns:
    created list
  - create
```
public static <E> GapList<E> create(int capacity)
```
    Create new list with specified capacity.
    
    Type Parameters:
    E - type of elements stored in the list
    Parameters:
    capacity - capacity
    
    Returns:
    created list
  - create
```
public static <E> GapList<E> create(java.util.Collection<? extends E> coll)
```
    Create new list with specified elements.
    
    Type Parameters:
    E - type of elements stored in the list
    Parameters:
    coll - collection with element
    
    Returns:
    created list
  - create
```
public static <E> GapList<E> create(E... elems)
```
    Create new list with specified elements.
    
    Type Parameters:
    E - type of elements stored in the list
    Parameters:
    elems - array with elements
    
    Returns:
    created list
  - init
```
public void init()
```
    Initialize the list to be empty. The list will have the default initial capacity.
  - init
```
public void init(int capacity)
```
    Initialize the list to be empty with specified initial capacity.
    
    Parameters:
    capacity - capacity
  - init
```
public void init(java.util.Collection<? extends E> coll)
```
    Initialize the list to contain the specified elements only. The list will have an initial capacity to hold these elements.
    
    Parameters:
    coll - collection with elements
  - init
```
public void init(E... elems)
```
    Initialize the list to contain the specified elements only. The list will have an initial capacity to hold these elements.
    
    Parameters:
    elems - array with elements
  - copy
```
public GapList<E> copy()
```
    Returns a shallow copy of this GapList instance (the new list will contain the same elements as the source list, i.e. the elements themselves are not copied). This method is identical to clone() except that the result is casted to GapList.
    
    Returns:
    a clone of this instance
    See Also:
    clone()
  - unmodifiableList
```
public GapList<E> unmodifiableList()
```
    Returns an unmodifiable view of this list. This method allows modules to provide users with "read-only" access to internal lists. Query operations on the returned list "read through" to the specified list, and attempts to modify the returned list, whether direct or via its iterator, result in an UnsupportedOperationException.
    
    Returns:
    an unmodifiable view of the specified list
  - clone
```
public java.lang.Object clone()
```
    Returns a shallow copy of this GapList instance (The elements themselves are not copied). The capacity of the list will be set to the number of elements, so after calling clone(), size and capacity are equal.
    
    Overrides:
    
    clone in class java.lang.Object
    
    Returns:
    a clone of this GapList instance
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface java.util.Collection<E>
    
    Specified by:
    
    clear in interface java.util.List<E>
    
    Overrides:
    
    clear in class java.util.AbstractList<E>
  - size
```
public int size()
```
    Specified by:
    
    size in interface java.util.Collection<E>
    
    Specified by:
    
    size in interface java.util.Deque<E>
    
    Specified by:
    
    size in interface java.util.List<E>
    
    Specified by:
    
    size in class java.util.AbstractCollection<E>
  - capacity
```
public int capacity()
```
    Returns capacity of this GapList. Note that two GapLists are considered equal even if they have a distinct capacity. Also the capacity can be changed by operations like clone() etc.
    
    Returns:
    capacity of this GapList
  - get
```
public E get(int index)
```
    Specified by:
    
    get in interface java.util.List<E>
    
    Specified by:
    
    get in class java.util.AbstractList<E>
  - set
```
public E set(int index,
    E elem)
```
    Specified by:
    
    set in interface java.util.List<E>
    
    Overrides:
    
    set in class java.util.AbstractList<E>
  - add
```
public boolean add(E elem)
```
    Specified by:
    
    add in interface java.util.Collection<E>
    
    Specified by:
    
    add in interface java.util.Deque<E>
    
    Specified by:
    
    add in interface java.util.List<E>
    
    Specified by:
    
    add in interface java.util.Queue<E>
    
    Overrides:
    
    add in class java.util.AbstractList<E>
  - add
```
public void add(int index,
       E elem)
```
    Specified by:
    
    add in interface java.util.List<E>
    
    Overrides:
    
    add in class java.util.AbstractList<E>
  - remove
```
public E remove(int index)
```
    Specified by:
    
    remove in interface java.util.List<E>
    
    Overrides:
    
    remove in class java.util.AbstractList<E>
  - ensureCapacity
```
public void ensureCapacity(int minCapacity)
```
    Increases the capacity of this GapList instance, if necessary, to ensure that it can hold at least the number of elements specified by the minimum capacity argument.
    
    Parameters:
    minCapacity - the desired minimum capacity
  - trimToSize
```
public void trimToSize()
```
    Trims the capacity of this GapList instance to be the list's current size. An application can use this operation to minimize the storage of an GapList instance.
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Specified by:
    
    equals in interface java.util.Collection<E>
    
    Specified by:
    
    equals in interface java.util.List<E>
    
    Overrides:
    
    equals in class java.util.AbstractList<E>
  - hashCode
```
public int hashCode()
```
    Specified by:
    
    hashCode in interface java.util.Collection<E>
    
    Specified by:
    
    hashCode in interface java.util.List<E>
    
    Overrides:
    
    hashCode in class java.util.AbstractList<E>
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.util.AbstractCollection<E>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface java.util.Collection<E>
    
    Specified by:
    
    isEmpty in interface java.util.List<E>
    
    Overrides:
    
    isEmpty in class java.util.AbstractCollection<E>
  - indexOf
```
public int indexOf(java.lang.Object elem)
```
    Specified by:
    
    indexOf in interface java.util.List<E>
    
    Overrides:
    
    indexOf in class java.util.AbstractList<E>
  - lastIndexOf
```
public int lastIndexOf(java.lang.Object elem)
```
    Specified by:
    
    lastIndexOf in interface java.util.List<E>
    
    Overrides:
    
    lastIndexOf in class java.util.AbstractList<E>
  - remove
```
public boolean remove(java.lang.Object elem)
```
    Specified by:
    
    remove in interface java.util.Collection<E>
    
    Specified by:
    
    remove in interface java.util.Deque<E>
    
    Specified by:
    
    remove in interface java.util.List<E>
    
    Overrides:
    
    remove in class java.util.AbstractCollection<E>
  - contains
```
public boolean contains(java.lang.Object elem)
```
    Specified by:
    
    contains in interface java.util.Collection<E>
    
    Specified by:
    
    contains in interface java.util.Deque<E>
    
    Specified by:
    
    contains in interface java.util.List<E>
    
    Overrides:
    
    contains in class java.util.AbstractCollection<E>
  - containsAny
```
public boolean containsAny(java.util.Collection<?> coll)
```
    Returns true if any of the elements of the specified collection is contained in the list.
    
    Parameters:
    coll - collection with elements to be contained
    
    Returns:
    true if any element is contained, false otherwise
  - containsAll
```
public boolean containsAll(java.util.Collection<?> coll)
```
    Specified by:
    
    containsAll in interface java.util.Collection<E>
    
    Specified by:
    
    containsAll in interface java.util.List<E>
    
    Overrides:
    
    containsAll in class java.util.AbstractCollection<E>
  - removeAll
```
public boolean removeAll(java.util.Collection<?> coll)
```
    Specified by:
    
    removeAll in interface java.util.Collection<E>
    
    Specified by:
    
    removeAll in interface java.util.List<E>
    
    Overrides:
    
    removeAll in class java.util.AbstractCollection<E>
  - removeAll
```
public boolean removeAll(GapList<?> coll)
```
    See Also:
    removeAll(Collection)
  - retainAll
```
public boolean retainAll(java.util.Collection<?> coll)
```
    Specified by:
    
    retainAll in interface java.util.Collection<E>
    
    Specified by:
    
    retainAll in interface java.util.List<E>
    
    Overrides:
    
    retainAll in class java.util.AbstractCollection<E>
  - retainAll
```
public boolean retainAll(GapList<?> coll)
```
    See Also:
    retainAll(Collection)
  - toArray
```
public java.lang.Object[] toArray()
```
    Specified by:
    
    toArray in interface java.util.Collection<E>
    
    Specified by:
    
    toArray in interface java.util.List<E>
    
    Overrides:
    
    toArray in class java.util.AbstractCollection<E>
  - toArray
```
public java.lang.Object[] toArray(int index,
                         int len)
```
    Returns an array containing the specified elements in this list.
    
    Parameters:
    index - index of first element to copy
    len - number of elements to copy
    
    Returns:
    array the specified elements
  - toArray
```
public <T> T[] toArray(T[] array)
```
    Specified by:
    
    toArray in interface java.util.Collection<E>
    
    Specified by:
    
    toArray in interface java.util.List<E>
    
    Overrides:
    
    toArray in class java.util.AbstractCollection<E>
  - addAll
```
public boolean addAll(java.util.Collection<? extends E> coll)
```
    Adds all of the elements in the specified collection into this list. The new elements will appear in the list in the order that they are returned by the specified collection's iterator.
    
    Specified by:
    
    addAll in interface java.util.Collection<E>
    
    Specified by:
    
    addAll in interface java.util.List<E>
    
    Overrides:
    
    addAll in class java.util.AbstractCollection<E>
    
    Parameters:
    coll - collection containing elements to be added to this list
    
    Returns:
    true if this list changed as a result of the call
    
    Throws:
    
    java.lang.NullPointerException - if the specified collection is null
  - addAll
```
public boolean addAll(int index,
             java.util.Collection<? extends E> coll)
```
    Inserts all of the elements in the specified collection into this list, starting at the specified position. Shifts the element currently at that position (if any) and any subsequent elements to the right (increases their indices). The new elements will appear in the list in the order that they are returned by the specified collection's iterator.
    
    Specified by:
    
    addAll in interface java.util.List<E>
    
    Overrides:
    
    addAll in class java.util.AbstractList<E>
    
    Parameters:
    index - index at which to insert the first element from the specified collection
    coll - collection containing elements to be inserted into this list
    
    Returns:
    true if this list changed as a result of the call
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the index is invalid
    
    java.lang.NullPointerException - if the specified collection is null
  - addAll
```
public boolean addAll(E... elems)
```
    Adds all specified elements into this list.
    
    Parameters:
    elems - elements to be added to this list
    
    Returns:
    true if this list changed as a result of the call
  - addAll
```
public boolean addAll(int index,
             E... elems)
```
    Inserts the specified elements into this list, starting at the specified position. Shifts the element currently at that position (if any) and any subsequent elements to the right (increases their indices).
    
    Parameters:
    index - index at which to insert the first element from the specified collection
    elems - elements to be inserted into this list
    
    Returns:
    true if this list changed as a result of the call
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the index is invalid
  - addAll
```
public boolean addAll(GapList<? extends E> list)
```
    Adds all of the elements in the specified list into this list.
    
    Parameters:
    list - collection containing elements to be added to this list
    
    Returns:
    true if this list changed as a result of the call
    
    Throws:
    
    java.lang.NullPointerException - if the specified list is null
  - addAll
```
public boolean addAll(int index,
             GapList<? extends E> list)
```
    Inserts all of the elements in the specified list into this list, starting at the specified position. Shifts the element currently at that position (if any) and any subsequent elements to the right (increases their indices).
    
    Parameters:
    index - index at which to insert the first element from the specified collection
    list - list containing elements to be inserted into this list
    
    Returns:
    true if this list changed as a result of the call
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the index is invalid
    
    java.lang.NullPointerException - if the specified collection is null
  - iterator
```
public java.util.Iterator<E> iterator()
```
    Specified by:
    
    iterator in interface java.lang.Iterable<E>
    
    Specified by:
    
    iterator in interface java.util.Collection<E>
    
    Specified by:
    
    iterator in interface java.util.Deque<E>
    
    Specified by:
    
    iterator in interface java.util.List<E>
    
    Overrides:
    
    iterator in class java.util.AbstractList<E>
  - listIterator
```
public java.util.ListIterator<E> listIterator()
```
    Specified by:
    
    listIterator in interface java.util.List<E>
    
    Overrides:
    
    listIterator in class java.util.AbstractList<E>
  - listIterator
```
public java.util.ListIterator<E> listIterator(int index)
```
    Specified by:
    
    listIterator in interface java.util.List<E>
    
    Overrides:
    
    listIterator in class java.util.AbstractList<E>
  - descendingIterator
```
public java.util.Iterator<E> descendingIterator()
```
    Specified by:
    
    descendingIterator in interface java.util.Deque<E>
  - peek
```
public E peek()
```
    Specified by:
    
    peek in interface java.util.Deque<E>
    
    Specified by:
    
    peek in interface java.util.Queue<E>
  - element
```
public E element()
```
    Specified by:
    
    element in interface java.util.Deque<E>
    
    Specified by:
    
    element in interface java.util.Queue<E>
  - poll
```
public E poll()
```
    Specified by:
    
    poll in interface java.util.Deque<E>
    
    Specified by:
    
    poll in interface java.util.Queue<E>
  - remove
```
public E remove()
```
    Specified by:
    
    remove in interface java.util.Deque<E>
    
    Specified by:
    
    remove in interface java.util.Queue<E>
  - offer
```
public boolean offer(E elem)
```
    Specified by:
    
    offer in interface java.util.Deque<E>
    
    Specified by:
    
    offer in interface java.util.Queue<E>
  - getFirst
```
public E getFirst()
```
    Specified by:
    
    getFirst in interface java.util.Deque<E>
  - getLast
```
public E getLast()
```
    Specified by:
    
    getLast in interface java.util.Deque<E>
  - addFirst
```
public void addFirst(E elem)
```
    Specified by:
    
    addFirst in interface java.util.Deque<E>
  - addLast
```
public void addLast(E elem)
```
    Specified by:
    
    addLast in interface java.util.Deque<E>
  - removeFirst
```
public E removeFirst()
```
    Specified by:
    
    removeFirst in interface java.util.Deque<E>
  - removeLast
```
public E removeLast()
```
    Specified by:
    
    removeLast in interface java.util.Deque<E>
  - offerFirst
```
public boolean offerFirst(E elem)
```
    Specified by:
    
    offerFirst in interface java.util.Deque<E>
  - offerLast
```
public boolean offerLast(E elem)
```
    Specified by:
    
    offerLast in interface java.util.Deque<E>
  - peekFirst
```
public E peekFirst()
```
    Specified by:
    
    peekFirst in interface java.util.Deque<E>
  - peekLast
```
public E peekLast()
```
    Specified by:
    
    peekLast in interface java.util.Deque<E>
  - pollFirst
```
public E pollFirst()
```
    Specified by:
    
    pollFirst in interface java.util.Deque<E>
  - pollLast
```
public E pollLast()
```
    Specified by:
    
    pollLast in interface java.util.Deque<E>
  - pop
```
public E pop()
```
    Specified by:
    
    pop in interface java.util.Deque<E>
  - push
```
public void push(E elem)
```
    Specified by:
    
    push in interface java.util.Deque<E>
  - removeFirstOccurrence
```
public boolean removeFirstOccurrence(java.lang.Object elem)
```
    Specified by:
    
    removeFirstOccurrence in interface java.util.Deque<E>
  - removeLastOccurrence
```
public boolean removeLastOccurrence(java.lang.Object elem)
```
    Specified by:
    
    removeLastOccurrence in interface java.util.Deque<E>
  - move
```
public static <E> void move(GapList<? extends E> src,
            int srcIndex,
            GapList<E> dst,
            int dstIndex,
            int len)
```
    Moves elements from one GapList to another.
    
    Type Parameters:
    E - type of elements stored in the list
    Parameters:
    src - source list
    srcIndex - index of first element in source list
    dst - destination list
    dstIndex - index of first element in source list
    len - number of elements to move
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the ranges are invalid
  - copy
```
public static <E> void copy(GapList<? extends E> src,
            int srcIndex,
            GapList<E> dst,
            int dstIndex,
            int len)
```
    Copies elements from one GapList to another.
    
    Type Parameters:
    E - type of elements stored in the list
    Parameters:
    src - source list
    srcIndex - index of first element in source list
    dst - destination list
    dstIndex - index of first element in source list
    len - number of elements to copy
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the ranges are invalid
  - swap
```
public static <E> void swap(GapList<E> src,
            int srcIndex,
            GapList<E> dst,
            int dstIndex,
            int len)
```
    Swaps elements from two GapLists.
    
    Type Parameters:
    E - type of elements stored in the list
    Parameters:
    src - first list
    srcIndex - index of first element in first list
    dst - second list
    dstIndex - index of first element in second list
    len - number of elements to swap
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the ranges are invalid
  - getAll
```
public GapList<E> getAll(int index,
                int len)
```
    Returns specified range of elements from list.
    
    Parameters:
    index - index of first element to retrieve
    len - number of elements to retrieve
    
    Returns:
    GapList containing the specified range of elements from list
  - getArray
```
public E[] getArray(int index,
           int len)
```
    Returns specified range of elements from list.
    
    Parameters:
    index - index of first element to retrieve
    len - number of elements to retrieve
    
    Returns:
    GapList containing the specified range of elements from list
  - setAll
```
public void setAll(int index,
          GapList<? extends E> list)
```
    Replaces the specified elements.
    
    Parameters:
    index - index of first element to set
    list - list with elements to set
  - setAll
```
public void setAll(int index,
          java.util.Collection<? extends E> coll)
```
    Replaces the specified elements.
    
    Parameters:
    index - index of first element to set
    coll - collection with elements to set
  - setAll
```
public void setAll(int index,
          E... elems)
```
    Replaces the specified elements.
    
    Parameters:
    index - index of first element to set
    elems - elements to set
  - remove
```
public void remove(int index,
          int len)
```
    Remove specified range of elements from list.
    
    Parameters:
    index - index of first element to remove
    len - number of elements to remove
  - init
```
public void init(int len,
        E elem)
```
    Initializes the list so it will afterwards have a size of len and contain only the element elem. The list will grow or shrink as needed.
    
    Parameters:
    len - length of list
    elem - element which the list will contain
  - resize
```
public void resize(int len,
          E elem)
```
    Resizes the list so it will afterwards have a size of len. If the list must grow, the specified element elem will be used for filling.
    
    Parameters:
    len - length of list
    elem - element which will be used for extending the list
  - fill
```
public void fill(E elem)
```
    Fill list.
    
    Parameters:
    elem - element used for filling
  - fill
```
public void fill(int index,
        int len,
        E elem)
```
    Fill specified elements.
    
    Parameters:
    index - index of first element to fill
    len - number of elements to fill
    elem - element used for filling
  - copy
```
public void copy(int srcIndex,
        int dstIndex,
        int len)
```
    Copy specified elements. Source and destination ranges may overlap.
    
    Parameters:
    srcIndex - index of first source element to copy
    dstIndex - index of first destination element to copy
    len - number of elements to copy
  - move
```
public void move(int srcIndex,
        int dstIndex,
        int len)
```
    Move specified elements. The elements which are moved away are set to null. Source and destination ranges may overlap.
    
    Parameters:
    srcIndex - index of first source element to move
    dstIndex - index of first destination element to move
    len - number of elements to move
  - reverse
```
public void reverse()
```
    Reverses the order of all elements in the specified list.
  - reverse
```
public void reverse(int index,
           int len)
```
    Reverses the order of the specified elements in the list.
    
    Parameters:
    index - index of first element to reverse
    len - number of elements to reverse
  - swap
```
public void swap(int index1,
        int index2,
        int len)
```
    Swap the specified elements in the list.
    
    Parameters:
    index1 - index of first element in first range to swap
    index2 - index of first element in second range to swap
    len - number of elements to swap
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the ranges overlap
  - rotate
```
public void rotate(int distance)
```
    Rotate specified elements in the list. The distance argument can be positive or negative: If it is positive, the elements are moved towards the end, if negative, the elements are moved toward the beginning, if distance is 0, the list is not changed.
    
    Parameters:
    distance - distance to move the elements
  - rotate
```
public void rotate(int index,
          int len,
          int distance)
```
    Rotate specified elements in the list. The distance argument can be positive or negative: If it is positive, the elements are moved towards the end, if negative, the elements are moved toward the beginning, if distance is 0, the list is not changed.
    
    Parameters:
    index - index of first element to rotate
    len - number of elements to rotate
    distance - distance to move the elements
  - sort
```
public void sort(java.util.Comparator<? super E> comparator)
```
    Sort elements in the list using the specified comparator.
    
    Parameters:
    comparator - comparator to use for sorting (null means the elements natural ordering should be used)
    See Also:
    Arrays.sort(int[])
  - sort
```
public void sort(int index,
        int len,
        java.util.Comparator<? super E> comparator)
```
    Sort specified elements in the list using the specified comparator.
    
    Parameters:
    index - index of first element to sort
    len - number of elements to sort
    comparator - comparator to use for sorting (null means the elements natural ordering should be used)
    See Also:
    Arrays.sort(int[])
  - binarySearch
```
public <K> int binarySearch(K key,
                   java.util.Comparator<? super K> comparator)
```
    Searches the specified range for an object using the binary search algorithm.
    
    Parameters:
    key - the value to be searched for
    comparator - the comparator by which the list is ordered. A null value indicates that the elements' natural ordering should be used.
    
    Returns:
    index of the search key, if it is contained in the array; otherwise, (-(insertion point) - 1). The insertion point is defined as the point at which the key would be inserted into the array: the index of the first element greater than the key, or a.length if all elements in the array are less than the specified key. Note that this guarantees that the return value will be >= 0 if and only if the key is found.
    See Also:
    Arrays.binarySearch(long[], long)
  - binarySearch
```
public <K> int binarySearch(int index,
                   int len,
                   K key,
                   java.util.Comparator<? super K> comparator)
```
    Searches the specified range for an object using the binary search algorithm.
    
    Parameters:
    index - index of first element to search
    len - number of elements to search
    key - the value to be searched for
    comparator - the comparator by which the list is ordered. A null value indicates that the elements' natural ordering should be used.
    
    Returns:
    index of the search key, if it is contained in the array; otherwise, (-(insertion point) - 1). The insertion point is defined as the point at which the key would be inserted into the array: the index of the first element greater than the key, or a.length if all elements in the array are less than the specified key. Note that this guarantees that the return value will be >= 0 if and only if the key is found.
    See Also:
    Arrays.binarySearch(long[], long)

Class GapList<E>

Constructor Summary

Method Summary

Methods inherited from class java.util.AbstractList

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.List

Constructor Detail

GapList

GapList

GapList

GapList

Method Detail

EMPTY

create

create

create

create

init

init

init

init

copy

unmodifiableList

clone

clear

size

capacity

get

set

add

add

remove

ensureCapacity

trimToSize

equals

hashCode

toString

isEmpty

indexOf

lastIndexOf

remove

contains

containsAny

containsAll

removeAll

removeAll

retainAll

retainAll

toArray

toArray

toArray

addAll

addAll

addAll

addAll

addAll

addAll

iterator

listIterator

listIterator

descendingIterator

peek

element

poll

remove

offer

getFirst

getLast

addFirst

addLast

removeFirst

removeLast

offerFirst

offerLast

peekFirst

peekLast

pollFirst

pollLast

pop

push