java.lang.Object
- org.eclipse.collections.impl.primitive.AbstractByteIterable
- - org.eclipse.collections.impl.list.mutable.primitive.ByteArrayList

All Implemented Interfaces:

java.io.Externalizable, java.io.Serializable, ByteIterable, MutableByteCollection, ByteList, MutableByteList, OrderedByteIterable, ReversibleByteIterable, PrimitiveIterable
```
public class ByteArrayList
extends AbstractByteIterable
implements MutableByteList, java.io.Externalizable
```
ByteArrayList is similar to FastList, and is memory-optimized for byte primitives. This file was automatically generated from template file primitiveArrayList.stg.

Since:

3.0.

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class Description

private class ByteArrayList.InternalByteIterator

Field Summary

Fields
Modifier and Type	Field	Description
`private static byte[]`	`DEFAULT_SIZED_EMPTY_ARRAY`
`protected byte[]`	`items`
`private static int`	`MAXIMUM_ARRAY_SIZE`
`private static long`	`serialVersionUID`
`protected int`	`size`
`private static byte[]`	`ZERO_SIZED_ARRAY`

Constructor Summary

Constructors
Constructor Description

ByteArrayList()

ByteArrayList(byte... array)

ByteArrayList(int initialCapacity)

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`boolean`	`add(byte newItem)`
`boolean`	`addAll(byte... source)`
`boolean`	`addAll(ByteIterable source)`
`boolean`	`addAllAtIndex(int index, byte... source)`
`boolean`	`addAllAtIndex(int index, ByteIterable source)`
`void`	`addAtIndex(int index, byte element)`
`private void`	`addAtIndexLessThanSize(int index, byte element)`
`boolean`	`allSatisfy(BytePredicate predicate)`	Returns true if all of the elements in the ByteIterable return true for the specified predicate, otherwise returns false.
`boolean`	`anySatisfy(BytePredicate predicate)`	Returns true if any of the elements in the ByteIterable return true for the specified predicate, otherwise returns false.
`void`	`appendString(java.lang.Appendable appendable, java.lang.String start, java.lang.String separator, java.lang.String end)`	Prints a string representation of this collection onto the given `Appendable`.
`LazyByteIterable`	`asReversed()`
`MutableByteList`	`asSynchronized()`
`MutableByteList`	`asUnmodifiable()`
`int`	`binarySearch(byte value)`
`MutableList<java.lang.Byte>`	`boxed()`
`MutableByteIterator`	`byteIterator()`	Returns a primitive iterator that can be used to iterate over the ByteIterable in an imperative style.
`private void`	`checkEmpty()`
`RichIterable<ByteIterable>`	`chunk(int size)`	Partitions elements in fixed size chunks.
`void`	`clear()`
`<V> MutableList<V>`	`collect(ByteToObjectFunction<? extends V> function)`	Returns a new collection with the results of applying the specified function on each element of the source collection.
`<V,R extends java.util.Collection<V>> R`	`collect(ByteToObjectFunction<? extends V> function, R target)`	Same as `ByteIterable.collect(ByteToObjectFunction)` , only the results are added to the target Collection.
`boolean`	`contains(byte value)`	Returns true if the value is contained in the ByteIterable, and false if it is not.
`private void`	`copyItems(int sourceSize, byte[] source)`
`private byte[]`	`copyItemsWithNewCapacity(int newCapacity)`
`int`	`count(BytePredicate predicate)`	Returns a count of the number of elements in the ByteIterable that return true for the specified predicate.
`byte`	`detectIfNone(BytePredicate predicate, byte ifNone)`
`MutableByteList`	`distinct()`
`long`	`dotProduct(ByteList list)`
`void`	`each(ByteProcedure procedure)`	A synonym for forEach.
`void`	`ensureCapacity(int minCapacity)`
`private void`	`ensureCapacityForAdd()`
`boolean`	`equals(java.lang.Object otherList)`	Follows the same general contract as `List.equals(Object)`.
`void`	`forEachWithIndex(ByteIntProcedure procedure)`
`byte`	`get(int index)`
`byte`	`getFirst()`
`byte`	`getLast()`
`int`	`hashCode()`	Follows the same general contract as `List.hashCode()`.
`int`	`indexOf(byte value)`
`<T> T`	`injectInto(T injectedValue, ObjectByteToObjectFunction<? super T,? extends T> function)`
`<T> T`	`injectIntoWithIndex(T injectedValue, ObjectByteIntToObjectFunction<? super T,? extends T> function)`
`int`	`lastIndexOf(byte value)`
`byte`	`max()`
`byte`	`min()`
`ByteArrayList`	`newEmpty()`	Creates a new empty ByteArrayList.
`private java.lang.IndexOutOfBoundsException`	`newIndexOutOfBoundsException(int index)`
`static ByteArrayList`	`newList(ByteIterable source)`
`static ByteArrayList`	`newListWith(byte... elements)`	Creates a new list using the passed `elements` argument as the backing store.
`static ByteArrayList`	`newWithNValues(int size, byte value)`
`void`	`readExternal(java.io.ObjectInput in)`
`ByteArrayList`	`reject(BytePredicate predicate)`	Returns a new ByteIterable with all of the elements in the ByteIterable that return false for the specified predicate.
`<R extends MutableByteCollection> R`	`reject(BytePredicate predicate, R target)`	Same as `ByteIterable.reject(BytePredicate)` , only the results are added to the target MutableByteCollection.
`boolean`	`remove(byte value)`
`boolean`	`removeAll(byte... source)`
`boolean`	`removeAll(ByteIterable source)`
`byte`	`removeAtIndex(int index)`
`boolean`	`removeIf(BytePredicate predicate)`
`boolean`	`retainAll(byte... source)`
`boolean`	`retainAll(ByteIterable source)`
`ByteArrayList`	`reverseThis()`
`ByteArrayList`	`select(BytePredicate predicate)`	Returns a new ByteIterable with all of the elements in the ByteIterable that return true for the specified predicate.
`<R extends MutableByteCollection> R`	`select(BytePredicate predicate, R target)`	Same as `ByteIterable.select(BytePredicate)` , only the results are added to the target MutableByteCollection.
`byte`	`set(int index, byte element)`
`private void`	`shiftElementsAtIndex(int index, int sourceSize)`
`int`	`size()`	Returns the number of items in this iterable.
`private int`	`sizePlusFiftyPercent(int oldSize)`
`ByteArrayList`	`sortThis()`	Sorts this list mutating its contents and returns the same mutable list (this).
`ByteArrayList`	`sortThis(ByteComparator comparator)`	Sorts the internal data structure of this list and returns the list itself as a convenience.
`MutableByteList`	`subList(int fromIndex, int toIndex)`
`long`	`sum()`
`void`	`swap(int index1, int index2)`
`private void`	`throwOutOfBounds(int index)`
`byte[]`	`toArray()`	Converts the ByteIterable to a primitive byte array.
`byte[]`	`toArray(byte[] target)`	Converts the ByteIterable to a primitive byte array.
`ImmutableByteList`	`toImmutable()`	Returns an immutable copy of this list.
`ByteArrayList`	`toReversed()`
`MutableByteStack`	`toStack()`	Converts the collection to a ByteStack.
`private void`	`transferItemsToNewArrayWithCapacity(int newCapacity)`
`void`	`trimToSize()`
`private void`	`wipeAndResetTheEnd(int newCurrentFilledIndex)`
`ByteArrayList`	`with(byte element)`
`ByteArrayList`	`with(byte element1, byte element2)`
`ByteArrayList`	`with(byte element1, byte element2, byte element3)`
`ByteArrayList`	`with(byte element1, byte element2, byte element3, byte... elements)`
`ByteArrayList`	`withAll(ByteIterable elements)`
`private ByteArrayList`	`withArrayCopy(byte[] elements, int begin, int length)`
`ByteArrayList`	`without(byte element)`
`ByteArrayList`	`withoutAll(ByteIterable elements)`
`static ByteArrayList`	`wrapCopy(byte... array)`	Creates a new list by first copying the array passed in.
`void`	`writeExternal(java.io.ObjectOutput out)`
`<T> MutableList<ByteObjectPair<T>>`	`zip(java.lang.Iterable<T> iterable)`	Returns a `MutableList` formed from this `MutableByteList` and a `ListIterable` by combining corresponding elements in pairs.
`MutableList<ByteBytePair>`	`zipByte(ByteIterable iterable)`	Returns a `MutableList` formed from this `MutableByteList` and another `ByteList` by combining corresponding elements in pairs.

