GNU Trove

## gnu.trove
Class TFloatArrayList

    java.lang.Object
      gnu.trove.TFloatArrayList

All Implemented Interfaces:
  java.io.Externalizable, java.io.Serializable, java.lang.Cloneable

    public class TFloatArrayList

extends java.lang.Object
implements java.io.Externalizable, java.lang.Cloneable

A resizable, array-backed list of float primitives. Created: Sat Dec 29 14:21:12 2001

Author:
  Eric D. Friedman, Rob Eden
See Also:
  Serialized Form

Field Summary
`protected float[]` `_data` the data of the list
`protected int` `_pos` the index after the last entry in the list
`protected static int` `DEFAULT_CAPACITY` the default capacity for new lists

Constructor Summary
`TFloatArrayList()` Creates a new `TFloatArrayList` instance with the default capacity.
`TFloatArrayList(float[] values)` Creates a new `TFloatArrayList` instance whose capacity is the greater of the length of `values` and DEFAULT_CAPACITY and whose initial contents are the specified values.
`TFloatArrayList(int capacity)` Creates a new `TFloatArrayList` instance with the specified capacity.

Method Summary
`void` `add(float val)` Adds `val` to the end of the list, growing as needed.
`void` `add(float[] vals)` Adds the values in the array `vals` to the end of the list, in order.
`void` `add(float[] vals, int offset, int length)` Adds a subset of the values in the array `vals` to the end of the list, in order.
`int` `binarySearch(float value)` Performs a binary search for `value` in the entire list.
`int` `binarySearch(float value, int fromIndex, int toIndex)` Performs a binary search for `value` in the specified range.
`void` `clear()` Flushes the internal state of the list, resetting the capacity to the default.
`void` `clear(int capacity)` Flushes the internal state of the list, setting the capacity of the empty list to `capacity`.
`java.lang.Object` `clone()` Returns a clone of this list.
`boolean` `contains(float value)` Searches the list for `value`
`void` `ensureCapacity(int capacity)` Grow the internal array as needed to accommodate the specified number of elements.
`boolean` `equals(java.lang.Object other)` Compares this list to another list, value by value.
`void` `fill(float val)` Fills every slot in the list with the specified value.
`void` `fill(int fromIndex, int toIndex, float val)` Fills a range in the list with the specified value.
`boolean` `forEach(TFloatProcedure procedure)` Applies the procedure to each value in the list in ascending (front to back) order.
`boolean` `forEachDescending(TFloatProcedure procedure)` Applies the procedure to each value in the list in descending (back to front) order.
`float` `get(int offset)` Returns the value at the specified offset.
`float` `getQuick(int offset)` Returns the value at the specified offset without doing any bounds checking.
`float` `getSet(int offset, float val)` Sets the value at the specified offset and returns the previously stored value.
`TFloatArrayList` `grep(TFloatProcedure condition)` Searches the list for values satisfying `condition` in the manner of the *nix `grep` utility.
`int` `hashCode()`
`int` `indexOf(float value)` Searches the list front to back for the index of `value`.
`int` `indexOf(int offset, float value)` Searches the list front to back for the index of `value`, starting at `offset`.
`void` `insert(int offset, float value)` Inserts `value` into the list at `offset`.
`void` `insert(int offset, float[] values)` Inserts the array of `values` into the list at `offset`.
`void` `insert(int offset, float[] values, int valOffset, int len)` Inserts a slice of the array of `values` into the list at `offset`.
`TFloatArrayList` `inverseGrep(TFloatProcedure condition)` Searches the list for values which do not satisfy `condition`.
`boolean` `isEmpty()` Tests whether this list contains any values.
`int` `lastIndexOf(float value)` Searches the list back to front for the last index of `value`.
`int` `lastIndexOf(int offset, float value)` Searches the list back to front for the last index of `value`, starting at `offset`.
`float` `max()` Finds the maximum value in the list.
`float` `min()` Finds the minimum value in the list.
`void` `readExternal(java.io.ObjectInput in)`
`float` `remove(int offset)` Removes the value at `offset` from the list.
`void` `remove(int offset, int length)` Removes `length` values from the list, starting at `offset`
`void` `reset()` Sets the size of the list to 0, but does not change its capacity.
`void` `resetQuick()` Sets the size of the list to 0, but does not change its capacity.
`void` `reverse()` Reverse the order of the elements in the list.
`void` `reverse(int from, int to)` Reverse the order of the elements in the range of the list.
`void` `set(int offset, float val)` Sets the value at the specified offset.
`void` `set(int offset, float[] values)` Replace the values in the list starting at `offset` with the contents of the `values` array.
`void` `set(int offset, float[] values, int valOffset, int length)` Replace the values in the list starting at `offset` with `length` values from the `values` array, starting at valOffset.
`void` `setQuick(int offset, float val)` Sets the value at the specified offset without doing any bounds checking.
`void` `shuffle(java.util.Random rand)` Shuffle the elements of the list using the specified random number generator.
`int` `size()` Returns the number of values in the list.
`void` `sort()` Sort the values in the list (ascending) using the Sun quicksort implementation.
`void` `sort(int fromIndex, int toIndex)` Sort a slice of the list (ascending) using the Sun quicksort implementation.
`TFloatArrayList` `subList(int begin, int end)` Returns a sublist of this list.
`float[]` `toNativeArray()` Copies the contents of the list into a native array.
`void` `toNativeArray(float[] dest, int offset, int len)` Copies a slice of the list into a native array.
`float[]` `toNativeArray(int offset, int len)` Copies a slice of the list into a native array.
`java.lang.String` `toString()` Returns a String representation of the list, front to back.
`void` `transformValues(TFloatFunction function)` Transform each value in the list using the specified function.
`void` `trimToSize()` Sheds any excess capacity above and beyond the current size of the list.
`void` `writeExternal(java.io.ObjectOutput out)`

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

