PackedIntegerArrayList

java.lang.Object
- info.bioinfweb.commons.collections.PackedIntegerArrayList

```
public class PackedIntegerArrayList
extends java.lang.Object
```
Implements a list of packed integer values which can occupy a space between 1 and 63 bits per value depending on the specified constructor parameter. The number space represented by these integers may but does not have to include negative values, depending on the constructor parameter minValue.
All elements are stored in an array of long values. If the number of bits in this array is not sufficient anymore to take up the values of this list, a new array is created automatically. The initial number of elements (not equal to the number of longs in the underlying array object) the list can take up before creating a new array object can be specified in the constructor.
This class can be used to store large lists of integer values in a specific range in a memory efficient way.

Author:

Ben Stöver

Field Summary

Fields
Modifier and Type	Field and Description
`protected long[]`	`array` The array containing the bits used to store values contained in this list.
`static int`	`BLOCK_BITS`
`static int`	`BLOCK_SIZE`
`static int`	`MAX_ARRAY_LENGTH`
`static int`	`MOD_MASK`

Constructor Summary

Constructors
Constructor and Description
`PackedIntegerArrayList(int bitsPerValue, long minValue, long initialCapacity)` Creates a new instance of this class.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`add(long value)` Adds the specified element to the end of this list.
`void`	`add(long index, long value)` Adds the specified element to this list and moves other elements to the right if necessary.
`protected int`	`calculateArrayLength(long capacity)` Calculates the number of `long` array elements necessary to store the specified number of elements.
`static int`	`calculateBitsPerValue(int elementCount)` Calculates how many bits are necessary to represent the specified number of different values.
`void`	`ensureCapacity(long newCapacity)` Makes sure that the underlying array can take up at least the specified number of elements.
`long`	`get(long index)` Returns the element stored at the specified index.
`long`	`getBitsPerValue()` Returns the length in bits of an entry in this list.
`long`	`getMaxValue()` Returns the maximum value that can be represented by an element of this list.
`long`	`getMinValue()` Returns the minimum value that can be represented by an element of this list.
`protected void`	`insertRange(long index, long length)` Reserves space for the specified number of elements at the specified position.
`void`	`remove(long index)` Removes the element at the specified position from this list.
`protected void`	`removeRange(long index, long length)` Removes the specified elements from this list.
`void`	`set(long index, long value)` Replaces the value at the specified position with the new value.
`long`	`size()` Returns the number of elements currently contained in this list.

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

- Field Detail
  - MAX_ARRAY_LENGTH
```
public static final int MAX_ARRAY_LENGTH
```
    See Also:
    
    Constant Field Values
  - BLOCK_SIZE
```
public static final int BLOCK_SIZE
```
    See Also:
    
    Constant Field Values
  - BLOCK_BITS
```
public static final int BLOCK_BITS
```
    See Also:
    
    Constant Field Values
  - MOD_MASK
```
public static final int MOD_MASK
```
    See Also:
    
    Constant Field Values
  - array
```
protected long[] array
```
    The array containing the bits used to store values contained in this list.
- Constructor Detail
  - PackedIntegerArrayList
```
public PackedIntegerArrayList(int bitsPerValue,
                              long minValue,
                              long initialCapacity)
```
    Creates a new instance of this class.
    
    Parameters:
    
    bitsPerValue - the number of bit each value will consume in memory
    
    minValue - the minimum value to be stored in the list
    
    initialCapacity - the number of values the underlying array can take up initially
    
    See Also:
    
    calculateBitsPerValue(int)
- Method Detail
  - calculateBitsPerValue
```
public static int calculateBitsPerValue(int elementCount)
```
    Calculates how many bits are necessary to represent the specified number of different values.
    
    Parameters:
    
    elementCount - the number of elements to be represented
    
    Returns:
    
    the necessary length in bits for a representation of elementCount different values/objects
  - getMinValue