Methods inherited from class org.eclipse.collections.impl.primitive.AbstractByteIterable
asLazy, average, maxIfEmpty, median, minIfEmpty, toBag, toList, toSet, toSortedArray, toSortedList, toString

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

Methods inherited from interface org.eclipse.collections.api.ByteIterable
asLazy, average, averageIfEmpty, collectBoolean, collectByte, collectChar, collectDouble, collectFloat, collectInt, collectLong, collectShort, containsAll, containsAll, containsAny, containsAny, containsNone, containsNone, flatCollect, forEach, injectIntoBoolean, injectIntoByte, injectIntoChar, injectIntoDouble, injectIntoFloat, injectIntoInt, injectIntoLong, injectIntoShort, maxIfEmpty, median, medianIfEmpty, minIfEmpty, noneSatisfy, reduce, reduceIfEmpty, summaryStatistics, toBag, toList, toSet, toSortedArray, toSortedList, toSortedList, toSortedListBy, toSortedListBy

Methods inherited from interface org.eclipse.collections.api.list.primitive.ByteList
forEachInBoth

Methods inherited from interface org.eclipse.collections.api.list.primitive.MutableByteList
collectWithIndex, rejectWithIndex, selectWithIndex, shuffleThis, shuffleThis, sortThisBy, sortThisBy, tap