Field Detail

### _data

    protected float[] _data

  the data of the list

### _pos

    protected int _pos

  the index after the last entry in the list

### DEFAULT_CAPACITY

    protected static final int DEFAULT_CAPACITY

  the default capacity for new lists

  See Also:
    Constant Field Values

Constructor Detail

### TFloatArrayList

    public TFloatArrayList()

  Creates a new `TFloatArrayList` instance with the default capacity.

### TFloatArrayList

    public TFloatArrayList(int capacity)

  Creates a new `TFloatArrayList` instance with the specified capacity.

  Parameters:
    `capacity` - an `int` value

### TFloatArrayList

    public TFloatArrayList(float[] values)

  Creates a new `TFloatArrayList` instance whose capacity is the greater of the length of `values` and DEFAULT_CAPACITY and whose initial contents are the specified values.

  Parameters:
    `values` - an `float[]` value

Method Detail

### ensureCapacity

    public void ensureCapacity(int capacity)

  Grow the internal array as needed to accommodate the specified number of elements. The size of the array floats on each resize unless `capacity` requires more than twice the current capacity.

  Parameters:
    `capacity` - an `int` value

### size

    public int size()

  Returns the number of values in the list.

  Returns:
    the number of values in the list.

### isEmpty

    public boolean isEmpty()

  Tests whether this list contains any values.

  Returns:
    true if the list is empty.

### trimToSize

    public void trimToSize()

  Sheds any excess capacity above and beyond the current size of the list.

### add

    public void add(float val)

  Adds `val` to the end of the list, growing as needed.

  Parameters:
    `val` - an `float` value

### add

    public void add(float[] vals)

  Adds the values in the array `vals` to the end of the list, in order.

  Parameters:
    `vals` - an `float[]` value

### add

    public void add(float[] vals,
                    int offset,
                    int length)

  Adds a subset of the values in the array `vals` to the end of the list, in order.

  Parameters:
    `vals` - an `float[]` value
    `offset` - the offset at which to start copying
    `length` - the number of values to copy.

### insert

    public void insert(int offset,
                       float value)

  Inserts `value` into the list at `offset`. All values including and to the right of `offset` are shifted to the right.

  Parameters:
    `offset` - an `int` value
    `value` - an `float` value

### insert

    public void insert(int offset,
                       float[] values)

  Inserts the array of `values` into the list at `offset`. All values including and to the right of `offset` are shifted to the right.

  Parameters:
    `offset` - an `int` value
    `values` - an `float[]` value

### insert

    public void insert(int offset,
                       float[] values,
                       int valOffset,
                       int len)

  Inserts a slice of the array of `values` into the list at `offset`. All values including and to the right of `offset` are shifted to the right.

  Parameters:
    `offset` - an `int` value
    `values` - an `float[]` value
    `valOffset` - the offset in the values array at which to start copying.
    `len` - the number of values to copy from the values array

### get

    public float get(int offset)

  Returns the value at the specified offset.

  Parameters:
    `offset` - an `int` value
  Returns:
    an `float` value

### getQuick

    public float getQuick(int offset)

  Returns the value at the specified offset without doing any bounds checking.

  Parameters:
    `offset` - an `int` value
  Returns:
    an `float` value

### set

    public void set(int offset,
                    float val)

  Sets the value at the specified offset.

  Parameters:
    `offset` - an `int` value
    `val` - an `float` value

### getSet

    public float getSet(int offset,
                        float val)

  Sets the value at the specified offset and returns the previously stored value.

  Parameters:
    `offset` - an `int` value
    `val` - an `float` value
  Returns:
    the value previously stored at offset.

### set

    public void set(int offset,
                    float[] values)

  Replace the values in the list starting at `offset` with the contents of the `values` array.

  Parameters:
    `offset` - the first offset to replace
    `values` - the source of the new values

