TByteArrayList

java.lang.Object
- com.slimjars.dist.gnu.trove.list.array.TByteArrayList

All Implemented Interfaces:

TByteList, TByteCollection, Externalizable, Serializable
```
public class TByteArrayList
extends Object
implements TByteList, Externalizable
```
A resizable, array-backed list of byte primitives.

See Also:

Serialized Form

Field Summary

Fields

Modifier and Type	Field and Description
`protected byte[]`	`_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
`protected byte`	`no_entry_value` the byte value that represents null

Constructor Summary

Constructors

Modifier	Constructor and Description
	`TByteArrayList()` Creates a new `TByteArrayList` instance with the default capacity.
	`TByteArrayList(byte[] values)` Creates a new `TByteArrayList` instance whose capacity is the length of `values` array and whose initial contents are the specified values.
`protected`	`TByteArrayList(byte[] values, byte no_entry_value, boolean wrap)`
	`TByteArrayList(int capacity)` Creates a new `TByteArrayList` instance with the specified capacity.
	`TByteArrayList(int capacity, byte no_entry_value)` Creates a new `TByteArrayList` instance with the specified capacity.
	`TByteArrayList(TByteCollection collection)` Creates a new `TByteArrayList` instance that contains a copy of the collection passed to us.

Method Summary

All Methods

Static Methods

Instance Methods

Concrete Methods
Modifier and Type	Method and Description
`boolean`	`add(byte val)`
`void`	`add(byte[] vals)`
`void`	`add(byte[] vals, int offset, int length)`
`boolean`	`addAll(byte[] array)`
`boolean`	`addAll(Collection<? extends Byte> collection)`
`boolean`	`addAll(TByteCollection collection)`
`int`	`binarySearch(byte value)`
`int`	`binarySearch(byte value, int fromIndex, int toIndex)`
`void`	`clear()`
`void`	`clear(int capacity)` Flushes the internal state of the list, setting the capacity of the empty list to `capacity`.
`boolean`	`contains(byte value)`
`boolean`	`containsAll(byte[] array)`
`boolean`	`containsAll(Collection<?> collection)`
`boolean`	`containsAll(TByteCollection collection)`
`void`	`ensureCapacity(int capacity)` Grow the internal array as needed to accommodate the specified number of elements.
`boolean`	`equals(Object other)`
`void`	`fill(byte val)`
`void`	`fill(int fromIndex, int toIndex, byte val)`
`boolean`	`forEach(TByteProcedure procedure)`
`boolean`	`forEachDescending(TByteProcedure procedure)`
`byte`	`get(int offset)`
`byte`	`getNoEntryValue()`
`byte`	`getQuick(int offset)` Returns the value at the specified offset without doing any bounds checking.
`TByteList`	`grep(TByteProcedure condition)`
`int`	`hashCode()`
`int`	`indexOf(byte value)`
`int`	`indexOf(int offset, byte value)`
`void`	`insert(int offset, byte value)`
`void`	`insert(int offset, byte[] values)`
`void`	`insert(int offset, byte[] values, int valOffset, int len)`
`TByteList`	`inverseGrep(TByteProcedure condition)`
`boolean`	`isEmpty()`
`TByteIterator`	`iterator()`
`int`	`lastIndexOf(byte value)`
`int`	`lastIndexOf(int offset, byte value)`
`byte`	`max()`
`byte`	`min()`
`void`	`readExternal(ObjectInput in)`
`boolean`	`remove(byte value)`
`void`	`remove(int offset, int length)`
`boolean`	`removeAll(byte[] array)`
`boolean`	`removeAll(Collection<?> collection)`
`boolean`	`removeAll(TByteCollection collection)`
`byte`	`removeAt(int offset)`
`byte`	`replace(int offset, byte val)`
`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.
`boolean`	`retainAll(byte[] array)`
`boolean`	`retainAll(Collection<?> collection)`
`boolean`	`retainAll(TByteCollection collection)`
`void`	`reverse()`
`void`	`reverse(int from, int to)`
`byte`	`set(int offset, byte val)`
`void`	`set(int offset, byte[] values)`
`void`	`set(int offset, byte[] values, int valOffset, int length)`
`void`	`setQuick(int offset, byte val)` Sets the value at the specified offset without doing any bounds checking.
`void`	`shuffle(Random rand)`
`int`	`size()`
`void`	`sort()`
`void`	`sort(int fromIndex, int toIndex)`
`TByteList`	`subList(int begin, int end)`
`byte`	`sum()`
`byte[]`	`toArray()`
`byte[]`	`toArray(byte[] dest)`
`byte[]`	`toArray(byte[] dest, int offset, int len)`
`byte[]`	`toArray(byte[] dest, int source_pos, int dest_pos, int len)`
`byte[]`	`toArray(int offset, int len)`
`String`	`toString()`
`void`	`transformValues(TByteFunction function)`
`void`	`trimToSize()` Sheds any excess capacity above and beyond the current size of the list.
`static TByteArrayList`	`wrap(byte[] values)` Returns a primitive List implementation that wraps around the given primitive array.
`static TByteArrayList`	`wrap(byte[] values, byte no_entry_value)` Returns a primitive List implementation that wraps around the given primitive array.
`void`	`writeExternal(ObjectOutput out)`

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

