org.magicwerk.brownies.collections

Class IList<E>

java.lang.Object

java.util.AbstractCollection<E>

java.util.AbstractList<E>

org.magicwerk.brownies.collections.IList<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:

BigList, BooleanObjBigList, BooleanObjGapList, ByteObjBigList, ByteObjGapList, CharObjBigList, CharObjGapList, DoubleObjBigList, DoubleObjGapList, FloatObjBigList, FloatObjGapList, GapList, IntObjBigList, IntObjGapList, KeyListImpl, LongObjBigList, LongObjGapList, ShortObjBigList, ShortObjGapList

public abstract class IList<E>
extends java.util.AbstractList<E>
implements java.util.List<E>, java.util.RandomAccess, java.lang.Cloneable, java.io.Serializable, java.util.Deque<E>

IList is an abstract class which offers all interfaces offered by both ArrayList and LinkedList. It also offers additional methods which are then available in all implementations of GapList and BigList.

Version:

$Id: IList.java 3150 2016-04-13 14:29:16Z origo $

Author:

Thomas Mauch

See Also:

List, Deque, ArrayList, LinkedList, Serialized Form

Constructor Summary

Constructors

Constructor and Description
IList()

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(IList<? 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, IList<? extends E> list) Inserts all of the elements in the specified list into this list, starting at the specified position.
boolean	addArray(E... elems) Adds all specified elements into this list.
boolean	addArray(int index, E... elems) Inserts the specified elements into this list, starting at the specified position.
void	addFirst(E elem)
boolean	addIfAbsent(E elem) Add elements if it is not already contained in the list.
void	addLast(E elem)
boolean	addMult(int len, E elem) Adds element multiple time to list.
boolean	addMult(int index, int len, E elem) Inserts element multiple time to list, starting at the specified position.
abstract <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.
abstract int	capacity() Returns capacity of this list.
void	clear()
java.lang.Object	clone() Returns a shallow copy of this list instance.
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.
IList<E>	copy() Returns a shallow copy of this list instance.
void	copy(int srcIndex, int dstIndex, int len) Copy specified elements.
java.util.Iterator<E>	descendingIterator()
void	drag(int srcIndex, int dstIndex, int len) Drag specified elements.
E	element()
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)
IList<E>	extract(int index, int len) Removes specified range of elements from list and return them.
IList<E>	extractWhere(IPredicate<E> predicate) Removes and returns all elements in the list which match the predicate.
void	fill(E elem) Fill list.
void	filter(IPredicate<? super E> predicate) Filter the list using the specified predicate.
E	get(int index)
IList<E>	getAll(E elem) Returns all elements in the list equal to the specified element.
IList<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 as array.
int	getCount(E elem) Counts how many times the specified element is contained in the list.
java.util.Set<E>	getDistinct() Returns distinct elements in the list.
E	getFirst()
E	getLast()
IList<E>	getWhere(IPredicate<E> predicate) Returns all elements in the list which match the predicate.
int	hashCode()
int	indexOf(java.lang.Object elem)
int	indexOf(java.lang.Object elem, int fromIndex) Returns the index of the first occurrence of the specified element in this list, starting the search at the specified position.
void	initAll(java.util.Collection<? extends E> coll) Initializes the list so it will afterwards only contain the elements of the collection.
void	initAll(IList<? extends E> list) Initializes the list so it will afterwards only contain the elements of the collection.
void	initArray(E... elems) Initializes the list so it will afterwards only contain the elements of the array.
void	initMult(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)
int	lastIndexOf(java.lang.Object elem, int fromIndex) Returns the index of the last occurrence of the specified element in this list, starting the search at the specified position.
java.util.ListIterator<E>	listIterator()
java.util.ListIterator<E>	listIterator(int index)
<R> IList<R>	mappedList(IFunction<E,R> mapper) Create a new list by applying the specified mapper to all elements.
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	put(int index, E elem) Sets or adds the element.
void	putAll(int index, java.util.Collection<? extends E> coll) Set or add the specified elements.
void	putAll(int index, IList<? extends E> list) Set or add the specified elements.
void	putArray(int index, E... elems) Set or add the specified elements.
void	putMult(int index, int len, E elem) Set or add the specified element multiple times.
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)
IList<E>	removeAll(E elem) Removes all equal elements.
boolean	removeAll(IList<?> coll)
E	removeFirst()
boolean	removeFirstOccurrence(java.lang.Object elem)
E	removeLast()
boolean	removeLastOccurrence(java.lang.Object elem)
void	removeWhere(IPredicate<E> predicate) Removes all elements in the list which match the predicate.
void	replaceAll(int index, int len, java.util.Collection<? extends E> coll) Replaces the specified range with new elements.
void	replaceAll(int index, int len, IList<? extends E> list) Replaces the specified range with new elements.
void	replaceArray(int index, int len, E... elems) Replaces the specified range with new elements.
void	replaceMult(int index, int len, int numElems, E elem) Replaces the specified range with new elements.
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(IList<?> coll)
void	retainWhere(IPredicate<E> predicate) Retains all elements in the list which match the predicate.
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) Sets the specified elements.
void	setAll(int index, IList<? extends E> list) Sets the specified elements.
void	setArray(int index, E... elems) Sets the specified elements.
void	setMult(int index, int len, E elem) Sets the element multiple times.
abstract int	size()
void	sort(java.util.Comparator<? super E> comparator) Sort elements in the list using the specified comparator.
abstract void	sort(int index, int len, java.util.Comparator<? super E> comparator) Sort specified elements in the list using the specified comparator.
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()
static <E> void	transferCopy(IList<E> src, int srcIndex, int srcLen, IList<? super E> dst, int dstIndex, int dstLen) Copies elements from one list to another.
static <E> void	transferMove(IList<E> src, int srcIndex, int srcLen, IList<? super E> dst, int dstIndex, int dstLen) Moves elements from one list to another by setting it to null in the source list.
static <E> void	transferRemove(IList<E> src, int srcIndex, int srcLen, IList<? super E> dst, int dstIndex, int dstLen) Moves elements from one list to another by removing it from the source list.
static <E> void	transferSwap(IList<E> src, int srcIndex, IList<E> dst, int dstIndex, int len) Swaps elements from two lists.
abstract void	trimToSize() An application can use this operation to minimize the storage of an instance.
abstract IList<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