### set

    public void set(int offset,
                    float[] values,
                    int valOffset,
                    int length)

  Replace the values in the list starting at `offset` with `length` values from the `values` array, starting at valOffset.

  Parameters:
    `offset` - the first offset to replace
    `values` - the source of the new values
    `valOffset` - the first value to copy from the values array
    `length` - the number of values to copy

### setQuick

    public void setQuick(int offset,
                         float val)

  Sets the value at the specified offset without doing any bounds checking.

  Parameters:
    `offset` - an `int` value
    `val` - an `float` value

### clear

    public void clear()

  Flushes the internal state of the list, resetting the capacity to the default.

### clear

    public void clear(int capacity)

  Flushes the internal state of the list, setting the capacity of the empty list to `capacity`.

  Parameters:
    `capacity` - an `int` value

### reset

    public void reset()

  Sets the size of the list to 0, but does not change its capacity. This method can be used as an alternative to the `clear` method if you want to recyle a list without allocating new backing arrays.

  See Also:
    `clear()`

### resetQuick

    public void resetQuick()

  Sets the size of the list to 0, but does not change its capacity. This method can be used as an alternative to the `clear` method if you want to recyle a list without allocating new backing arrays. This method differs from `reset` in that it does not clear the old values in the backing array. Thus, it is possible for `getQuick` to return stale data if this method is used and the caller is careless about bounds checking.

  See Also:
    `reset()`, `clear()`, `getQuick(int)`

### remove

    public float remove(int offset)

  Removes the value at `offset` from the list.

  Parameters:
    `offset` - an `int` value
  Returns:
    the value previously stored at offset.

### remove

    public void remove(int offset,
                       int length)

  Removes `length` values from the list, starting at `offset`

  Parameters:
    `offset` - an `int` value
    `length` - an `int` value

### transformValues

    public void transformValues(TFloatFunction function)

  Transform each value in the list using the specified function.

  Parameters:
    `function` - a `TFloatFunction` value

### reverse

    public void reverse()

  Reverse the order of the elements in the list.

### reverse

    public void reverse(int from,
                        int to)

  Reverse the order of the elements in the range of the list.

  Parameters:
    `from` - the inclusive index at which to start reversing
    `to` - the exclusive index at which to stop reversing

### shuffle

    public void shuffle(java.util.Random rand)

  Shuffle the elements of the list using the specified random number generator.

  Parameters:
    `rand` - a `Random` value

### clone

    public java.lang.Object clone()

  Returns a clone of this list. Since this is a primitive collection, this will be a deep clone.

  Overrides:
    `clone` in class `java.lang.Object`
  Returns:
    a deep clone of the list.

### subList

    public TFloatArrayList subList(int begin,
                                   int end)

  Returns a sublist of this list.

  Parameters:
    `begin` - low endpoint (inclusive) of the subList.
    `end` - high endpoint (exclusive) of the subList.
  Returns:
    sublist of this list from begin, inclusive to end, exclusive.
  Throws:
    `java.lang.IndexOutOfBoundsException` - - endpoint out of range
    `java.lang.IllegalArgumentException` - - endpoints out of order (end > begin)

### toNativeArray

    public float[] toNativeArray()

  Copies the contents of the list into a native array.

  Returns:
    an `float[]` value

### toNativeArray

    public float[] toNativeArray(int offset,
                                 int len)

  Copies a slice of the list into a native array.

  Parameters:
    `offset` - the offset at which to start copying
    `len` - the number of values to copy.
  Returns:
    an `float[]` value

### toNativeArray

    public void toNativeArray(float[] dest,
                              int offset,
                              int len)

  Copies a slice of the list into a native array.

  Parameters:
    `dest` - the array to copy into.
    `offset` - the offset of the first value to copy
    `len` - the number of values to copy.

### equals

    public boolean equals(java.lang.Object other)

  Compares this list to another list, value by value.

  Overrides:
    `equals` in class `java.lang.Object`
  Parameters:
    `other` - the object to compare against
  Returns:
    true if other is a TFloatArrayList and has exactly the same values.

### hashCode

    public int hashCode()

  Overrides:
    `hashCode` in class `java.lang.Object`

### forEach

    public boolean forEach(TFloatProcedure procedure)

  Applies the procedure to each value in the list in ascending (front to back) order.

  Parameters:
    `procedure` - a `TFloatProcedure` value
  Returns:
    true if the procedure did not terminate prematurely.

### forEachDescending

    public boolean forEachDescending(TFloatProcedure procedure)

  Applies the procedure to each value in the list in descending (back to front) order.

  Parameters:
    `procedure` - a `TFloatProcedure` value
  Returns:
    true if the procedure did not terminate prematurely.