Methods inherited from interface org.eclipse.collections.api.ordered.primitive.OrderedByteIterable
collectWithIndex, rejectWithIndex, selectWithIndex

Methods inherited from interface org.eclipse.collections.api.PrimitiveIterable
appendString, appendString, isEmpty, makeString, makeString, makeString, notEmpty, toString

- Field Detail
  - serialVersionUID
```
private static final long serialVersionUID
```
    See Also:
    
    Constant Field Values
  - DEFAULT_SIZED_EMPTY_ARRAY
```
private static final byte[] DEFAULT_SIZED_EMPTY_ARRAY
```
  - ZERO_SIZED_ARRAY
```
private static final byte[] ZERO_SIZED_ARRAY
```
  - MAXIMUM_ARRAY_SIZE
```
private static final int MAXIMUM_ARRAY_SIZE
```
    See Also:
    
    Constant Field Values
  - size
```
protected int size
```
  - items
```
protected transient byte[] items
```
- Constructor Detail
  - ByteArrayList
```
public ByteArrayList()
```
  - ByteArrayList
```
public ByteArrayList(int initialCapacity)
```
  - ByteArrayList
```
public ByteArrayList(byte... array)
```
- Method Detail
  - newListWith
```
public static ByteArrayList newListWith(byte... elements)
```
    Creates a new list using the passed elements argument as the backing store.
    !!! WARNING: This method uses the passed in array, so can be very unsafe if the original array is held onto anywhere else. !!!
  - newList
```
public static ByteArrayList newList(ByteIterable source)
```
  - newWithNValues
```
public static ByteArrayList newWithNValues(int size,
                                           byte value)
```
  - wrapCopy