IList

public IList()

Method Detail

copy

public IList<E> copy()

Returns a shallow copy of this list 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 an IList.

Returns:

a clone of this instance

See Also:

clone()

unmodifiableList

public abstract IList<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 list instance. (The elements themselves are not copied).

Overrides:

clone in class java.lang.Object

Returns:

a clone of this list 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>

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

Throws:

java.lang.IndexOutOfBoundsException - if the range is invalid

size

public abstract 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 abstract int capacity()

Returns capacity of this list. Note that two lists 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 list

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>

put

public E put(int index,
    E elem)

Sets or adds the element. If the index is smaller than the size of the list, the existing element is replaced. If the index equals the size of the list, the element is added.

Parameters:

index - index where element will be placed

elem - element to put

Returns:

old element if an element was replaced, null if the element was added

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 abstract void trimToSize()

An application can use this operation to minimize the storage of an 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>

getCount

public int getCount(E elem)

Counts how many times the specified element is contained in the list.

Parameters:

elem - element to count

Returns:

count how many times the specified element is contained in the list

getAll

public IList<E> getAll(E elem)

Returns all elements in the list equal to the specified element.

Parameters:

elem - element to look for

Returns:

all elements in the list equal to the specified element

getWhere

public IList<E> getWhere(IPredicate<E> predicate)

Returns all elements in the list which match the predicate.

Parameters:

predicate - predicate

Returns:

all elements in the list which match the predicate

removeWhere

public void removeWhere(IPredicate<E> predicate)

Removes all elements in the list which match the predicate.

Parameters:

predicate - predicate

retainWhere

public void retainWhere(IPredicate<E> predicate)

Retains all elements in the list which match the predicate.

Parameters:

predicate - predicate

extractWhere

public IList<E> extractWhere(IPredicate<E> predicate)

Removes and returns all elements in the list which match the predicate.

Parameters:

predicate - predicate

Returns:

elements which have been removed from the list

getDistinct

public java.util.Set<E> getDistinct()

Returns distinct elements in the list.

Returns:

distinct elements in the list

mappedList

