BooleanGapList

java.lang.Object
- org.magicwerk.brownies.collections.primitive.BooleanGapList

All Implemented Interfaces:

java.io.Serializable, java.lang.Cloneable
```
public class BooleanGapList
extends java.lang.Object
implements java.lang.Cloneable, java.io.Serializable
```
BooleanGapList 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: BooleanGapList.java 1513 2013-01-24 22:14:20Z origo $

Author:

Thomas Mauch

See Also:
List, ArrayList, LinkedList, Serialized Form

Constructor Summary

Constructors
Constructor and Description
`BooleanGapList()` Default constructor.
`BooleanGapList(java.util.Collection<java.lang.Boolean> that)` Copy constructor.
`BooleanGapList(int capacity)` Construct a vector with given capacity.

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`add(boolean elem)`
`void`	`add(int index, boolean elem)`
`boolean`	`addAll(boolean... elems)` Adds all specified elements into this list.
`boolean`	`addAll(BooleanGapList list)` Adds all of the elements in the specified list into this list.
`boolean`	`addAll(java.util.Collection<java.lang.Boolean> coll)` Adds all of the elements in the specified collection into this list.
`boolean`	`addAll(int index, boolean... elems)` Inserts the specified elements into this list, starting at the specified position.
`boolean`	`addAll(int index, BooleanGapList list)` Inserts all of the elements in the specified list into this list, starting at the specified position.
`boolean`	`addAll(int index, java.util.Collection<java.lang.Boolean> coll)` Inserts all of the elements in the specified collection into this list, starting at the specified position.
`void`	`addFirst(boolean elem)`
`void`	`addLast(boolean elem)`
`int`	`capacity()` Returns capacity of this BooleanGapList.
`void`	`clear()`
`java.lang.Object`	`clone()` Returns a shallow copy of this `BooleanGapList` instance (The elements themselves are not copied).
`boolean`	`contains(boolean elem)`
`boolean`	`containsAll(java.util.Collection<java.lang.Boolean> coll)`
`boolean`	`containsAny(java.util.Collection<java.lang.Boolean> coll)` Returns true if any of the elements of the specified collection is contained in the list.
`BooleanGapList`	`copy()` Returns a shallow copy of this `BooleanGapList` instance (the new list will contain the same elements as the source list, i.e. the elements themselves are not copied).
`static void`	`copy(BooleanGapList src, int srcIndex, BooleanGapList dst, int dstIndex, int len)` Copies elements from one BooleanGapList to another.
`void`	`copy(int srcIndex, int dstIndex, int len)` Copy specified elements.
`static BooleanGapList`	`create()` Create new list.
`static BooleanGapList`	`create(boolean... elems)` Create new list and add multiple elements to list.
`boolean`	`element()`
`static BooleanGapList`	`EMPTY()`
`void`	`ensureCapacity(int minCapacity)` Increases the capacity of this `BooleanGapList` 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)` Indicates whether some other object is "equal to" this one.
`void`	`fill(boolean elem)` Fill list.
`void`	`fill(int index, int len, boolean elem)` Fill specified elements.
`boolean`	`get(int index)`
`BooleanGapList`	`get(int index, int len)` Returns specified range of elements from list.
`boolean[]`	`getArray(int index, int len)` Returns specified range of elements from list.
`boolean`	`getFirst()`
`boolean`	`getLast()`
`int`	`hashCode()` Returns a hash code value for the object.
`int`	`indexOf(boolean elem)`
`void`	`init(int len, boolean elem)` Initializes the list so it will afterwards have a size of `len` and contain only the element `elem`.
`boolean`	`isEmpty()`
`int`	`lastIndexOf(boolean elem)`
`static void`	`move(BooleanGapList src, int srcIndex, BooleanGapList dst, int dstIndex, int len)` Moves elements from one BooleanGapList to another.
`void`	`move(int srcIndex, int dstIndex, int len)` Move specified elements.
`boolean`	`offer(boolean elem)`
`boolean`	`offerFirst(boolean elem)`
`boolean`	`offerLast(boolean elem)`
`boolean`	`peek()`
`boolean`	`peekFirst()`
`boolean`	`peekLast()`
`boolean`	`poll()`
`boolean`	`pollFirst()`
`boolean`	`pollLast()`
`boolean`	`pop()`
`void`	`push(boolean elem)`
`boolean`	`remove()`
`boolean`	`remove(int index)`
`void`	`remove(int index, int len)` Remove specified range of elements from list.
`boolean`	`removeAll(BooleanGapList coll)`
`boolean`	`removeAll(java.util.Collection<java.lang.Boolean> coll)`
`boolean`	`removeFirst()`
`boolean`	`removeFirstOccurrence(boolean elem)`
`boolean`	`removeLast()`
`boolean`	`removeLastOccurrence(boolean elem)`
`void`	`resize(int len, boolean elem)` Resizes the list so it will afterwards have a size of `len`.
`boolean`	`retainAll(BooleanGapList coll)`
`boolean`	`retainAll(java.util.Collection<java.lang.Boolean> 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.
`boolean`	`set(int index, boolean elem)`
`void`	`setAll(int index, boolean... elems)` Replaces the specified elements.
`void`	`setAll(int index, BooleanGapList list)` Replaces the specified elements.
`void`	`setAll(int index, java.util.Collection<java.lang.Boolean> coll)` Replaces the specified elements.
`int`	`size()`
`static void`	`swap(BooleanGapList src, int srcIndex, BooleanGapList 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.
`boolean[]`	`toArray()`
`boolean[]`	`toArray(boolean[] array)`
`boolean[]`	`toArray(int index, int len)` Returns an array containing the specified elements in this list.
`java.lang.String`	`toString()` Returns a string representation of the object.
`void`	`trimToSize()` Trims the capacity of this `BooleanGapList` instance to be the list's current size.
`BooleanGapList`	`unmodifiableList()` Returns an unmodifiable view of this list.

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

- Constructor Detail
  - BooleanGapList
```
public BooleanGapList()
```
    Default constructor.
  - BooleanGapList
```
public BooleanGapList(int capacity)
```
    Construct a vector with given capacity.
    
    Parameters:
    capacity - capacity to use
  - BooleanGapList
```
public BooleanGapList(java.util.Collection<java.lang.Boolean> that)
```
    Copy constructor.
    
    Parameters:
    that - source object to copy
- Method Detail
  - EMPTY
```
public static BooleanGapList EMPTY()
```
    Returns:
    unmodifiable empty instance
  - create
```
public static BooleanGapList create()
```
    Create new list.
    
    Parameters:
    type - of elements stored in the list
    
    Returns:
    created array list
  - create
```
public static BooleanGapList create(boolean... elems)
```
    Create new list and add multiple elements to list.
    
    Parameters:
    elems - elements to add
    type - of elements stored in the list
    
    Returns:
    created array list
  - copy
```
public BooleanGapList copy()
```
    Returns a shallow copy of this BooleanGapList 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 BooleanGapList.
    
    Returns:
    a clone of this instance
    See Also:
    clone()
  - unmodifiableList
```
public BooleanGapList 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 BooleanGapList 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 BooleanGapList instance
    See Also:
    Cloneable
  - clear
```
public void clear()
```
  - size
```
public int size()
```
  - capacity
```
public int capacity()
```
    Returns capacity of this BooleanGapList. 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 BooleanGapList
  - get
```
public boolean get(int index)
```
  - set
```
public boolean set(int index,
          boolean elem)
```
  - add
```
public boolean add(boolean elem)
```
  - add
```
public void add(int index,
       boolean elem)
```
  - remove
```
public boolean remove(int index)
```
  - ensureCapacity
```
public void ensureCapacity(int minCapacity)
```
    Increases the capacity of this BooleanGapList 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 BooleanGapList instance to be the list's current size. An application can use this operation to minimize the storage of an BooleanGapList instance.
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Description copied from class: java.lang.Object
    Indicates whether some other object is "equal to" this one.
    The equals method implements an equivalence relation on non-null object references:
    - It is reflexive: for any non-null reference value x, x.equals(x) should return true.
    - It is symmetric: for any non-null reference values x and y, x.equals(y) should return true if and only if y.equals(x) returns true.
    - It is transitive: for any non-null reference values x, y, and z, if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true.
    - It is consistent: for any non-null reference values x and y, multiple invocations of x.equals(y) consistently return true or consistently return false, provided no information used in equals comparisons on the objects is modified.
    - For any non-null reference value x, x.equals(null) should return false.
    The equals method for class Object implements the most discriminating possible equivalence relation on objects; that is, for any non-null reference values x and y, this method returns true if and only if x and y refer to the same object (x == y has the value true).
    Note that it is generally necessary to override the hashCode method whenever this method is overridden, so as to maintain the general contract for the hashCode method, which states that equal objects must have equal hash codes.
    Overrides:
    
    equals in class java.lang.Object
    
    Parameters:
    obj - the reference object with which to compare.
    
    Returns:
    true if this object is the same as the obj argument; false otherwise.
    See Also:
    Object.hashCode(), Hashtable
  - hashCode
```
public int hashCode()
```
    Description copied from class: java.lang.Object
    Returns a hash code value for the object. This method is supported for the benefit of hashtables such as those provided by java.util.Hashtable.
    The general contract of hashCode is:
    - Whenever it is invoked on the same object more than once during an execution of a Java application, the hashCode method must consistently return the same integer, provided no information used in equals comparisons on the object is modified. This integer need not remain consistent from one execution of an application to another execution of the same application.
    - If two objects are equal according to the equals(Object) method, then calling the hashCode method on each of the two objects must produce the same integer result.
    - It is not required that if two objects are unequal according to the Object.equals(java.lang.Object) method, then calling the hashCode method on each of the two objects must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal objects may improve the performance of hashtables.
    As much as is reasonably practical, the hashCode method defined by class Object does return distinct integers for distinct objects. (This is typically implemented by converting the internal address of the object into an integer, but this implementation technique is not required by the Java^TM programming language.)
    Overrides:
    
    hashCode in class java.lang.Object
    
    Returns:
    a hash code value for this object.
    See Also:
    Object.equals(java.lang.Object), Hashtable
  - toString
```
public java.lang.String toString()
```
    Description copied from class: java.lang.Object
    Returns a string representation of the object. In general, the toString method returns a string that "textually represents" this object. The result should be a concise but informative representation that is easy for a person to read. It is recommended that all subclasses override this method.
    The toString method for class Object returns a string consisting of the name of the class of which the object is an instance, the at-sign character `@', and the unsigned hexadecimal representation of the hash code of the object. In other words, this method returns a string equal to the value of:
    getClass().getName() + '@' + Integer.toHexString(hashCode())
    Overrides:
    
    toString in class java.lang.Object
    
    Returns:
    a string representation of the object.
  - isEmpty
```
public boolean isEmpty()
```
  - indexOf
```
public int indexOf(boolean elem)
```
  - lastIndexOf
```
public int lastIndexOf(boolean elem)
```
  - contains
```
public boolean contains(boolean elem)
```
  - containsAny
```
public boolean containsAny(java.util.Collection<java.lang.Boolean> 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<java.lang.Boolean> coll)
```
  - removeAll
```
public boolean removeAll(java.util.Collection<java.lang.Boolean> coll)
```
  - removeAll
```
public boolean removeAll(BooleanGapList coll)
```
    See Also:
    removeAll(Collection)
  - retainAll
```
public boolean retainAll(java.util.Collection<java.lang.Boolean> coll)
```
  - retainAll
```
public boolean retainAll(BooleanGapList coll)
```
    See Also:
    retainAll(Collection)
  - toArray
```
public boolean[] toArray()
```
  - toArray
```
public boolean[] 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 boolean[] toArray(boolean[] array)
```
  - addAll
```
public boolean addAll(java.util.Collection<java.lang.Boolean> 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.
    
    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 (boolean)false
  - addAll
```
public boolean addAll(int index,
             java.util.Collection<java.lang.Boolean> 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.
    
    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 (boolean)false
  - addAll
```
public boolean addAll(boolean... 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,
             boolean... 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(BooleanGapList 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 (boolean)false
  - addAll
```
public boolean addAll(int index,
             BooleanGapList 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 (boolean)false
  - getFirst
```
public boolean getFirst()
```
  - getLast
```
public boolean getLast()
```
  - addFirst
```
public void addFirst(boolean elem)
```
  - addLast
```
public void addLast(boolean elem)
```
  - removeFirst
```
public boolean removeFirst()
```
  - removeLast
```
public boolean removeLast()
```
  - peek
```
public boolean peek()
```
  - element
```
public boolean element()
```
  - poll
```
public boolean poll()
```
  - remove
```
public boolean remove()
```
  - offer
```
public boolean offer(boolean elem)
```
  - offerFirst
```
public boolean offerFirst(boolean elem)
```
  - offerLast
```
public boolean offerLast(boolean elem)
```
  - peekFirst
```
public boolean peekFirst()
```
  - peekLast
```
public boolean peekLast()
```
  - pollFirst
```
public boolean pollFirst()
```
  - pollLast
```
public boolean pollLast()
```
  - pop
```
public boolean pop()
```
  - push
```
public void push(boolean elem)
```
  - removeFirstOccurrence
```
public boolean removeFirstOccurrence(boolean elem)
```
  - removeLastOccurrence
```
public boolean removeLastOccurrence(boolean elem)
```
  - move
```
public static void move(BooleanGapList src,
        int srcIndex,
        BooleanGapList dst,
        int dstIndex,
        int len)
```
    Moves elements from one BooleanGapList to another.
    
    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
    type - of elements stored in the list
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the ranges are invalid
  - copy
```
public static void copy(BooleanGapList src,
        int srcIndex,
        BooleanGapList dst,
        int dstIndex,
        int len)
```
    Copies elements from one BooleanGapList to another.
    
    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
    type - of elements stored in the list
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the ranges are invalid
  - swap
```
public static void swap(BooleanGapList src,
        int srcIndex,
        BooleanGapList dst,
        int dstIndex,
        int len)
```
    Swaps elements from two GapLists.
    
    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
    type - of elements stored in the list
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the ranges are invalid
  - get
```
public BooleanGapList get(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:
    BooleanGapList containing the specified range of elements from list
  - getArray
```
public boolean[] 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:
    BooleanGapList containing the specified range of elements from list
  - setAll
```
public void setAll(int index,
          BooleanGapList 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<java.lang.Boolean> 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,
          boolean... 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,
        boolean 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,
          boolean 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(boolean elem)
```
    Fill list.
    
    Parameters:
    elem - element used for filling
  - fill
```
public void fill(int index,
        int len,
        boolean 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 (boolean)false. 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

Class BooleanGapList

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

BooleanGapList

BooleanGapList

BooleanGapList

Method Detail

EMPTY

create

create

copy

unmodifiableList

clone

clear

size

capacity

get

set

add

add

remove

ensureCapacity

trimToSize

equals

hashCode

toString

isEmpty

indexOf

lastIndexOf

contains

containsAny

containsAll

removeAll

removeAll

retainAll

retainAll

toArray

toArray

toArray

addAll

addAll

addAll

addAll

addAll

addAll

getFirst

getLast

addFirst

addLast

removeFirst

removeLast

peek

element

poll

remove

offer

offerFirst

offerLast

peekFirst

peekLast

pollFirst

pollLast

pop

push

removeFirstOccurrence

removeLastOccurrence

move

copy

swap

get

getArray

setAll

setAll

setAll

remove

init

resize

fill