```
public static ByteArrayList wrapCopy(byte... array)
```
    Creates a new list by first copying the array passed in.
  - size
```
public int size()
```
    Description copied from interface: PrimitiveIterable
    
    Returns the number of items in this iterable.
    
    Specified by:
    
    size in interface PrimitiveIterable
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface MutableByteCollection
  - contains
```
public boolean contains(byte value)
```
    Description copied from interface: ByteIterable
    
    Returns true if the value is contained in the ByteIterable, and false if it is not.
    
    Specified by:
    
    contains in interface ByteIterable
  - get
```
public byte get(int index)
```
    Specified by:
    
    get in interface ByteList
  - newIndexOutOfBoundsException
```
private java.lang.IndexOutOfBoundsException newIndexOutOfBoundsException(int index)
```
  - getFirst
```
public byte getFirst()
```
    Specified by:
    
    getFirst in interface OrderedByteIterable
  - getLast
```
public byte getLast()
```
    Specified by:
    
    getLast in interface ReversibleByteIterable
  - checkEmpty
```
private void checkEmpty()
```
  - indexOf
```
public int indexOf(byte value)
```
    Specified by:
    
    indexOf in interface OrderedByteIterable
  - lastIndexOf
```
public int lastIndexOf(byte value)
```
    Specified by:
    
    lastIndexOf in interface ByteList
  - trimToSize
```
public void trimToSize()
```
  - transferItemsToNewArrayWithCapacity
```
private void transferItemsToNewArrayWithCapacity(int newCapacity)
```
  - copyItemsWithNewCapacity
```
private byte[] copyItemsWithNewCapacity(int newCapacity)
```
  - sizePlusFiftyPercent
```
private int sizePlusFiftyPercent(int oldSize)
```
  - ensureCapacity
```
public void ensureCapacity(int minCapacity)
```
  - ensureCapacityForAdd
```
private void ensureCapacityForAdd()
```
  - add
```
public boolean add(byte newItem)
```
    Specified by:
    
    add in interface MutableByteCollection
  - addAll
```
public boolean addAll(byte... source)
```
    Specified by:
    
    addAll in interface MutableByteCollection
  - addAll
```
public boolean addAll(ByteIterable source)
```
    Specified by:
    
    addAll in interface MutableByteCollection
  - copyItems
```
private void copyItems(int sourceSize,
                       byte[] source)
```
  - throwOutOfBounds
```
private void throwOutOfBounds(int index)
```
  - addAtIndex
```
public void addAtIndex(int index,
                       byte element)
```
    Specified by:
    
    addAtIndex in interface MutableByteList
  - addAtIndexLessThanSize
```
private void addAtIndexLessThanSize(int index,
                                    byte element)
```
  - addAllAtIndex
```
public boolean addAllAtIndex(int index,
                             byte... source)
```
    Specified by:
    
    addAllAtIndex in interface MutableByteList
  - addAllAtIndex
```
public boolean addAllAtIndex(int index,
                             ByteIterable source)
```
    Specified by:
    
    addAllAtIndex in interface MutableByteList
  - shiftElementsAtIndex
```
private void shiftElementsAtIndex(int index,
                                  int sourceSize)
```
  - remove
```
public boolean remove(byte value)
```
    Specified by:
    
    remove in interface MutableByteCollection
  - removeIf
```
public boolean removeIf(BytePredicate predicate)
```
    Specified by:
    
    removeIf in interface MutableByteCollection
  - wipeAndResetTheEnd
```
private void wipeAndResetTheEnd(int newCurrentFilledIndex)
```
  - removeAll
```
public boolean removeAll(ByteIterable source)
```
    Specified by:
    
    removeAll in interface MutableByteCollection
  - removeAll
```
public boolean removeAll(byte... source)
```
    Specified by:
    
    removeAll in interface MutableByteCollection
  - retainAll