Field Detail
- _data
```
protected byte[] _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
- no_entry_value
```
protected byte no_entry_value
```
  the byte value that represents null

Constructor Detail
- TByteArrayList
```
public TByteArrayList()
```
  Creates a new TByteArrayList instance with the default capacity.
- TByteArrayList
```
public TByteArrayList(int capacity)
```
  Creates a new TByteArrayList instance with the specified capacity.
  
  Parameters:
  
  capacity - an int value
- TByteArrayList
```
public TByteArrayList(int capacity,
                      byte no_entry_value)
```
  Creates a new TByteArrayList instance with the specified capacity.
  
  Parameters:
  
  capacity - an int value
  
  no_entry_value - an byte value that represents null.
- TByteArrayList
```
public TByteArrayList(TByteCollection collection)
```
  Creates a new TByteArrayList instance that contains a copy of the collection passed to us.
  
  Parameters:
  
  collection - the collection to copy
- TByteArrayList
```
public TByteArrayList(byte[] values)
```
  Creates a new TByteArrayList instance whose capacity is the length of values array and whose initial contents are the specified values.
  A defensive copy of the given values is held by the new instance.
  
  Parameters:
  
  values - an byte[] value
- TByteArrayList
```
protected TByteArrayList(byte[] values,
                         byte no_entry_value,
                         boolean wrap)
```

Method Detail

wrap
```
public static TByteArrayList wrap(byte[] values)
```
Returns a primitive List implementation that wraps around the given primitive array.
NOTE: mutating operation are allowed as long as the List does not grow. In that case an IllegalStateException will be thrown

Parameters:

values -

Returns:

wrap
```
public static TByteArrayList wrap(byte[] values,
                                  byte no_entry_value)
```
Returns a primitive List implementation that wraps around the given primitive array.
NOTE: mutating operation are allowed as long as the List does not grow. In that case an IllegalStateException will be thrown

Parameters:

values -

no_entry_value -

Returns:

getNoEntryValue
```
public byte getNoEntryValue()
```

ensureCapacity
```
public void ensureCapacity(int capacity)
```
Grow the internal array as needed to accommodate the specified number of elements. The size of the array bytes on each resize unless capacity requires more than twice the current capacity.

size
```
public int size()
```

isEmpty
```
public boolean isEmpty()
```

trimToSize
```
public void trimToSize()
```
Sheds any excess capacity above and beyond the current size of the list.

add
```
public boolean add(byte val)
```

add
```
public void add(byte[] vals)
```

add

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

insert

public void insert(int offset,
                   byte value)

insert

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

insert

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

get
```
public byte get(int offset)
```

getQuick
```
public byte getQuick(int offset)
```
Returns the value at the specified offset without doing any bounds checking.

set

public byte set(int offset,
                byte val)

replace

public byte replace(int offset,
                    byte val)

set

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

set

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

setQuick
```
public void setQuick(int offset,
                     byte val)