```
public long getMinValue()
```
    Returns the minimum value that can be represented by an element of this list.
    
    Returns:
    
    the minimum value specified in the constructor
  - getMaxValue
```
public long getMaxValue()
```
    Returns the maximum value that can be represented by an element of this list.
    
    Returns:
    
    a value depending on getMinValue() and the specified number of bits per value
  - getBitsPerValue
```
public long getBitsPerValue()
```
    Returns the length in bits of an entry in this list.
    
    Returns:
    
    the number of bits each element in this list uses
  - calculateArrayLength
```
protected int calculateArrayLength(long capacity)
```
    Calculates the number of long array elements necessary to store the specified number of elements.
    
    Parameters:
    
    capacity - the number of list elements to be stored
    
    Returns:
    
    the needed array size
  - ensureCapacity
```
public void ensureCapacity(long newCapacity)
```
    Makes sure that the underlying array can take up at least the specified number of elements. If the current array is too small a new array which is at least 1.5 times as large as the current one (or larger if the requested capacity requires it) is created and the current contents are copied there.
    
    Parameters:
    
    newCapacity - the number of elements that need to be stored in the array
  - insertRange
```
protected void insertRange(long index,
                           long length)
```
    Reserves space for the specified number of elements at the specified position. Elements right of the specified position are moved accordingly. The new elements are not initialized. The underlying array is resized if necessary.
    
    Parameters:
    
    index - the index of the first element to be inserted
    
    length - the number of elements to be inserted
  - removeRange
```
protected void removeRange(long index,
                           long length)
```
    Removes the specified elements from this list. All elements to the right of the removed sequence are copied to the left accordingly.
    
    Parameters:
    
    index - the index of the first element to be removed
    
    length - the number of elements to be removed
    
    Throws:
    
    java.lang.IllegalArgumentException - if the specified range is outside the current size of the list
  - add
```
public void add(long index,
                long value)
```
    Adds the specified element to this list and moves other elements to the right if necessary.
    
    Parameters:
    
    index - the index where the new element shall be inserted
    
    value - the value to be inserted
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if index is lower than 0 or greater than the current size of the list
    
    java.lang.IllegalArgumentException - if value does not fit into the range specified by the constructor parameters bitsPerValue and minValue
  - add
```
public void add(long value)
```
    Adds the specified element to the end of this list.
    
    Parameters:
    
    value - the value to be appended
    
    Throws:
    
    java.lang.IllegalArgumentException - if value does not fit into the range specified by the constructor parameters bitsPerValue and minValue
  - get
```
public long get(long index)
```
    Returns the element stored at the specified index.
    
    Parameters:
    
    index - the index of the element to be read
    
    Returns:
    
    the integer value stored at this position
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if index is lower than 0 or greater or equal to the current size of the list
  - remove
```
public void remove(long index)
```
    Removes the element at the specified position from this list.
    
    Parameters:
    
    index - the index of the element to be removed
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if index is lower than 0 or greater or equal to the current size of the list
  - set
```
public void set(long index,
                long value)
```
    Replaces the value at the specified position with the new value.
    
    Parameters:
    
    index - the index of the value to be replaced
    
    value - the new value for the specified position
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if index is lower than 0 or greater or equal to the current size of the list
    
    java.lang.IllegalArgumentException - if value does not fit into the range specified by the constructor parameters bitsPerValue and minValue
  - size
```
public long size()
```
    Returns the number of elements currently contained in this list. (This is not equal to the size of the underlying long array.
    
    Returns:
    
    the current size of the list

Class PackedIntegerArrayList

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

MAX_ARRAY_LENGTH

BLOCK_SIZE

BLOCK_BITS

MOD_MASK

array

Constructor Detail

PackedIntegerArrayList

Method Detail

calculateBitsPerValue

getMinValue

getMaxValue

getBitsPerValue

calculateArrayLength

ensureCapacity

insertRange

removeRange

add

add

get

remove

set

size