```
public boolean retainAll(ByteIterable source)
```
    Specified by:
    
    retainAll in interface MutableByteCollection
    
    See Also:
    
    Collection.retainAll(Collection)
  - retainAll
```
public boolean retainAll(byte... source)
```
    Specified by:
    
    retainAll in interface MutableByteCollection
    
    See Also:
    
    Collection.retainAll(Collection)
  - removeAtIndex
```
public byte removeAtIndex(int index)
```
    Specified by:
    
    removeAtIndex in interface MutableByteList
  - set
```
public byte set(int index,
                byte element)
```
    Specified by:
    
    set in interface MutableByteList
  - swap
```
public void swap(int index1,
                 int index2)
```
    Specified by:
    
    swap in interface MutableByteList
  - with
```
public ByteArrayList with(byte element)
```
    Specified by:
    
    with in interface MutableByteCollection
    
    Specified by:
    
    with in interface MutableByteList
  - without
```
public ByteArrayList without(byte element)
```
    Specified by:
    
    without in interface MutableByteCollection
    
    Specified by:
    
    without in interface MutableByteList
  - withAll
```
public ByteArrayList withAll(ByteIterable elements)
```
    Specified by:
    
    withAll in interface MutableByteCollection
    
    Specified by:
    
    withAll in interface MutableByteList
  - withoutAll
```
public ByteArrayList withoutAll(ByteIterable elements)
```
    Specified by:
    
    withoutAll in interface MutableByteCollection
    
    Specified by:
    
    withoutAll in interface MutableByteList
  - with
```
public ByteArrayList with(byte element1,
                          byte element2)
```
  - with
```
public ByteArrayList with(byte element1,
                          byte element2,
                          byte element3)
```
  - with
```
public ByteArrayList with(byte element1,
                          byte element2,
                          byte element3,
                          byte... elements)
```
  - withArrayCopy
```
private ByteArrayList withArrayCopy(byte[] elements,
                                    int begin,
                                    int length)
```
  - byteIterator
```
public MutableByteIterator byteIterator()
```
    Description copied from interface: ByteIterable
    
    Returns a primitive iterator that can be used to iterate over the ByteIterable in an imperative style.
    
    Specified by:
    
    byteIterator in interface ByteIterable
    
    Specified by:
    
    byteIterator in interface MutableByteCollection
  - each
```
public void each(ByteProcedure procedure)
```
    Description copied from interface: ByteIterable
    
    A synonym for forEach.
    
    Specified by:
    
    each in interface ByteIterable
    
    Since:
    
    7.0.
  - forEachWithIndex
```
public void forEachWithIndex(ByteIntProcedure procedure)
```
    Specified by:
    
    forEachWithIndex in interface OrderedByteIterable
  - injectInto
```
public <T> T injectInto(T injectedValue,
                        ObjectByteToObjectFunction<? super T,? extends T> function)
```
    Specified by:
    
    injectInto in interface ByteIterable
  - injectIntoWithIndex
```
public <T> T injectIntoWithIndex(T injectedValue,
                                 ObjectByteIntToObjectFunction<? super T,? extends T> function)
```
    Specified by:
    
    injectIntoWithIndex in interface OrderedByteIterable
    
    Specified by:
    
    injectIntoWithIndex in interface ReversibleByteIterable
  - chunk
```
public RichIterable<ByteIterable> chunk(int size)
```
    Description copied from interface: ByteIterable
    
    Partitions elements in fixed size chunks.
    
    Specified by:
    
    chunk in interface ByteIterable
    
    Parameters:
    
    size - the number of elements per chunk
    
    Returns:
    
    A RichIterable containing ByteIterables of size size, except the last will be truncated if the elements don't divide evenly.
  - count
```
public int count(BytePredicate predicate)
```
    Description copied from interface: ByteIterable
    
    Returns a count of the number of elements in the ByteIterable that return true for the specified predicate.
    
    Specified by:
    
    count in interface ByteIterable
  - anySatisfy