```
Sets the value at the specified offset without doing any bounds checking.

clear
```
public void clear()
```

clear
```
public void clear(int capacity)
```
Flushes the internal state of the list, setting the capacity of the empty list to capacity.

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 recycle a list without allocating new backing arrays.

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

remove
```
public boolean remove(byte value)
```

removeAt
```
public byte removeAt(int offset)
```

remove

public void remove(int offset,
                   int length)

iterator
```
public TByteIterator iterator()
```

containsAll

public boolean containsAll(Collection<?> collection)

containsAll

public boolean containsAll(TByteCollection collection)

containsAll

public boolean containsAll(byte[] array)

addAll

public boolean addAll(Collection<? extends Byte> collection)

addAll

public boolean addAll(TByteCollection collection)

addAll
```
public boolean addAll(byte[] array)
```

retainAll

public boolean retainAll(Collection<?> collection)

retainAll

public boolean retainAll(TByteCollection collection)

retainAll

public boolean retainAll(byte[] array)

removeAll

public boolean removeAll(Collection<?> collection)

removeAll

public boolean removeAll(TByteCollection collection)

removeAll

public boolean removeAll(byte[] array)

transformValues

public void transformValues(TByteFunction function)

reverse
```
public void reverse()
```

reverse

public void reverse(int from,
                    int to)

shuffle
```
public void shuffle(Random rand)
```

subList

public TByteList subList(int begin,
                         int end)

toArray
```
public byte[] toArray()
```

toArray

public byte[] toArray(int offset,
                      int len)

toArray
```
public byte[] toArray(byte[] dest)
```

toArray

public byte[] toArray(byte[] dest,
                      int offset,
                      int len)

toArray

public byte[] toArray(byte[] dest,
                      int source_pos,
                      int dest_pos,
                      int len)

equals
```
public boolean equals(Object other)
```

hashCode
```
public int hashCode()
```

forEach

public boolean forEach(TByteProcedure procedure)

forEachDescending

public boolean forEachDescending(TByteProcedure procedure)

sort
```
public void sort()
```

sort

public void sort(int fromIndex,
                 int toIndex)

fill
```
public void fill(byte val)
```

fill

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

binarySearch
```
public int binarySearch(byte value)
```

binarySearch

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

indexOf
```
public int indexOf(byte value)
```

indexOf

public int indexOf(int offset,
                   byte value)

lastIndexOf
```
public int lastIndexOf(byte value)
```

lastIndexOf

public int lastIndexOf(int offset,
                       byte value)

contains
```
public boolean contains(byte value)
```

grep

public TByteList grep(TByteProcedure condition)

inverseGrep

public TByteList inverseGrep(TByteProcedure condition)

max
```
public byte max()
```

min
```
public byte min()
```

sum
```
public byte sum()
```

toString
```
public String toString()
```

writeExternal

public void writeExternal(ObjectOutput out)
                   throws IOException

Specified by:: writeExternal in interface Externalizable
Throws:: IOException

readExternal

public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException

Specified by:: readExternal in interface Externalizable
Throws:: IOException; ClassNotFoundException

Class TByteArrayList

Field Summary

Fields

Constructor Summary

Constructors

Method Summary

Methods inherited from class java.lang.Object

Field Detail

_data

_pos

DEFAULT_CAPACITY

no_entry_value

Constructor Detail

TByteArrayList

TByteArrayList

TByteArrayList

TByteArrayList

TByteArrayList

TByteArrayList

Method Detail

wrap

wrap

getNoEntryValue

ensureCapacity

size

isEmpty

trimToSize

add

add

add

insert

insert

insert

get

getQuick

set

replace

set

set

setQuick

clear

clear

reset

resetQuick

remove

removeAt

remove

iterator

containsAll

containsAll

containsAll

addAll

addAll

addAll

retainAll

retainAll

retainAll

removeAll

removeAll

removeAll

transformValues

reverse

reverse

shuffle

subList

toArray

toArray

toArray

toArray

toArray

equals

hashCode

forEach

forEachDescending

sort

sort

fill

fill

binarySearch

binarySearch