Package org.agrona.collections

Class IntArrayList

java.lang.Object
java.util.AbstractCollection<E>
java.util.AbstractList<Integer>
org.agrona.collections.IntArrayList
All Implemented Interfaces:
Iterable<Integer>, Collection<Integer>, List<Integer>, RandomAccess
public class IntArrayList extends AbstractList<Integer> implements List<Integer>, RandomAccess
A List implementation that stores int values with the ability to not have them boxed.

  • Field Details

    • DEFAULT_NULL_VALUE

      public static final int DEFAULT_NULL_VALUE
      The default value that will be used in place of null for an element.
      See Also:

    • INITIAL_CAPACITY

      public static final int INITIAL_CAPACITY
      Initial capacity to which the array will be sized.
      See Also:

  • Constructor Details

    • IntArrayList

      public IntArrayList()
      Constructs a new list with the INITIAL_CAPACITY using DEFAULT_NULL_VALUE.

    • IntArrayList

      public IntArrayList(int initialCapacity, int nullValue)
      Construct a new list.
      Parameters:
      initialCapacity - for the backing array.
      nullValue - to be used to represent a null element.

    • IntArrayList

      public IntArrayList(int[] initialElements, int initialSize, int nullValue)
      Create a new list that wraps an existing arrays without copying it.
      Parameters:
      initialElements - to be wrapped.
      initialSize - of the array to wrap.
      nullValue - to be used to represent a null element.

  • Method Details

    • wrap

      public void wrap(int[] initialElements, int initialSize)
      Wrap an existing array without copying it.
      Parameters:
      initialElements - to be wrapped.
      initialSize - of the array to wrap.
      Throws:
      IllegalArgumentException - if the initialSize is less than 0 or greater than the length of the initial array.

    • nullValue

      public int nullValue()
      The value representing a null element.
      Returns:
      value representing a null element.

    • size

      public int size()
      Specified by:
      size in interface Collection<Integer>
      Specified by:
      size in interface List<Integer>
      Specified by:
      size in class AbstractCollection<Integer>

    • capacity

      public int capacity()
      The current capacity for the collection.
      Returns:
      the current capacity for the collection.

    • clear

      public void clear()
      Specified by:
      clear in interface Collection<Integer>
      Specified by:
      clear in interface List<Integer>
      Overrides:
      clear in class AbstractList<Integer>

    • trimToSize

      public void trimToSize()
      Trim the underlying array to be the current size, or INITIAL_CAPACITY if size is less.

    • get

      public Integer get(int index)
      Specified by:
      get in interface List<Integer>
      Specified by:
      get in class AbstractList<Integer>

    • getInt

      public int getInt(int index)
      Get the element at a given index without boxing.
      Parameters:
      index - to get.
      Returns:
      the unboxed element.

    • add

      public boolean add(Integer element)
      Specified by:
      add in interface Collection<Integer>
      Specified by:
      add in interface List<Integer>
      Overrides:
      add in class AbstractList<Integer>

    • addInt

      public boolean addInt(int element)
      Add an element without boxing.
      Parameters:
      element - to be added.
      Returns:
      true

    • add

      public void add(int index, Integer element)
      Specified by:
      add in interface List<Integer>
      Overrides:
      add in class AbstractList<Integer>

    • addInt

      public void addInt(int index, int element)
      Add an element without boxing at a given index.
      Parameters:
      index - at which the element should be added.
      element - to be added.

    • set

      public Integer set(int index, Integer element)
      Specified by:
      set in interface List<Integer>
      Overrides:
      set in class AbstractList<Integer>

    • setInt

      public int setInt(int index, int element)
      Set an element at a given index without boxing.
      Parameters:
      index - at which to set the element.
      element - to be added.
      Returns:
      the previous element at the index.

    • contains

      public boolean contains(Object o)
      Specified by:
      contains in interface Collection<Integer>
      Specified by:
      contains in interface List<Integer>
      Overrides:
      contains in class AbstractCollection<Integer>

    • containsInt

      public boolean containsInt(int value)
      Does the list contain this element value.
      Parameters:
      value - of the element.
      Returns:
      true if present otherwise false.

    • indexOf

      public int indexOf(int value)
      Index of the first element with this value.
      Parameters:
      value - for the element.
      Returns:
      the index if found otherwise -1.

    • lastIndexOf

      public int lastIndexOf(int value)
      Index of the last element with this value.
      Parameters:
      value - for the element.
      Returns:
      the index if found otherwise -1.

    • addAll

      public boolean addAll(IntArrayList list)
      Appends all the elements in the specified list to the end of this list, in the order that they are stored in the specified list.
      Parameters:
      list - containing elements to be added to this list.
      Returns:
      true if this list changed as a result of the call.

    • addAll

      public boolean addAll(int index, IntArrayList list)
      Inserts all the elements from the specified list to this list at the specified position. Shifts the element currently at that position (if any) and any subsequent elements to the right (increases their indices). The new elements will appear in this list in the order that they are stored in the specified list.
      Parameters:
      index - at which to insert the first element from the specified collection.
      list - containing elements to be added to this list.
      Returns:
      true if this list changed as a result of the call.

    • containsAll

      public boolean containsAll(IntArrayList list)
      Returns true if this list contains all the elements of the specified list.
      Parameters:
      list - to be checked for containment in this list.
      Returns:
      true if this list contains all the elements of the specified list.

    • retainAll

      public boolean retainAll(IntArrayList list)
      Retains only the elements in this list that are contained in the specified list. In other words, removes from this list all of its elements that are not contained in the specified list.
      Parameters:
      list - containing elements to be removed from this list.
      Returns:
      true if this list changed as a result of the call.

    • removeAll

      public boolean removeAll(IntArrayList list)
      Removes all of this collection's elements that are also contained in the specified list. After this call returns, this list will contain no elements in common with the specified list.
      Parameters:
      list - whose elements are to be removed from this list.
      Returns:
      true if this list changed as a result of the call.

    • removeIfInt

      public boolean removeIfInt(IntPredicate filter)
      Removes all the elements of this collection that satisfy the given predicate.
      Parameters:
      filter - a predicate which returns true for elements to be removed.
      Returns:
      true if any elements were removed.

    • remove

      public boolean remove(Object o)
      Specified by:
      remove in interface Collection<Integer>
      Specified by:
      remove in interface List<Integer>
      Overrides:
      remove in class AbstractCollection<Integer>

    • remove

      public Integer remove(int index)
      Remove at a given index.
      Specified by:
      remove in interface List<Integer>
      Overrides:
      remove in class AbstractList<Integer>
      Parameters:
      index - of the element to be removed.
      Returns:
      the existing value at this index.

    • removeAt

      public int removeAt(int index)
      Remove at a given index.
      Parameters:
      index - of the element to be removed.
      Returns:
      the existing value at this index.

    • fastUnorderedRemove

      public int fastUnorderedRemove(int index)
      Removes element at index, but instead of copying all elements to the left, it replaces the item in the slot with the last item in the list. This avoids the copy costs at the expense of preserving list order. If index is the last element it is just removed.
      Parameters:
      index - of the element to be removed.
      Returns:
      the existing value at this index.
      Throws:
      IndexOutOfBoundsException - if index is out of bounds.

    • removeInt

      public boolean removeInt(int value)
      Remove the first instance of a value if found in the list.

      Primitive specialization of the List.remove(Object) method.

      Parameters:
      value - to be removed.
      Returns:
      true if successful otherwise false.

    • fastUnorderedRemoveInt

      public boolean fastUnorderedRemoveInt(int value)
      Remove the first instance of a value if found in the list and replaces it with the last item in the list. This saves a copy down of all items at the expense of not preserving list order.
      Parameters:
      value - to be removed.
      Returns:
      true if successful otherwise false.

    • pushInt

      public void pushInt(int element)
      Push an element onto the end of the array like a stack.
      Parameters:
      element - to be pushed onto the end of the array.

    • popInt

      public int popInt()
      Pop a value off the end of the array as a stack operation.
      Returns:
      the value at the end of the array.
      Throws:
      NoSuchElementException - if the array is empty.

    • forEachOrderedInt

      public void forEachOrderedInt(IntConsumer action)
      For each element in order provide the int value to a IntConsumer.
      Parameters:
      action - to be taken for each element.

    • intStream

      public IntStream intStream()
      Create a IntStream over the elements of underlying array.
      Returns:
      a IntStream over the elements of underlying array.

    • toIntArray

      public int[] toIntArray()
      Create a new array that is a copy of the elements.
      Returns:
      a copy of the elements.

    • toIntArray

      public int[] toIntArray(int[] dst)
      Create a new array that is a copy of the elements.
      Parameters:
      dst - destination array for the copy if it is the correct size.
      Returns:
      a copy of the elements.

    • ensureCapacity

      public void ensureCapacity(int requiredCapacity)
      Ensure the backing array has a required capacity.
      Parameters:
      requiredCapacity - for the backing array.

    • equals

      public boolean equals(IntArrayList that)
      Type-safe overload of the equals(Object) method.
      Parameters:
      that - other list.
      Returns:
      true if lists are equal.

    • equals

      public boolean equals(Object other)
      Specified by:
      equals in interface Collection<Integer>
      Specified by:
      equals in interface List<Integer>
      Overrides:
      equals in class AbstractList<Integer>

    • hashCode

      public int hashCode()
      Specified by:
      hashCode in interface Collection<Integer>
      Specified by:
      hashCode in interface List<Integer>
      Overrides:
      hashCode in class AbstractList<Integer>

    • forEach

      public void forEach(Consumer<? super Integer> action)
      Specified by:
      forEach in interface Iterable<Integer>

    • forEachInt

      public void forEachInt(IntConsumer action)
      Iterate over the collection without boxing.
      Parameters:
      action - to be taken for each element.

    • toString

      public String toString()
      Overrides:
      toString in class AbstractCollection<Integer>