```
public boolean anySatisfy(BytePredicate predicate)
```
    Description copied from interface: ByteIterable
    
    Returns true if any of the elements in the ByteIterable return true for the specified predicate, otherwise returns false.
    
    Specified by:
    
    anySatisfy in interface ByteIterable
  - allSatisfy
```
public boolean allSatisfy(BytePredicate predicate)
```
    Description copied from interface: ByteIterable
    
    Returns true if all of the elements in the ByteIterable return true for the specified predicate, otherwise returns false.
    
    Specified by:
    
    allSatisfy in interface ByteIterable
  - select
```
public ByteArrayList select(BytePredicate predicate)
```
    Description copied from interface: ByteIterable
    
    Returns a new ByteIterable with all of the elements in the ByteIterable that return true for the specified predicate.
    
    Specified by:
    
    select in interface ByteIterable
    
    Specified by:
    
    select in interface ByteList
    
    Specified by:
    
    select in interface MutableByteCollection
    
    Specified by:
    
    select in interface MutableByteList
    
    Specified by:
    
    select in interface OrderedByteIterable
    
    Specified by:
    
    select in interface ReversibleByteIterable
  - select
```
public <R extends MutableByteCollection> R select(BytePredicate predicate,
                                                  R target)
```
    Description copied from interface: ByteIterable
    
    Same as ByteIterable.select(BytePredicate) , only the results are added to the target MutableByteCollection.
    
    Specified by:
    
    select in interface ByteIterable
    
    Since:
    
    8.1.
  - reject
```
public ByteArrayList reject(BytePredicate predicate)
```
    Description copied from interface: ByteIterable
    
    Returns a new ByteIterable with all of the elements in the ByteIterable that return false for the specified predicate.
    
    Specified by:
    
    reject in interface ByteIterable
    
    Specified by:
    
    reject in interface ByteList
    
    Specified by:
    
    reject in interface MutableByteCollection
    
    Specified by:
    
    reject in interface MutableByteList
    
    Specified by:
    
    reject in interface OrderedByteIterable
    
    Specified by:
    
    reject in interface ReversibleByteIterable
  - reject
```
public <R extends MutableByteCollection> R reject(BytePredicate predicate,
                                                  R target)
```
    Description copied from interface: ByteIterable
    
    Same as ByteIterable.reject(BytePredicate) , only the results are added to the target MutableByteCollection.
    
    Specified by:
    
    reject in interface ByteIterable
    
    Since:
    
    8.1.
  - detectIfNone
```
public byte detectIfNone(BytePredicate predicate,
                         byte ifNone)
```
    Specified by:
    
    detectIfNone in interface ByteIterable
  - collect
```
public <V> MutableList<V> collect(ByteToObjectFunction<? extends V> function)
```
    Description copied from interface: ByteIterable
    
    Returns a new collection with the results of applying the specified function on each element of the source collection. This method is also commonly called transform or map.
    
    Specified by:
    
    collect in interface ByteIterable
    
    Specified by:
    
    collect in interface ByteList
    
    Specified by:
    
    collect in interface MutableByteCollection
    
    Specified by:
    
    collect in interface MutableByteList
    
    Specified by:
    
    collect in interface OrderedByteIterable
    
    Specified by:
    
    collect in interface ReversibleByteIterable
  - collect
```
public <V,R extends java.util.Collection<V>> R collect(ByteToObjectFunction<? extends V> function,
                                                             R target)
```
    Description copied from interface: ByteIterable
    
    Same as ByteIterable.collect(ByteToObjectFunction) , only the results are added to the target Collection.
    
    Specified by:
    
    collect in interface ByteIterable
    
    Since:
    
    8.1.
  - max
```
public byte max()
```
    Specified by:
    
    max in interface ByteIterable
  - min
```
public byte min()
```
    Specified by:
    
    min in interface ByteIterable
  - sum