### sort

    public void sort()

  Sort the values in the list (ascending) using the Sun quicksort implementation.

  See Also:
    `Arrays.sort(long[])`

### sort

    public void sort(int fromIndex,
                     int toIndex)

  Sort a slice of the list (ascending) using the Sun quicksort implementation.

  Parameters:
    `fromIndex` - the index at which to start sorting (inclusive)
    `toIndex` - the index at which to stop sorting (exclusive)
  See Also:
    `Arrays.sort(long[])`

### fill

    public void fill(float val)

  Fills every slot in the list with the specified value.

  Parameters:
    `val` - the value to use when filling

### fill

    public void fill(int fromIndex,
                     int toIndex,
                     float val)

  Fills a range in the list with the specified value.

  Parameters:
    `fromIndex` - the offset at which to start filling (inclusive)
    `toIndex` - the offset at which to stop filling (exclusive)
    `val` - the value to use when filling

### binarySearch

    public int binarySearch(float value)

  Performs a binary search for `value` in the entire list. Note that you must @{link #sort sort} the list before doing a search.

  Parameters:
    `value` - the value to search for
  Returns:
    the absolute offset in the list of the value, or its negative insertion point into the sorted list.

### binarySearch

    public int binarySearch(float value,
                            int fromIndex,
                            int toIndex)

  Performs a binary search for `value` in the specified range. Note that you must @{link #sort sort} the list or the range before doing a search.

  Parameters:
    `value` - the value to search for
    `fromIndex` - the lower boundary of the range (inclusive)
    `toIndex` - the upper boundary of the range (exclusive)
  Returns:
    the absolute offset in the list of the value, or its negative insertion point into the sorted list.

### indexOf

    public int indexOf(float value)

  Searches the list front to back for the index of `value`.

  Parameters:
    `value` - an `float` value
  Returns:
    the first offset of the value, or -1 if it is not in the list.
  See Also:
    `for faster searches on sorted lists`

### indexOf

    public int indexOf(int offset,
                       float value)

  Searches the list front to back for the index of `value`, starting at `offset`.

  Parameters:
    `offset` - the offset at which to start the linear search (inclusive)
    `value` - an `float` value
  Returns:
    the first offset of the value, or -1 if it is not in the list.
  See Also:
    `for faster searches on sorted lists`

### lastIndexOf

    public int lastIndexOf(float value)

  Searches the list back to front for the last index of `value`.

  Parameters:
    `value` - an `float` value
  Returns:
    the last offset of the value, or -1 if it is not in the list.
  See Also:
    `for faster searches on sorted lists`

### lastIndexOf

    public int lastIndexOf(int offset,
                           float value)

  Searches the list back to front for the last index of `value`, starting at `offset`.

  Parameters:
    `offset` - the offset at which to start the linear search (exclusive)
    `value` - an `float` value
  Returns:
    the last offset of the value, or -1 if it is not in the list.
  See Also:
    `for faster searches on sorted lists`

### contains

    public boolean contains(float value)

  Searches the list for `value`

  Parameters:
    `value` - an `float` value
  Returns:
    true if value is in the list.

### grep

    public TFloatArrayList grep(TFloatProcedure condition)

  Searches the list for values satisfying `condition` in the manner of the *nix `grep` utility.

  Parameters:
    `condition` - a condition to apply to each element in the list
  Returns:
    a list of values which match the condition.

### inverseGrep

    public TFloatArrayList inverseGrep(TFloatProcedure condition)

  Searches the list for values which do not satisfy `condition`. This is akin to *nix `grep -v`.

  Parameters:
    `condition` - a condition to apply to each element in the list
  Returns:
    a list of values which do not match the condition.

### max

    public float max()

  Finds the maximum value in the list.

  Returns:
    the largest value in the list.
  Throws:
    `java.lang.IllegalStateException` - if the list is empty

### min

    public float min()

  Finds the minimum value in the list.

  Returns:
    the smallest value in the list.
  Throws:
    `java.lang.IllegalStateException` - if the list is empty

### toString

    public java.lang.String toString()

  Returns a String representation of the list, front to back.

  Overrides:
    `toString` in class `java.lang.Object`
  Returns:
    a `String` value

### writeExternal

    public void writeExternal(java.io.ObjectOutput out)
                       throws java.io.IOException

  Specified by:
    `writeExternal` in interface `java.io.Externalizable`
  Throws:
    `java.io.IOException`

### readExternal

    public void readExternal(java.io.ObjectInput in)
                      throws java.io.IOException,
                             java.lang.ClassNotFoundException

  Specified by:
    `readExternal` in interface `java.io.Externalizable`
  Throws:
    `java.io.IOException`
    `java.lang.ClassNotFoundException`

GNU Trove

GNU Trove is copyright © 2001-2009 Eric D. Friedman. All Rights Reserved.