public <R> IList<R> mappedList(IFunction<E,R> mapper)

Create a new list by applying the specified mapper to all elements.

Parameters:

mapper - mapper function

Returns:

created list

filter

public void filter(IPredicate<? super E> predicate)

Filter the list using the specified predicate. Only element which are allowed remain in the list, the others are removed

Parameters:

predicate - predicate used for filtering

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>

indexOf

public int indexOf(java.lang.Object elem,
          int fromIndex)

Returns the index of the first occurrence of the specified element in this list, starting the search at the specified position. If the element is not found, -1 is returned.

Parameters:

elem - element to search for

fromIndex - start index for search

Returns:

the index of the first occurrence of the specified element in this list that is greater than or equal to fromIndex, or -1 if this list does not contain the element

See Also:

indexOf(Object)

lastIndexOf

public int lastIndexOf(java.lang.Object elem,
              int fromIndex)

Returns the index of the last occurrence of the specified element in this list, starting the search at the specified position. If the element is not found, -1 is returned.

Parameters:

elem - element to search for

fromIndex - start index for search

Returns:

the index of the last occurrence of the specified element in this list that is less than or equal to fromIndex, or -1 if this list does not contain the element

See Also:

lastIndexOf(Object)

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>

addIfAbsent

public boolean addIfAbsent(E elem)

Add elements if it is not already contained in the list.

Parameters:

elem - element to add

Returns:

true if element has been added, false if not

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 IList<E> removeAll(E elem)

Removes all equal elements.

Parameters:

elem - element

Returns:

removed equal elements (never null)

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(IList<?> 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(IList<?> 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>

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>

transferCopy

public static <E> void transferCopy(IList<E> src,
                    int srcIndex,
                    int srcLen,
                    IList<? super E> dst,
                    int dstIndex,
                    int dstLen)

Copies elements from one list to another. Elements and size of source list do not change. The elements in the specified range in the destination list are removed and the elements specified to be copied are inserted. If source and destination list are identical, the method behaves like copy(int, int, int).

Type Parameters:

E - type of elements stored in the list

Parameters:

src - source list

srcIndex - index of first element in source list

srcLen - number of elements to copy

dst - destination list

dstIndex - index of first element in destination list

dstLen - number of elements to replace in destination list

Throws:

java.lang.IndexOutOfBoundsException - if the ranges are invalid

transferMove

public static <E> void transferMove(IList<E> src,
                    int srcIndex,
                    int srcLen,
                    IList<? super E> dst,
                    int dstIndex,
                    int dstLen)

Moves elements from one list to another by setting it to null in the source list. Elements in the source range are set to null, but size of source list does not change. The elements in the specified range in the destination list are removed and the elements specified to be moved are inserted. If source and destination list are identical, the method behaves like move(int, int, int).

Type Parameters:

E - type of elements stored in the list

Parameters:

src - source list

srcIndex - index of first element in source list

srcLen - number of elements to copy

dst - destination list

dstIndex - index of first element in destination list

dstLen - number of elements to replace in destination list

Throws:

java.lang.IndexOutOfBoundsException - if the ranges are invalid

transferRemove

public static <E> void transferRemove(IList<E> src,
                      int srcIndex,
                      int srcLen,
                      IList<? super E> dst,
                      int dstIndex,
                      int dstLen)

Moves elements from one list to another by removing it from the source list. So the size of source list will change. The elements in the specified range in the destination list are removed and the elements specified to be moved are inserted. If source and destination list are identical, the method behaves like drag(int, int, int).

Type Parameters:

E - type of elements stored in the list

Parameters:

src - source list

srcIndex - index of first element in source list

srcLen - number of elements to copy

dst - destination list

dstIndex - index of first element in destination list

dstLen - number of elements to replace in destination list

Throws:

java.lang.IndexOutOfBoundsException - if the ranges are invalid

transferSwap

public static <E> void transferSwap(IList<E> src,
                    int srcIndex,
                    IList<E> dst,
                    int dstIndex,
                    int len)

Swaps elements from two lists. The size of both source and destination list do not change. If source and destination list are identical, the method behaves like swap(int, int, int).

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 IList<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:

list containing the specified range of elements

extract

public IList<E> extract(int index,
               int len)

Removes specified range of elements from list and return them.

Parameters:

index - index of first element to retrieve

len - number of elements to retrieve

Returns:

list containing the specified range of elements

getArray

public E[] getArray(int index,
           int len)

Returns specified range of elements from list as array.

Parameters:

index - index of first element to retrieve

len - number of elements to retrieve

Returns:

array containing the specified range of elements

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

Throws:

java.lang.IndexOutOfBoundsException - if the range is invalid

addAll

public boolean addAll(IList<? 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,
             IList<? 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

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

addArray

public boolean addArray(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

addArray

public boolean addArray(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

addMult

public boolean addMult(int len,
              E elem)

Adds element multiple time to list.

Parameters:

elem - element to be added to this list

Returns:

true if this list changed as a result of the call

addMult

public boolean addMult(int index,
              int len,
              E elem)

Inserts element multiple time to 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

elem - element 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

setAll

public void setAll(int index,
          IList<? extends E> list)

Sets the specified elements.

Parameters:

index - index of first element to set

list - list with elements to set

Throws:

java.lang.IndexOutOfBoundsException - if the range is invalid

setAll

public void setAll(int index,
          java.util.Collection<? extends E> coll)

Sets the specified elements.

Parameters:

index - index of first element to set

coll - collection with elements to set

setArray

public void setArray(int index,
            E... elems)

Sets the specified elements.

Parameters:

index - index of first element to set

elemes - array with elements to set

Throws:

java.lang.IndexOutOfBoundsException - if the range is invalid

setMult

public void setMult(int index,
           int len,
           E elem)

Sets the element multiple times.

Parameters:

index - index of first element to set

elem - element to set

putAll

public void putAll(int index,
          IList<? extends E> list)

Set or add the specified elements.

Parameters:

index - index of first element to set or add

list - list with elements to set or add

putAll

public void putAll(int index,
          java.util.Collection<? extends E> coll)

Set or add the specified elements. If the index is smaller than the size of the list, the existing element is replaced. If the index equals the size of the list, the element is added.

Parameters:

index - index of first element to set or add

coll - collection with elements to set or add

putArray

public void putArray(int index,
            E... elems)

Set or add the specified elements. If the index is smaller than the size of the list, the existing element is replaced. If the index equals the size of the list, the element is added.

Parameters:

index - index of first element to set or add

elems - array with elements to set or add

putMult

public void putMult(int index,
           int len,
           E elem)

Set or add the specified element multiple times. If the index is smaller than the size of the list, the existing element is replaced. If the index equals the size of the list, the element is added.

Parameters:

index - index of first element to set or add

len - element to set or add

initAll

public void initAll(IList<? extends E> list)

Initializes the list so it will afterwards only contain the elements of the collection. The list will grow or shrink as needed.

Parameters:

list - list with elements

Throws:

java.lang.IndexOutOfBoundsException - if the length is invalid

initAll

public void initAll(java.util.Collection<? extends E> coll)

Initializes the list so it will afterwards only contain the elements of the collection. The list will grow or shrink as needed.

Parameters:

coll - collection with elements

Throws:

java.lang.IndexOutOfBoundsException - if the length is invalid

initArray

public void initArray(E... elems)

Initializes the list so it will afterwards only contain the elements of the array. The list will grow or shrink as needed.

Parameters:

elems - array with elements

Throws:

java.lang.IndexOutOfBoundsException - if the length is invalid

initMult

public void initMult(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

Throws:

java.lang.IndexOutOfBoundsException - if the length is invalid

replaceAll

public void replaceAll(int index,
              int len,
              java.util.Collection<? extends E> coll)

Replaces the specified range with new elements. This method is very powerful as it offers the functionality of many other methods which are therefore only offered for convenience:
- addAll(index, list) -> replaceAll(index, 0, list)
- setAll(index, list) -> replaceAll(index, list.size(), list)
- putAll(index, list) -> replaceAll(index, -1, list)
- initAll(list) -> replaceAll(0, this.size(), list)
- remove(index, list) -> replaceAll(index, list.size(), null)

Parameters:

index - index of first element to replace, use -1 for the position after the last element (this.size())

len - number of elements to replace, use -1 for getting behavior of putAll()

coll - collection with elements which replace the old elements, use null if elements should only be removed

Throws:

java.lang.IndexOutOfBoundsException - if the range is invalid

replaceArray

public void replaceArray(int index,
                int len,
                E... elems)

Replaces the specified range with new elements. This method is very powerful as it offers the functionality of many other methods which are therefore only offered for convenience:
- addAll(index, list) -> replaceAll(index, 0, list)
- setAll(index, list) -> replaceAll(index, list.size(), list)
- putAll(index, list) -> replaceAll(index, -1, list)
- initAll(list) -> replaceAll(0, this.size(), list)
- remove(index, list) -> replaceAll(index, list.size(), null)

Parameters:

index - index of first element to replace, use -1 for the position after the last element (this.size())

len - number of elements to replace, use -1 for getting behavior of putAll()

elems - array with elements which replace the old elements, use null if elements should only be removed

Throws:

java.lang.IndexOutOfBoundsException - if the range is invalid

replaceMult

public void replaceMult(int index,
               int len,
               int numElems,
               E elem)

Replaces the specified range with new elements. This method is very powerful as it offers the functionality of many other methods which are therefore only offered for convenience:
- addAll(index, list) -> replaceAll(index, 0, list)
- setAll(index, list) -> replaceAll(index, list.size(), list)
- putAll(index, list) -> replaceAll(index, -1, list)
- initAll(list) -> replaceAll(0, this.size(), list)
- remove(index, list) -> replaceAll(index, list.size(), null)

Parameters:

index - index of first element to replace, use -1 for the position after the last element (this.size())

len - number of elements to replace, use -1 for getting behavior of putAll()

numElems - number of time element has to be added

elem - element to add

Throws:

java.lang.IndexOutOfBoundsException - if the range is invalid

replaceAll

public void replaceAll(int index,
              int len,
              IList<? extends E> list)

Replaces the specified range with new elements. This method is very powerful as it offers the functionality of many other methods which are therefore only offered for convenience:
- addAll(index, list) -> replaceAll(index, 0, list)
- setAll(index, list) -> replaceAll(index, list.size(), list)
- putAll(index, list) -> replaceAll(index, -1, list)
- initAll(list) -> replaceAll(0, this.size(), list)
- remove(index, list) -> replaceAll(index, list.size(), null)

Parameters:

index - index of first element to replace, use -1 for the position after the last element (this.size())

len - number of elements to replace, use -1 for getting behavior of putAll()

list - list with elements which replace the old elements, use null if elements should only be removed

Throws:

java.lang.IndexOutOfBoundsException - if the range is invalid

fill

public void fill(E elem)

Fill list.

Parameters:

elem - element used for filling

copy

public void copy(int srcIndex,
        int dstIndex,
        int len)

Copy specified elements. Source and destination ranges may overlap. The size of the list does not change.

Parameters:

srcIndex - index of first source element to copy

dstIndex - index of first destination element to copy

len - number of elements to copy

Throws:

java.lang.IndexOutOfBoundsException - if the ranges are invalid

move

public void move(int srcIndex,
        int dstIndex,
        int len)

Move specified elements. Source and destination ranges may overlap. The elements which are moved away are set to null, so the size of the list does not change.

Parameters:

srcIndex - index of first source element to move

dstIndex - index of first destination element to move

len - number of elements to move

Throws:

java.lang.IndexOutOfBoundsException - if the ranges are invalid

drag

public void drag(int srcIndex,
        int dstIndex,
        int len)

Drag specified elements. Source and destination ranges may overlap. The size of the list does not change and it contains the same elements as before, but in changed order.

Parameters:

srcIndex - index of first source element to move

dstIndex - index of first destination element to move

len - number of elements to move

Throws:

java.lang.IndexOutOfBoundsException - if the ranges are invalid

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 are invalid

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

Throws:

java.lang.IndexOutOfBoundsException - if the ranges are invalid

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

Throws:

java.lang.IndexOutOfBoundsException - if the ranges are invalid

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 abstract 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)

Throws:

java.lang.IndexOutOfBoundsException - if the range is invalid

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 abstract <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.

Throws:

java.lang.IndexOutOfBoundsException - if the range is invalid

See Also:

Arrays.binarySearch(long[], long)