```
public long sum()
```
    Specified by:
    
    sum in interface ByteIterable
  - dotProduct
```
public long dotProduct(ByteList list)
```
    Specified by:
    
    dotProduct in interface ByteList
  - toArray
```
public byte[] toArray()
```
    Description copied from interface: ByteIterable
    
    Converts the ByteIterable to a primitive byte array.
    
    Specified by:
    
    toArray in interface ByteIterable
  - toArray
```
public byte[] toArray(byte[] target)
```
    Description copied from interface: ByteIterable
    
    Converts the ByteIterable to a primitive byte array. If the collection fits into the provided array it is used to store its elements and is returned from the method, otherwise a new array of the appropriate size is allocated and returned. If the iterable is empty, the target array is returned unchanged.
    
    Specified by:
    
    toArray in interface ByteIterable
  - equals
```
public boolean equals(java.lang.Object otherList)
```
    Description copied from interface: ByteList
    
    Follows the same general contract as List.equals(Object).
    
    Specified by:
    
    equals in interface ByteList
    
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Description copied from interface: ByteList
    
    Follows the same general contract as List.hashCode().
    
    Specified by:
    
    hashCode in interface ByteList
    
    Overrides:
    
    hashCode in class java.lang.Object
  - appendString
```
public void appendString(java.lang.Appendable appendable,
                         java.lang.String start,
                         java.lang.String separator,
                         java.lang.String end)
```
    Description copied from interface: PrimitiveIterable
    
    Prints a string representation of this collection onto the given Appendable. Prints the string returned by PrimitiveIterable.makeString(String, String, String).
    
    Specified by:
    
    appendString in interface PrimitiveIterable
  - asUnmodifiable
```
public MutableByteList asUnmodifiable()
```
    Specified by:
    
    asUnmodifiable in interface MutableByteCollection
    
    Specified by:
    
    asUnmodifiable in interface MutableByteList
  - asSynchronized
```
public MutableByteList asSynchronized()
```
    Specified by:
    
    asSynchronized in interface MutableByteCollection
    
    Specified by:
    
    asSynchronized in interface MutableByteList
  - toImmutable
```
public ImmutableByteList toImmutable()
```
    Description copied from interface: MutableByteList
    
    Returns an immutable copy of this list.
    
    Specified by:
    
    toImmutable in interface ByteList
    
    Specified by:
    
    toImmutable in interface MutableByteCollection
    
    Specified by:
    
    toImmutable in interface MutableByteList
  - 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
```
    Specified by:
    
    readExternal in interface java.io.Externalizable
    
    Throws:
    
    java.io.IOException
  - asReversed
```
public LazyByteIterable asReversed()
```
    Specified by:
    
    asReversed in interface ReversibleByteIterable
  - reverseThis
```
public ByteArrayList reverseThis()
```
    Specified by:
    
    reverseThis in interface MutableByteList
  - sortThis
```
public ByteArrayList sortThis()
```
    Description copied from interface: MutableByteList
    
    Sorts this list mutating its contents and returns the same mutable list (this).
    
    Specified by:
    
    sortThis in interface MutableByteList
  - sortThis
```
public ByteArrayList sortThis(ByteComparator comparator)
```
    Description copied from interface: MutableByteList
    
    Sorts the internal data structure of this list and returns the list itself as a convenience.
    
    Specified by:
    
    sortThis in interface MutableByteList
  - toReversed
```
public ByteArrayList toReversed()
```
    Specified by:
    
    toReversed in interface ByteList
    
    Specified by:
    
    toReversed in interface MutableByteList
    
    Specified by:
    
    toReversed in interface ReversibleByteIterable
  - binarySearch
```
public int binarySearch(byte value)
```
    Specified by:
    
    binarySearch in interface ByteList
  - distinct
```
public MutableByteList distinct()
```
    Specified by:
    
    distinct in interface ByteList
    
    Specified by:
    
    distinct in interface MutableByteList
    
    Specified by:
    
    distinct in interface ReversibleByteIterable
  - subList
```
public MutableByteList subList(int fromIndex,
                               int toIndex)
