info.bioinfweb.commons.collections

Class PackedPrimitiveWrapperArrayList<E extends java.lang.Number>

java.lang.Object

java.util.AbstractCollection<E>

java.util.AbstractList<E>

info.bioinfweb.commons.collections.PackedPrimitiveWrapperArrayList<E>

Type Parameters:

E - the primitive wrapper class to use (See above for details on how which classes are treated.)

All Implemented Interfaces:

java.lang.Iterable<E>, java.util.Collection<E>, java.util.List<E>

public abstract class PackedPrimitiveWrapperArrayList<E extends java.lang.Number>
extends java.util.AbstractList<E>

An adapter class providing access to an instance if PackedIntegerArrayList using the List interface where the element type can be any numeric primitive wrapper class of the Java API, namely Byte, Short, Integer or Long.

The number of bits per value to be stored in the underlying packed list can be determined independently of the selected wrapper type.

Using Float or Double would also be possible but they would be rounded to long before they are stored. If instances of BigInteger are used they would be treated as described in BigInteger.longValue().

Author:

Ben Stöver

Field Summary

Fields

Modifier and Type	Field and Description
protected PackedIntegerArrayList	packedList

Fields inherited from class java.util.AbstractList

modCount

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	PackedPrimitiveWrapperArrayList(int bitsPerValue, long minValue, int initialCapacity)

Method Summary

Modifier and Type	Method and Description
void	add(int index, E element)
static PackedPrimitiveWrapperArrayList<java.lang.Byte>	newByteInstance(int bitsPerValue, long minValue, int initialCapacity) Creates a new instance of this class using Byte elements.
static PackedPrimitiveWrapperArrayList<java.lang.Integer>	newIntegerInstance(int bitsPerValue, long minValue, int initialCapacity) Creates a new instance of this class using Integer elements.
static PackedPrimitiveWrapperArrayList<java.lang.Long>	newLongInstance(int bitsPerValue, long minValue, int initialCapacity) Creates a new instance of this class using Long elements.
static PackedPrimitiveWrapperArrayList<java.lang.Short>	newShortInstance(int bitsPerValue, long minValue, int initialCapacity) Creates a new instance of this class using Short elements.
E	remove(int index)
protected void	removeRange(int fromIndex, int toIndex)
E	set(int index, E element)
int	size()

Methods inherited from class java.util.AbstractList

add, addAll, clear, equals, get, hashCode, indexOf, iterator, lastIndexOf, listIterator, listIterator, subList

Methods inherited from class java.util.AbstractCollection

addAll, contains, containsAll, isEmpty, remove, removeAll, retainAll, toArray, toArray, toString

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.util.List

addAll, contains, containsAll, isEmpty, remove, removeAll, replaceAll, retainAll, sort, spliterator, toArray, toArray

Methods inherited from interface java.util.Collection

parallelStream, removeIf, stream

Methods inherited from interface java.lang.Iterable

forEach

Field Detail

packedList

protected PackedIntegerArrayList packedList

Constructor Detail

PackedPrimitiveWrapperArrayList

protected PackedPrimitiveWrapperArrayList(int bitsPerValue,
                                          long minValue,
                                          int initialCapacity)

Method Detail

newByteInstance

public static PackedPrimitiveWrapperArrayList<java.lang.Byte> newByteInstance(int bitsPerValue,
                                                                              long minValue,
                                                                              int initialCapacity)

Creates a new instance of this class using Byte elements.

Parameters:

bitsPerValue - the number of bits per value that shall be stored

minValue - the minimal value to be represented by the underlying packed list

initialCapacity - the initial number of elements the underlying packed list can take up before resizing its array

Returns:

the new instance

Throws:

java.lang.IllegalArgumentException - if the combination if bits per value and the minimal value could lead to values that cannot be stored in a byte

newShortInstance

public static PackedPrimitiveWrapperArrayList<java.lang.Short> newShortInstance(int bitsPerValue,
                                                                                long minValue,
                                                                                int initialCapacity)

Creates a new instance of this class using Short elements.

Parameters:

bitsPerValue - the number of bits per value that shall be stored

minValue - the minimal value to be represented by the underlying packed list

initialCapacity - the initial number of elements the underlying packed list can take up before resizing its array

Returns:

the new instance

Throws:

java.lang.IllegalArgumentException - if the combination if bits per value and the minimal value could lead to values that cannot be stored in a short

newIntegerInstance

public static PackedPrimitiveWrapperArrayList<java.lang.Integer> newIntegerInstance(int bitsPerValue,
                                                                                    long minValue,
                                                                                    int initialCapacity)

Creates a new instance of this class using Integer elements.

Parameters:

bitsPerValue - the number of bits per value that shall be stored

minValue - the minimal value to be represented by the underlying packed list

initialCapacity - the initial number of elements the underlying packed list can take up before resizing its array

Returns:

the new instance

Throws:

java.lang.IllegalArgumentException - if the combination if bits per value and the minimal value could lead to values that cannot be stored in a int

newLongInstance

public static PackedPrimitiveWrapperArrayList<java.lang.Long> newLongInstance(int bitsPerValue,
                                                                              long minValue,
                                                                              int initialCapacity)

Creates a new instance of this class using Long elements.

Parameters:

bitsPerValue - the number of bits per value that shall be stored

minValue - the minimal value to be represented by the underlying packed list

initialCapacity - the initial number of elements the underlying packed list can take up before resizing its array

Returns:

the new instance

Throws:

java.lang.IllegalArgumentException - if the combination if bits per value and the minimal value could lead to values that cannot be stored in a long

add

public void add(int index,
                E element)

Specified by:

add in interface java.util.List<E extends java.lang.Number>

Overrides:

add in class java.util.AbstractList<E extends java.lang.Number>

remove

public E remove(int index)

Specified by:

remove in interface java.util.List<E extends java.lang.Number>

Overrides:

remove in class java.util.AbstractList<E extends java.lang.Number>

removeRange

protected void removeRange(int fromIndex,
                           int toIndex)

Overrides:

removeRange in class java.util.AbstractList<E extends java.lang.Number>

set

public E set(int index,
             E element)

Specified by:

set in interface java.util.List<E extends java.lang.Number>

Overrides:

set in class java.util.AbstractList<E extends java.lang.Number>

size

public int size()

Specified by:

size in interface java.util.Collection<E extends java.lang.Number>

Specified by:

size in interface java.util.List<E extends java.lang.Number>

Specified by:

size in class java.util.AbstractCollection<E extends java.lang.Number>