```
    Specified by:
    
    subList in interface ByteList
    
    Specified by:
    
    subList in interface MutableByteList
    
    See Also:
    
    List.subList(int fromIndex, int toIndex)
  - zipByte
```
public MutableList<ByteBytePair> zipByte(ByteIterable iterable)
```
    Description copied from interface: MutableByteList
    
    Returns a MutableList formed from this MutableByteList and another ByteList by combining corresponding elements in pairs. If one of the two ByteLists is longer than the other, its remaining elements are ignored.
    
    Specified by:
    
    zipByte in interface ByteList
    
    Specified by:
    
    zipByte in interface MutableByteList
    
    Since:
    
    9.1.
  - newEmpty
```
public ByteArrayList newEmpty()
```
    Creates a new empty ByteArrayList.
    
    Specified by:
    
    newEmpty in interface MutableByteCollection
    
    Specified by:
    
    newEmpty in interface MutableByteList
    
    Since:
    
    9.2.
  - zip
```
public <T> MutableList<ByteObjectPair<T>> zip(java.lang.Iterable<T> iterable)
```
    Description copied from interface: MutableByteList
    
    Returns a MutableList formed from this MutableByteList and a ListIterable by combining corresponding elements in pairs. If one of the two Lists is longer than the other, its remaining elements are ignored.
    
    Specified by:
    
    zip in interface ByteList
    
    Specified by:
    
    zip in interface MutableByteList
    
    Since:
    
    9.1.
  - boxed
```
public MutableList<java.lang.Byte> boxed()
```
    Specified by:
    
    boxed in interface MutableByteList
  - toStack
```
public MutableByteStack toStack()
```
    Description copied from interface: OrderedByteIterable
    
    Converts the collection to a ByteStack.
    
    Specified by:
    
    toStack in interface OrderedByteIterable

Constructor	Description
`ByteArrayList()`
`ByteArrayList(byte... array)`
`ByteArrayList(int initialCapacity)`

Class ByteArrayList

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.eclipse.collections.impl.primitive.AbstractByteIterable

Methods inherited from class java.lang.Object

Methods inherited from interface org.eclipse.collections.api.ByteIterable

Methods inherited from interface org.eclipse.collections.api.list.primitive.ByteList

Methods inherited from interface org.eclipse.collections.api.list.primitive.MutableByteList

Methods inherited from interface org.eclipse.collections.api.ordered.primitive.OrderedByteIterable

Methods inherited from interface org.eclipse.collections.api.PrimitiveIterable

Field Detail

serialVersionUID

DEFAULT_SIZED_EMPTY_ARRAY

ZERO_SIZED_ARRAY

MAXIMUM_ARRAY_SIZE

size

items

Constructor Detail

ByteArrayList

ByteArrayList

ByteArrayList

Method Detail

newListWith

newList

newWithNValues

wrapCopy

size

clear

contains

get

newIndexOutOfBoundsException

getFirst

getLast

checkEmpty

indexOf

lastIndexOf

trimToSize

transferItemsToNewArrayWithCapacity

copyItemsWithNewCapacity

sizePlusFiftyPercent

ensureCapacity

ensureCapacityForAdd

add

addAll

addAll

copyItems

throwOutOfBounds

addAtIndex

addAtIndexLessThanSize

addAllAtIndex

addAllAtIndex

shiftElementsAtIndex

remove

removeIf

wipeAndResetTheEnd

removeAll

removeAll

retainAll

retainAll

removeAtIndex

set

swap

with

without

withAll

withoutAll

with

with

with

withArrayCopy

byteIterator

each

forEachWithIndex

injectInto

injectIntoWithIndex

chunk

count

anySatisfy