Package com.github.tommyettinger.ds

Class IntDeque

java.lang.Object
com.github.tommyettinger.ds.IntList
com.github.tommyettinger.ds.IntDeque
All Implemented Interfaces:
Arrangeable, Ordered.OfInt, PrimitiveCollection<Integer>, PrimitiveCollection.OfInt, RandomAccess
public class IntDeque extends IntList implements RandomAccess, Arrangeable, PrimitiveCollection.OfInt, Ordered.OfInt
A resizable, insertion-ordered double-ended queue of primitive int with efficient add and remove at the beginning and end. This extends IntList and supports RandomAccess. Like IntList, it is a PrimitiveCollection.OfInt, Arrangeable, and Ordered.OfInt. Values in the backing array may wrap back to the beginning, making add and remove at the beginning and end O(1) (unless the backing array needs to resize when adding). Deque functionality is provided via removeLast() and addFirst(int).
Unlike most Deque implementations in the JDK, you can get and set items anywhere in the deque in constant time with get(int) and set(int, int). Relative to a IntList, get(int) has slightly higher overhead, but it still runs in constant time. Unlike ArrayDeque in the JDK, this implements equals(Object) and hashCode(). This can provide what are effectively ListIterators for iteration from an index or in reverse order.
Unlike ArrayDeque or ArrayList, most methods that take an index here try to be "forgiving;" that is, they treat negative indices as index 0, and too-large indices as the last index, rather than throwing an Exception, except in some cases where the IntDeque is empty and an item from it is required. An exception is in set(int, int), which allows prepending by setting a negative index, or appending by setting a too-large index. This isn't a standard JDK behavior, and it doesn't always act how Deque or List is documented.
Some new methods are present here, or have been made public when they weren't before. removeRange(int, int), for instance, is now public, as is resize(int). New APIs include Deque-like methods that affect the middle of the deque, such as peekAt(int) and pollAt(int). There are more bulk methods that work at the head or tail region of the deque, such as addAllFirst(OfInt) and truncateFirst(int). There are the methods from Arrangeable, and many default methods from PrimitiveCollection and Ordered.
In general, this is an improvement over ArrayDeque in every type of functionality, and is mostly equivalent to IntList as long as the performance of get(int) is adequate. Because it is array-backed, it should usually be much faster than LinkedList, as well; only periodic resizing and modifications in the middle of the List using an iterator should be typically faster for LinkedList.

  • Nested Class Summary

    Nested Classes
    Modifier and Type
    Class
    Description
    static class 
    IntDeque.IntDequeIterator
    A IntIterator over the elements of an IntDeque.

    Nested classes/interfaces inherited from class com.github.tommyettinger.ds.IntList

    IntList.IntListIterator

    Nested classes/interfaces inherited from interface com.github.tommyettinger.ds.Arrangeable

    Arrangeable.ArrangeableList<T>

    Nested classes/interfaces inherited from interface com.github.tommyettinger.ds.PrimitiveCollection

    PrimitiveCollection.OfBoolean, PrimitiveCollection.OfByte, PrimitiveCollection.OfChar, PrimitiveCollection.OfDouble, PrimitiveCollection.OfFloat, PrimitiveCollection.OfInt, PrimitiveCollection.OfLong, PrimitiveCollection.OfShort

  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    int
    defaultValue
    The value returned when nothing can be obtained from this deque and an exception is not meant to be thrown, such as when calling peek() on an empty deque.
    protected IntDeque.IntDequeIterator
    descendingIterator1
     
    protected IntDeque.IntDequeIterator
    descendingIterator2
     
    protected int
    head
    Index of first element.
    protected int
    tail
    Index of last element.

    Fields inherited from class com.github.tommyettinger.ds.IntList

    items, iterator1, iterator2, size

  • Constructor Summary

    Constructors
    Constructor
    Description
    IntDeque()
    Creates a new IntDeque which can hold 16 values without needing to resize the backing array.
    IntDeque(int initialSize)
    Creates a new IntDeque which can hold the specified number of values without needing to resize the backing array.
    IntDeque(int[] a)
    Creates a new IntDeque using all the contents of the given array.
    IntDeque(int[] a, int offset, int count)
    Creates a new IntDeque using count items from a, starting at offset.
    IntDeque(IntDeque deque)
    Copies the given IntDeque exactly into this one.
    IntDeque(Ordered.OfInt other)
     
    IntDeque(Ordered.OfInt other, int offset, int count)
     
    IntDeque(PrimitiveCollection.OfInt coll)
    Creates a new IntDeque using all the contents of the given Collection.
    IntDeque(IntIterator iter)
    Creates a new instance containing the items in the specified iterator.

  • Method Summary

    Modifier and Type
    Method
    Description
    boolean
    add(int t)
    Inserts the specified element into the deque represented by this deque (in other words, at the tail of this deque) if it is possible to do so immediately without violating capacity restrictions, returning true upon success and throwing an IllegalStateException if no space is currently available.
    void
    add(int value1, int value2)
     
    void
    add(int value1, int value2, int value3)
     
    void
    add(int value1, int value2, int value3, int value4)
     
    boolean
    addAll(int[] array)
    Exactly like addAll(OfInt), but takes an array instead of a PrimitiveCollection.OfInt.
    boolean
    addAll(int[] array, int offset, int length)
    Like addAll(int[]), but only uses at most length items from array, starting at offset.
    boolean
    addAll(int index, int[] array)
    Like addAll(int, OfInt), but takes an array instead of a PrimitiveCollection.OfInt and inserts it so the first item will be at the given index.
    boolean
    addAll(int index, int[] array, int offset, int length)
    Like addAll(int, OfInt), but takes an array instead of a PrimitiveCollection.OfInt, gets items starting at offset from that array, using length items, and inserts them so the item at the given offset will be at the given index.
    boolean
    addAll(int index, Ordered.OfInt ord)
    Like addAll(int, OfInt), but takes an ord instead of a PrimitiveCollection.OfInt and inserts it so the first item will be at the given index.
    boolean
    addAll(int index, Ordered.OfInt ord, int offset, int length)
    Like addAll(int, OfInt), but takes an array instead of a PrimitiveCollection.OfInt, gets items starting at offset from that array, using length items, and inserts them so the item at the given offset will be at the given index.
    boolean
    addAll(int index, PrimitiveCollection.OfInt c)
     
    boolean
    addAll(IntList list)
     
    boolean
    addAll(IntList list, int offset, int count)
     
    boolean
    addAll(Ordered.OfInt ord)
    Exactly like addAll(OfInt), but takes an Ordered.OfInt instead of a PrimitiveCollection.OfInt.
    boolean
    addAll(Ordered.OfInt ord, int offset, int length)
    Like addAll(int[]), but only uses at most length items from ord, starting at offset.
    boolean
    addAll(PrimitiveCollection.OfInt c)
    Adds all the elements in the specified collection at the end of this deque, as if by calling addLast(int) on each one, in the order that they are returned by the collection's iterator.
    boolean
    addAllFirst(int[] array)
    Exactly like addAllFirst(OfInt), but takes an array instead of a PrimitiveCollection.OfInt.
    boolean
    addAllFirst(int[] array, int offset, int length)
    Like addAllFirst(int[]), but only uses at most length items from array, starting at offset.
    boolean
    addAllFirst(Ordered.OfInt ord)
    Exactly like addAllFirst(OfInt), but takes an ord instead of a PrimitiveCollection.OfInt.
    boolean
    addAllFirst(Ordered.OfInt ord, int offset, int length)
    Like addAllFirst(Ordered.OfInt), but only uses at most length items from ord, starting at offset.
    boolean
    addAllFirst(PrimitiveCollection.OfInt c)
    Adds every item in c to this in order at the start.
    boolean
    addAllLast(int[] array)
    An alias for addAll(int[]).
    boolean
    addAllLast(int[] array, int offset, int length)
    An alias for addAll(int[], int, int).
    boolean
    addAllLast(Ordered.OfInt ord)
    An alias for addAll(Ordered.OfInt).
    boolean
    addAllLast(Ordered.OfInt ord, int offset, int length)
    An alias for addAll(Ordered.OfInt, int, int).
    boolean
    addAllLast(PrimitiveCollection.OfInt c)
    An alias for addAll(OfInt), this adds every item in c to this in order at the end.
    void
    addFirst(int value)
    Prepend given value to the head (enqueue to head).
    void
    addFirst(int value1, int value2)
     
    void
    addFirst(int value1, int value2, int value3)
     
    void
    addFirst(int value1, int value2, int value3, int value4)
     
    void
    addLast(int value)
    Appends given int to the tail (enqueue to tail).
    void
    addLast(int value1, int value2)
     
    void
    addLast(int value1, int value2, int value3)
     
    void
    addLast(int value1, int value2, int value3, int value4)
     
    int
    assign(int index, int item)
    Replaces the element at the specified position in this list with the specified element.
    void
    clear()
    Removes all values from this deque.
    boolean
    contains(int o)
    Returns true if this deque contains the specified element.
    boolean
    containsAll(IntList other)
    Returns true if this IntList contains, at least once, every item in other; otherwise returns false.
    IntList.IntListIterator
    descendingIterator()
    Returns an iterator over the elements in this deque in reverse sequential order.
    IntList.IntListIterator
    descendingIterator(int index)
    Returns an iterator over the elements in this deque in reverse sequential order.
    IntList
    div(int value)
    Divides each item in this IntList by value, stores it in this and returns it.
    void
    div(int index, int value)
     
    boolean
    duplicateRange(int index, int count)
    Inserts the specified number of items at the specified index.
    int
    element()
    Retrieves, but does not remove, the head of the queue represented by this deque (in other words, the first element of this deque).
    int[]
    ensureCapacity(int additional)
    Increases the size of the backing array to accommodate the specified number of additional items.
    protected int
    ensureGap(int index, int gapSize)
    Make sure there is a "gap" of exactly gapSize values starting at index.
    boolean
    equals(Object o)
    Using == between each item in order, compares for equality with other subtypes of IntList.
    int
    first()
    Returns the first (head) item in the deque (without removing it).
    int
    get(int index)
    Returns the element at the specified position in this deque.
    int
    getDefaultValue()
    Gets the default value, which is the value returned when nothing can be obtained from this deque and an exception is not meant to be thrown, such as when calling peek() on an empty deque.
    int
    getFirst()
    Retrieves, but does not remove, the first element of this deque.
    int
    getLast()
    Retrieves, but does not remove, the last element of this deque.
    int
    getRandom(Random random)
    Gets a randomly selected item from this IntDeque, using the given random number generator.
    int
    hashCode()
     
    int
    indexOf(int value)
    Returns the index of the first occurrence of value in the deque, or -1 if no such value exists.
    int
    indexOf(int value, int fromIndex)
    Returns the index of the first occurrence of value in the deque, or -1 if no such value exists.
    void
    insert(int index, int item)
    Inserts the specified element into this deque at the specified index.
    boolean
    insertAll(int index, int[] array)
    Alias for addAll(int, int[]).
    boolean
    insertAll(int index, int[] array, int offset, int length)
    Alias for addAll(int, int[], int, int).
    boolean
    insertAll(int index, Ordered.OfInt ord)
    Alias for addAll(int, Ordered.OfInt).
    boolean
    insertAll(int index, Ordered.OfInt ord, int offset, int length)
    Alias for addAll(int, Ordered.OfInt, int, int).
    boolean
    insertAll(int index, PrimitiveCollection.OfInt c)
    An alias for addAll(int, OfInt); inserts all elements in the specified collection into this list at the specified position.
    boolean
    isEmpty()
    Returns true if the deque is empty.
    IntList.IntListIterator
    iterator()
    Returns an iterator for the items in the deque.
    int
    last()
    Returns the last (tail) item in the deque (without removing it).
    int
    lastIndexOf(int value)
    Returns the index of the last occurrence of value in the deque, or -1 if no such value exists.
    int
    lastIndexOf(int value, int fromIndex)
    Returns the index of last occurrence of value in the deque, starting from fromIndex and going backwards, or -1 if no such value exists.
    IntList.IntListIterator
    listIterator()
     
    IntList.IntListIterator
    listIterator(int index)
    Gets an iterator over this deque that starts at the given index.
    IntList
    minus(int value)
    Takes each item in this IntList and subtracts value, stores it in this and returns it.
    void
    minus(int index, int value)
     
    boolean
    notEmpty()
    Returns true if the deque has one or more items.
    boolean
    offer(int t)
    Inserts the specified element into the queue represented by this deque (in other words, at the tail of this deque) if it is possible to do so immediately without violating capacity restrictions, returning true upon success and false if no space is currently available.
    boolean
    offerFirst(int t)
    Inserts the specified element at the front of this deque unless it would violate capacity restrictions.
    boolean
    offerLast(int t)
    Inserts the specified element at the end of this deque unless it would violate capacity restrictions.
    IntDeque
    order()
    Returns this IntList, since it is its own order.
    static IntDeque
    parse(String str, String delimiter)
    Calls parse(String, String, boolean) with brackets set to false.
    static IntDeque
    parse(String str, String delimiter, boolean brackets)
    Creates a new collection and fills it by calling PrimitiveCollection.OfInt.addLegible(String, String, int, int) on either all of str (if brackets is false) or str without its first and last chars (if brackets is true).
    static IntDeque
    parse(String str, String delimiter, int offset, int length)
    Creates a new collection and fills it by calling PrimitiveCollection.OfInt.addLegible(String, String, int, int) with the given four parameters as-is.
    int
    peek()
    Retrieves, but does not remove, the head of the queue represented by this deque (in other words, the first element of this deque), or returns defaultValue if this deque is empty.
    int
    peekAt(int index)
    Returns the element at the specified position in this deque.
    int
    peekFirst()
    Retrieves, but does not remove, the first element of this deque, or returns defaultValue if this deque is empty.
    int
    peekLast()
    Retrieves, but does not remove, the last element of this deque, or returns defaultValue if this deque is empty.
    IntList
    plus(int value)
    Adds value to each item in this IntList, stores it in this and returns it.
    void
    plus(int index, int value)
     
    int
    poll()
    Retrieves and removes the head of the queue represented by this deque (in other words, the first element of this deque), or returns defaultValue if this deque is empty.
    int
    poll(int index)
    Removes the element at the specified position in this deque.
    int
    pollAt(int index)
    Removes the element at the specified position in this deque.
    int
    pollFirst()
    Retrieves and removes the first element of this deque, or returns defaultValue if this deque is empty.
    int
    pollLast()
    Retrieves and removes the last element of this deque, or returns defaultValue if this deque is empty.
    int
    pop()
    Pops an element from the stack represented by this deque.
    void
    push(int t)
    Pushes an element onto the stack represented by this deque (in other words, at the head of this deque).
    int
    random(Random random)
    Gets a randomly selected item from this IntDeque, using the given random number generator.
    IntList
    rem(int value)
    Gets the remainder of each item in this IntList with value, stores it in this and returns it.
    void
    rem(int index, int value)
     
    int
    remove()
    Retrieves and removes the head of the queue represented by this deque (in other words, the first element of this deque).
    boolean
    remove(int o)
    Removes the first occurrence of the specified element from this deque.
    boolean
    removeAll(PrimitiveCollection.OfInt c)
    Removes from this IntList all occurrences of any elements contained in the specified collection.
    int
    removeAt(int index)
    Removes the element at the specified position in this deque.
    boolean
    removeEach(PrimitiveCollection.OfInt c)
    Removes from this IntList element-wise occurrences of elements contained in the specified collection.
    int
    removeFirst()
    Remove the first item from the deque.
    boolean
    removeFirstOccurrence(int o)
    Removes the first occurrence of the specified element from this deque.
    int
    removeLast()
    Remove the last item from the deque.
    boolean
    removeLastOccurrence(int o)
    Removes the last occurrence of the specified element from this deque.
    boolean
    removeLastValue(int value)
    Removes the last instance of the specified value in the deque.
    void
    removeRange(int fromIndex, int toIndex)
    Removes from this list all the elements whose index is between fromIndex, inclusive, and toIndex, exclusive.
    boolean
    removeValue(int value)
    Removes the first instance of the specified value in the deque.
    int
    replaceAll(int find, int replace)
    Replaces every occurrence of find with replace.
    void
    replaceAll(com.github.tommyettinger.function.IntToIntFunction operator)
    Replaces each element of this list with the result of applying the given operator to that element.
    boolean
    replaceFirst(int find, int replace)
    Replaces the first occurrence of find with replace.
    int[]
    resize(int newSize)
    Resizes the backing array.
    boolean
    retainAll(PrimitiveCollection.OfInt other)
    Removes all items from this IntList that are not present somewhere in other, any number of times.
    void
    reverse()
    Reverses this IntDeque in-place.
    void
    set(int index, int item)
    Replaces the element at the specified position in this list with the specified element.
    void
    setDefaultValue(int defaultValue)
    Sets the default value, which is the value returned when nothing can be obtained from this deque and an exception is not meant to be thrown, such as when calling peek() on an empty deque.
    int[]
    setSize(int newSize)
    Sets the list size, leaving any values beyond the current size undefined.
    int[]
    shrink()
    Reduces the size of the backing array to the size of the actual items.
    void
    shuffle(Random rng)
    Pseudo-randomly shuffles the order of this Ordered in-place.
    int
    size()
    Returns the number of elements in this deque.
    void
    sort()
    Sorts this deque in-place using Arrays.sort(int[], int, int) in ascending order.
    void
    sort(int from, int to)
    Uses Arrays.sort(int[], int, int) to sort a (clamped) subrange of this deque.
    void
    sort(int from, int to, IntComparator comparator)
    Sorts the specified range of elements according to the order induced by the specified comparator using mergesort, or Arrays.sort(int[], int, int) if c is null.
    void
    sort(IntComparator comparator)
    Sorts this deque in-place using IntComparators.sort(int[], int, int, IntComparator).
    void
    swap(int first, int second)
    Switches the ordering of positions first and second, without changing any items beyond that.
    IntList
    times(int value)
    Multiplies each item in this IntList by value, stores it in this and returns it.
    void
    times(int index, int value)
     
    int[]
    toArray()
    Returns an array containing all the elements in this collection.
    int[]
    toArray(int[] array)
    If array.length at least equal to IntList.size(), this copies the contents of this into array and returns it; otherwise, it allocates a new int array that can fit all the items in this, and proceeds to copy into that and return that.
    String
    toString()
    Delegates to PrimitiveCollection.OfInt.toString(String, boolean) with a delimiter of ", " and square brackets enabled.
    void
    trimToSize()
    Trims the capacity of this IntDeque instance to be the deque's current size.
    void
    truncate(int newSize)
    Reduces the size of the deque to the specified size by bulk-removing items from the tail end.
    void
    truncateFirst(int newSize)
    Reduces the size of the deque to the specified size by bulk-removing from the head.
    void
    truncateLast(int newSize)
    Alias for truncate(int).
    static IntDeque
    with()
    Constructs an empty deque.
    static IntDeque
    with(int item)
    Creates a new IntDeque that holds only the given item, but can be resized.
    static IntDeque
    with(int... varargs)
    Creates a new IntDeque that will hold the items in the given array or varargs.
    static IntDeque
    with(int item0, int item1)
    Creates a new IntDeque that holds only the given items, but can be resized.
    static IntDeque
    with(int item0, int item1, int item2)
    Creates a new IntDeque that holds only the given items, but can be resized.
    static IntDeque
    with(int item0, int item1, int item2, int item3)
    Creates a new IntDeque that holds only the given items, but can be resized.
    static IntDeque
    with(int item0, int item1, int item2, int item3, int item4)
    Creates a new IntDeque that holds only the given items, but can be resized.
    static IntDeque
    with(int item0, int item1, int item2, int item3, int item4, int item5)
    Creates a new IntDeque that holds only the given items, but can be resized.
    static IntDeque
    with(int item0, int item1, int item2, int item3, int item4, int item5, int item6)
    Creates a new IntDeque that holds only the given items, but can be resized.
    static IntDeque
    with(int item0, int item1, int item2, int item3, int item4, int item5, int item6, int item7)
    Creates a new IntDeque that holds only the given items, but can be resized.

    Methods inherited from class com.github.tommyettinger.ds.IntList

    keepsOrder

    Methods inherited from class java.lang.Object

    clone, finalize, getClass, notify, notifyAll, wait, wait, wait

    Methods inherited from interface com.github.tommyettinger.ds.Arrangeable

    rearrange, shuffle

    Methods inherited from interface com.github.tommyettinger.ds.Ordered.OfInt

    getOrderType, random, selectRanked, selectRankedIndex

    Methods inherited from interface com.github.tommyettinger.ds.PrimitiveCollection.OfInt

    addAll, addDense, addDense, addLegible, addLegible, addVarargs, appendTo, appendTo, containsAll, containsAll, containsAll, containsAll, containsAny, containsAny, containsAny, containsAny, denseAppendTo, equalContents, forEach, removeAll, removeAll, removeAll, removeEach, removeEach, removeEach, removeIf, retainAll, retainAll, toDenseString, toDenseString, toString, toString, toString

  • Field Details

    • defaultValue

      public int defaultValue
      The value returned when nothing can be obtained from this deque and an exception is not meant to be thrown, such as when calling peek() on an empty deque.

    • tail

      protected int tail
      Index of last element. Logically bigger than head. Unless empty, it points to a valid element inside the deque. This may be the same as head, and is if there is one element in the deque (or none), that will be the case.

    • descendingIterator1

      protected transient IntDeque.IntDequeIterator descendingIterator1

    • descendingIterator2

      protected transient IntDeque.IntDequeIterator descendingIterator2

  • Constructor Details

    • IntDeque

      public IntDeque()
      Creates a new IntDeque which can hold 16 values without needing to resize the backing array.

    • IntDeque

      public IntDeque(int initialSize)
      Creates a new IntDeque which can hold the specified number of values without needing to resize the backing array.
      Parameters:
      initialSize - how large the backing array should be, without any padding

    • IntDeque

      public IntDeque(PrimitiveCollection.OfInt coll)
      Creates a new IntDeque using all the contents of the given Collection.
      Parameters:
      coll - a Collection of int that will be copied into this and used in full
      Throws:
      NullPointerException - if coll is null

    • IntDeque

      public IntDeque(IntIterator iter)
      Creates a new instance containing the items in the specified iterator.
      Parameters:
      iter - an iterator that will have its remaining contents added to this
      Throws:
      NullPointerException - if iter is null

    • IntDeque

      public IntDeque(IntDeque deque)
      Copies the given IntDeque exactly into this one. Individual values will be shallow-copied.
      Parameters:
      deque - another IntDeque to copy
      Throws:
      NullPointerException - if deque is null

    • IntDeque

      public IntDeque(Ordered.OfInt other, int offset, int count)

    • IntDeque

      public IntDeque(int[] a)
      Creates a new IntDeque using all the contents of the given array.
      Parameters:
      a - an array of int that will be copied into this and used in full
      Throws:
      NullPointerException - if a is null

    • IntDeque

      public IntDeque(int[] a, int offset, int count)
      Creates a new IntDeque using count items from a, starting at offset. If count is 0 or less, this will create an empty IntDeque with capacity 1.
      Parameters:
      a - an array of int
      offset - where in a to start using items
      count - how many items to use from a
      Throws:
      NullPointerException - if a is null

    • IntDeque

      public IntDeque(Ordered.OfInt other)

  • Method Details

    • order

      public IntDeque order()
      Description copied from class: IntList
      Returns this IntList, since it is its own order. This is only here to satisfy the Ordered.OfInt interface.
      Specified by:
      order in interface Ordered.OfInt
      Overrides:
      order in class IntList
      Returns:
      this IntList

    • getDefaultValue

      public int getDefaultValue()
      Gets the default value, which is the value returned when nothing can be obtained from this deque and an exception is not meant to be thrown, such as when calling peek() on an empty deque. Unless changed, the default value is usually null.
      Returns:
      the current default value

    • setDefaultValue

      public void setDefaultValue(int defaultValue)
      Sets the default value, which is the value returned when nothing can be obtained from this deque and an exception is not meant to be thrown, such as when calling peek() on an empty deque. Unless changed, the default value is usually null.
      Parameters:
      defaultValue - any int this can return instead of throwing an Exception, or null

    • addLast

      public void addLast(int value)
      Appends given int to the tail (enqueue to tail). Unless the backing array needs resizing, operates in O(1) time.
      Parameters:
      value - can be null

    • addLast

      public void addLast(int value1, int value2)

    • addLast

      public void addLast(int value1, int value2, int value3)

    • addLast

      public void addLast(int value1, int value2, int value3, int value4)

    • addFirst

      public void addFirst(int value)
      Prepend given value to the head (enqueue to head). Unless backing array needs resizing, operates in O(1) time.
      Parameters:
      value - can be null
      See Also:

    • addFirst

      public void addFirst(int value1, int value2)

    • addFirst

      public void addFirst(int value1, int value2, int value3)

    • addFirst

      public void addFirst(int value1, int value2, int value3, int value4)

    • trimToSize

      public void trimToSize()
      Trims the capacity of this IntDeque instance to be the deque's current size. An application can use this operation to minimize the storage of a IntDeque instance.
      Overrides:
      trimToSize in class IntList

    • shrink

      public int[] shrink()
      Description copied from class: IntList
      Reduces the size of the backing array to the size of the actual items. This is useful to release memory when many items have been removed, or if it is known that more items will not be added.
      Overrides:
      shrink in class IntList
      Returns:
      IntList.items; this will be a different reference if this resized

    • ensureCapacity

      public int[] ensureCapacity(int additional)
      Increases the size of the backing array to accommodate the specified number of additional items. Useful before adding many items to avoid multiple backing array resizes.
      Overrides:
      ensureCapacity in class IntList
      Returns:
      the backing array this will use after this call

    • resize

      public int[] resize(int newSize)
      Resizes the backing array. newSize should be greater than the current size; otherwise, newSize will be set to size and the resize to the same size will (for most purposes) be wasted effort. If this is not empty, this will rearrange the items internally to be linear and have the head at index 0, with the tail at size - 1. This always allocates a new internal backing array.
      Overrides:
      resize in class IntList
      Returns:
      the new backing array, as a direct reference

    • ensureGap

      protected int ensureGap(int index, int gapSize)
      Make sure there is a "gap" of exactly gapSize values starting at index. This can resize the backing array to achieve this goal. If possible, this will keep the same backing array and modify it in-place. The "gap" is not assigned null, and may contain old/duplicate references; calling code must overwrite the entire gap with additional values to ensure GC correctness.
      Parameters:
      index - the 0-based index in the iteration order where the gap will be present
      gapSize - the number of items that will need filling in the gap, and can be filled without issues.
      Returns:
      the position in the array where the gap will begin, which is unrelated to the index

    • addAll

      public boolean addAll(IntList list)
      Overrides:
      addAll in class IntList

    • addAll

      public boolean addAll(IntList list, int offset, int count)
      Overrides:
      addAll in class IntList

    • removeFirst

      public int removeFirst()
      Remove the first item from the deque. (dequeue from head) Always O(1).
      Returns:
      removed int
      Throws:
      NoSuchElementException - when the deque is empty

    • removeLast

      public int removeLast()
      Remove the last item from the deque. (dequeue from tail) Always O(1).
      Returns:
      removed int
      Throws:
      NoSuchElementException - when the deque is empty
      See Also:

    • offerFirst

      public boolean offerFirst(int t)
      Inserts the specified element at the front of this deque unless it would violate capacity restrictions. When using a capacity-restricted deque, this method is generally preferable to the addFirst(int) method, which can fail to insert an element only by throwing an exception.
      Parameters:
      t - the element to add
      Returns:
      true if the element was added to this deque, else false
      Throws:
      ClassCastException - if the class of the specified element prevents it from being added to this deque
      NullPointerException - if the specified element is null and this deque does not permit null elements
      IllegalArgumentException - if some property of the specified element prevents it from being added to this deque

    • offerLast

      public boolean offerLast(int t)
      Inserts the specified element at the end of this deque unless it would violate capacity restrictions. When using a capacity-restricted deque, this method is generally preferable to the addLast(int) method, which can fail to insert an element only by throwing an exception.
      Parameters:
      t - the element to add
      Returns:
      true if the element was added to this deque, else false
      Throws:
      ClassCastException - if the class of the specified element prevents it from being added to this deque
      NullPointerException - if the specified element is null and this deque does not permit null elements
      IllegalArgumentException - if some property of the specified element prevents it from being added to this deque

    • pollFirst

      public int pollFirst()
      Retrieves and removes the first element of this deque, or returns defaultValue if this deque is empty. The default value is usually null unless it has been changed with setDefaultValue(int).
      Returns:
      the head of this deque, or defaultValue if this deque is empty
      See Also:

    • pollLast

      public int pollLast()
      Retrieves and removes the last element of this deque, or returns defaultValue if this deque is empty. The default value is usually null unless it has been changed with setDefaultValue(int).
      Returns:
      the tail of this deque, or defaultValue if this deque is empty
      See Also:

    • getFirst

      public int getFirst()
      Retrieves, but does not remove, the first element of this deque.

      This method differs from peekFirst only in that it throws an exception if this deque is empty.

      Returns:
      the head of this deque
      Throws:
      NoSuchElementException - if this deque is empty

    • getLast

      public int getLast()
      Retrieves, but does not remove, the last element of this deque. This method differs from peekLast only in that it throws an exception if this deque is empty.
      Returns:
      the tail of this deque
      Throws:
      NoSuchElementException - if this deque is empty

    • peekFirst

      public int peekFirst()
      Retrieves, but does not remove, the first element of this deque, or returns defaultValue if this deque is empty.
      Returns:
      the head of this deque, or defaultValue if this deque is empty

    • peekLast

      public int peekLast()
      Retrieves, but does not remove, the last element of this deque, or returns defaultValue if this deque is empty.
      Returns:
      the tail of this deque, or defaultValue if this deque is empty

    • removeFirstOccurrence

      public boolean removeFirstOccurrence(int o)
      Removes the first occurrence of the specified element from this deque. If the deque does not contain the element, it is unchanged. More formally, removes the first element e such that o == e (if such an element exists). Returns true if this deque contained the specified element (or equivalently, if this deque changed as a result of the call).
      Parameters:
      o - element to be removed from this deque, if present
      Returns:
      true if an element was removed as a result of this call

    • removeLastOccurrence

      public boolean removeLastOccurrence(int o)
      Removes the last occurrence of the specified element from this deque. If the deque does not contain the element, it is unchanged. More formally, removes the last element e such that o == e (if such an element exists). Returns true if this deque contained the specified element (or equivalently, if this deque changed as a result of the call).
      Parameters:
      o - element to be removed from this deque, if present
      Returns:
      true if an element was removed as a result of this call

    • add

      public boolean add(int t)
      Inserts the specified element into the deque represented by this deque (in other words, at the tail of this deque) if it is possible to do so immediately without violating capacity restrictions, returning true upon success and throwing an IllegalStateException if no space is currently available. When using a capacity-restricted deque, it is generally preferable to use offer.

      This method is equivalent to addLast(int).

      Specified by:
      add in interface PrimitiveCollection.OfInt
      Overrides:
      add in class IntList
      Parameters:
      t - the element to add
      Returns:
      true (as specified by Collection.add(E))

    • add

      public void add(int value1, int value2)
      Overrides:
      add in class IntList

    • add

      public void add(int value1, int value2, int value3)
      Overrides:
      add in class IntList

    • add

      public void add(int value1, int value2, int value3, int value4)
      Overrides:
      add in class IntList

    • insert

      public void insert(int index, int item)
      Inserts the specified element into this deque at the specified index. Unlike offerFirst(int) and offerLast(int), this does not run in expected constant time unless the index is less than or equal to 0 (where it acts like offerFirst()) or greater than or equal to size() (where it acts like offerLast()).
      Overrides:
      insert in class IntList
      Parameters:
      index - the index in the deque's insertion order to insert the item
      item - an int item to insert; may be null

    • offer

      public boolean offer(int t)
      Inserts the specified element into the queue represented by this deque (in other words, at the tail of this deque) if it is possible to do so immediately without violating capacity restrictions, returning true upon success and false if no space is currently available. When using a capacity-restricted deque, this method is generally preferable to the add(int) method, which can fail to insert an element only by throwing an exception.

      This method is equivalent to offerLast(int).

      Parameters:
      t - the element to add
      Returns:
      true if the element was added to this deque, else false

    • remove

      public int remove()
      Retrieves and removes the head of the queue represented by this deque (in other words, the first element of this deque). This method differs from poll() only in that it throws an exception if this deque is empty.

      This method is equivalent to removeFirst().

      Returns:
      the head of the queue represented by this deque
      Throws:
      NoSuchElementException - if this deque is empty

    • poll

      public int poll()
      Retrieves and removes the head of the queue represented by this deque (in other words, the first element of this deque), or returns defaultValue if this deque is empty.

      This method is equivalent to pollFirst().

      Returns:
      the first element of this deque, or defaultValue if this deque is empty

    • element

      public int element()
      Retrieves, but does not remove, the head of the queue represented by this deque (in other words, the first element of this deque). This method differs from peek only in that it throws an exception if this deque is empty.

      This method is equivalent to getFirst().

      Returns:
      the head of the queue represented by this deque
      Throws:
      NoSuchElementException - if this deque is empty

    • peek

      public int peek()
      Retrieves, but does not remove, the head of the queue represented by this deque (in other words, the first element of this deque), or returns defaultValue if this deque is empty.

      This method is equivalent to peekFirst().

      Overrides:
      peek in class IntList
      Returns:
      the head of the queue represented by this deque, or defaultValue if this deque is empty

    • addAll

      public boolean addAll(PrimitiveCollection.OfInt c)
      Adds all the elements in the specified collection at the end of this deque, as if by calling addLast(int) on each one, in the order that they are returned by the collection's iterator.

      When using a capacity-restricted deque, it is generally preferable to call offer separately on each element.

      An exception encountered while trying to add an element may result in only some of the elements having been successfully added when the associated exception is thrown.

      Specified by:
      addAll in interface PrimitiveCollection.OfInt
      Parameters:
      c - the elements to be inserted into this deque
      Returns:
      true if this deque changed as a result of the call

    • addAllLast

      public boolean addAllLast(PrimitiveCollection.OfInt c)
      An alias for addAll(OfInt), this adds every item in c to this in order at the end.
      Parameters:
      c - the elements to be inserted into this deque
      Returns:
      true if this deque changed as a result of the call

    • addAllFirst

      public boolean addAllFirst(PrimitiveCollection.OfInt c)
      Adds every item in c to this in order at the start. The iteration order of c will be preserved for the added items.
      Parameters:
      c - the elements to be inserted into this deque
      Returns:
      true if this deque changed as a result of the call

    • insertAll

      public boolean insertAll(int index, PrimitiveCollection.OfInt c)
      An alias for addAll(int, OfInt); inserts all elements in the specified collection into 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 returned by the specified collection's iterator. The behavior of this operation is undefined if the specified collection is modified while the operation is in progress. (Note that this will occur if the specified collection is this list, and it's nonempty.)
      Parameters:
      index - index at which to insert the first element from the specified collection
      c - collection 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, PrimitiveCollection.OfInt c)

    • addAll

      public boolean addAll(int[] array)
      Exactly like addAll(OfInt), but takes an array instead of a PrimitiveCollection.OfInt.
      Specified by:
      addAll in interface PrimitiveCollection.OfInt
      Overrides:
      addAll in class IntList
      Parameters:
      array - the elements to be inserted into this deque
      Returns:
      true if this deque changed as a result of the call
      See Also:

    • addAll

      public boolean addAll(int[] array, int offset, int length)
      Like addAll(int[]), but only uses at most length items from array, starting at offset.
      Specified by:
      addAll in interface PrimitiveCollection.OfInt
      Overrides:
      addAll in class IntList
      Parameters:
      array - the elements to be inserted into this deque
      offset - the index of the first item in array to add
      length - how many items, at most, to add from array into this
      Returns:
      true if this deque changed as a result of the call
      See Also:

    • addAllLast

      public boolean addAllLast(int[] array)
      An alias for addAll(int[]).
      Parameters:
      array - the elements to be inserted into this deque
      Returns:
      true if this deque changed as a result of the call
      See Also:

    • addAllLast

      public boolean addAllLast(int[] array, int offset, int length)
      An alias for addAll(int[], int, int).
      Parameters:
      array - the elements to be inserted into this deque
      offset - the index of the first item in array to add
      length - how many items, at most, to add from array into this
      Returns:
      true if this deque changed as a result of the call
      See Also:

    • addAllFirst

      public boolean addAllFirst(int[] array)
      Exactly like addAllFirst(OfInt), but takes an array instead of a PrimitiveCollection.OfInt.
      Parameters:
      array - the elements to be inserted into this deque
      Returns:
      true if this deque changed as a result of the call
      See Also:

    • addAllFirst

      public boolean addAllFirst(int[] array, int offset, int length)
      Like addAllFirst(int[]), but only uses at most length items from array, starting at offset. The order of array will be preserved, starting at the head of the deque.
      Parameters:
      array - the elements to be inserted into this deque
      offset - the index of the first item in array to add
      length - how many items, at most, to add from array into this
      Returns:
      true if this deque changed as a result of the call
      See Also:

    • insertAll

      public boolean insertAll(int index, int[] array)
      Alias for addAll(int, int[]).
      Parameters:
      index - the index in this deque's iteration order to place the first item in array
      array - the elements to be inserted into this deque
      Returns:
      true if this deque changed as a result of the call

    • insertAll

      public boolean insertAll(int index, int[] array, int offset, int length)
      Alias for addAll(int, int[], int, int).
      Parameters:
      index - the index in this deque's iteration order to place the first item in array
      array - the elements to be inserted into this deque
      offset - the index of the first item in array to add
      length - how many items, at most, to add from array into this
      Returns:
      true if this deque changed as a result of the call

    • addAll

      public boolean addAll(int index, int[] array)
      Like addAll(int, OfInt), but takes an array instead of a PrimitiveCollection.OfInt and inserts it so the first item will be at the given index. The order of array will be preserved, starting at the given index in this deque.
      Parameters:
      index - the index in this deque's iteration order to place the first item in array
      array - the elements to be inserted into this deque
      Returns:
      true if this deque changed as a result of the call
      See Also:

    • addAll

      public boolean addAll(int index, int[] array, int offset, int length)
      Like addAll(int, OfInt), but takes an array instead of a PrimitiveCollection.OfInt, gets items starting at offset from that array, using length items, and inserts them so the item at the given offset will be at the given index. The order of array will be preserved, starting at the given index in this deque.
      Parameters:
      index - the index in this deque's iteration order to place the first item in array
      array - the elements to be inserted into this deque
      offset - the index of the first item in array to add
      length - how many items, at most, to add from array into this
      Returns:
      true if this deque changed as a result of the call
      See Also:

    • addAll

      public boolean addAll(Ordered.OfInt ord)
      Exactly like addAll(OfInt), but takes an Ordered.OfInt instead of a PrimitiveCollection.OfInt.
      Parameters:
      ord - the elements to be inserted into this deque
      Returns:
      true if this deque changed as a result of the call
      See Also:

    • addAll

      public boolean addAll(Ordered.OfInt ord, int offset, int length)
      Like addAll(int[]), but only uses at most length items from ord, starting at offset.
      Overrides:
      addAll in class IntList
      Parameters:
      ord - the elements to be inserted into this deque
      offset - the index of the first item in ord to add
      length - how many items, at most, to add from ord into this
      Returns:
      true if this deque changed as a result of the call
      See Also:

    • addAll

      public boolean addAll(int index, Ordered.OfInt ord)
      Like addAll(int, OfInt), but takes an ord instead of a PrimitiveCollection.OfInt and inserts it so the first item will be at the given index. The order of ord will be preserved, starting at the given index in this deque.
      Parameters:
      index - the index in this deque's iteration order to place the first item in ord
      ord - the elements to be inserted into this deque
      Returns:
      true if this deque changed as a result of the call
      See Also:

    • addAll

      public boolean addAll(int index, Ordered.OfInt ord, int offset, int length)
      Like addAll(int, OfInt), but takes an array instead of a PrimitiveCollection.OfInt, gets items starting at offset from that array, using length items, and inserts them so the item at the given offset will be at the given index. The order of array will be preserved, starting at the given index in this deque.
      Overrides:
      addAll in class IntList
      Parameters:
      index - the index in this deque's iteration order to place the first item in array
      ord - the elements to be inserted into this deque
      offset - the index of the first item in array to add
      length - how many items, at most, to add from array into this
      Returns:
      true if this deque changed as a result of the call
      See Also:

    • addAllLast

      public boolean addAllLast(Ordered.OfInt ord)
      An alias for addAll(Ordered.OfInt).
      Parameters:
      ord - the elements to be inserted into this deque
      Returns:
      true if this deque changed as a result of the call
      See Also:

    • addAllLast

      public boolean addAllLast(Ordered.OfInt ord, int offset, int length)
      An alias for addAll(Ordered.OfInt, int, int).
      Parameters:
      ord - the elements to be inserted into this deque
      offset - the index of the first item in ord to add
      length - how many items, at most, to add from ord into this
      Returns:
      true if this deque changed as a result of the call
      See Also:

    • addAllFirst

      public boolean addAllFirst(Ordered.OfInt ord)
      Exactly like addAllFirst(OfInt), but takes an ord instead of a PrimitiveCollection.OfInt.
      Parameters:
      ord - the elements to be inserted into this deque
      Returns:
      true if this deque changed as a result of the call
      See Also:

    • addAllFirst

      public boolean addAllFirst(Ordered.OfInt ord, int offset, int length)
      Like addAllFirst(Ordered.OfInt), but only uses at most length items from ord, starting at offset. The order of ord will be preserved, starting at the head of the deque.
      Parameters:
      ord - the elements to be inserted into this deque
      offset - the index of the first item in ord to add
      length - how many items, at most, to add from ord into this
      Returns:
      true if this deque changed as a result of the call
      See Also:

    • insertAll

      public boolean insertAll(int index, Ordered.OfInt ord)
      Alias for addAll(int, Ordered.OfInt).
      Parameters:
      index - the index in this deque's iteration order to place the first item in ord
      ord - the elements to be inserted into this deque
      Returns:
      true if this deque changed as a result of the call

    • insertAll

      public boolean insertAll(int index, Ordered.OfInt ord, int offset, int length)
      Alias for addAll(int, Ordered.OfInt, int, int).
      Parameters:
      index - the index in this deque's iteration order to place the first item in ord
      ord - the elements to be inserted into this deque
      offset - the index of the first item in ord to add
      length - how many items, at most, to add from ord into this
      Returns:
      true if this deque changed as a result of the call

    • push

      public void push(int t)
      Pushes an element onto the stack represented by this deque (in other words, at the head of this deque).

      This method is equivalent to addFirst(int).

      Parameters:
      t - the element to push

    • pop

      public int pop()
      Pops an element from the stack represented by this deque. In other words, removes and returns the first element of this deque.

      This method is equivalent to removeFirst().

      Overrides:
      pop in class IntList
      Returns:
      the element at the front of this deque (which is the top of the stack represented by this deque)
      Throws:
      NoSuchElementException - if this deque is empty

    • remove

      public boolean remove(int o)
      Removes the first occurrence of the specified element from this deque. If the deque does not contain the element, it is unchanged. More formally, removes the first element e such that o == e (if such an element exists). Returns true if this deque contained the specified element (or equivalently, if this deque changed as a result of the call).

      This method is equivalent to removeFirstOccurrence(int).

      Specified by:
      remove in interface PrimitiveCollection.OfInt
      Overrides:
      remove in class IntList
      Parameters:
      o - element to be removed from this deque, if present
      Returns:
      true if an element was removed as a result of this call

    • contains

      public boolean contains(int o)
      Returns true if this deque contains the specified element. More formally, returns true if and only if this deque contains at least one element e such that o == e.
      Specified by:
      contains in interface PrimitiveCollection.OfInt
      Overrides:
      contains in class IntList
      Parameters:
      o - element whose presence in this deque is to be tested
      Returns:
      true if this deque contains the specified element

    • containsAll

      public boolean containsAll(IntList other)
      Description copied from class: IntList
      Returns true if this IntList contains, at least once, every item in other; otherwise returns false.
      Overrides:
      containsAll in class IntList
      Parameters:
      other - an IntList
      Returns:
      true if this contains every item in other, otherwise false

    • size

      public int size()
      Returns the number of elements in this deque.
      Specified by:
      size in interface Arrangeable
      Specified by:
      size in interface PrimitiveCollection<Integer>
      Overrides:
      size in class IntList
      Returns:
      the number of elements in this deque

    • toArray

      public int[] toArray()
      Returns an array containing all the elements in this collection. If this collection makes any guarantees as to what order its elements are returned by its iterator, this method must return the elements in the same order. The returned array's runtime component type is int.

      The returned array will be "safe" in that no references to it are maintained by this collection. (In other words, this method must allocate a new array even if this collection is backed by an array). The caller is thus free to modify the returned array.

      Specified by:
      toArray in interface PrimitiveCollection.OfInt
      Overrides:
      toArray in class IntList
      Returns:
      an array, whose runtime component type is int, containing all the elements in this collection

    • toArray

      public int[] toArray(int[] array)
      Description copied from class: IntList
      If array.length at least equal to IntList.size(), this copies the contents of this into array and returns it; otherwise, it allocates a new int array that can fit all the items in this, and proceeds to copy into that and return that.
      Specified by:
      toArray in interface PrimitiveCollection.OfInt
      Overrides:
      toArray in class IntList
      Parameters:
      array - a int array that will be modified if it can fit IntList.size() items
      Returns:
      array, if it had sufficient size, or a new array otherwise, either with a copy of this

    • setSize

      public int[] setSize(int newSize)
      Description copied from class: IntList
      Sets the list size, leaving any values beyond the current size undefined.
      Overrides:
      setSize in class IntList
      Returns:
      IntList.items; this will be a different reference if this resized to a larger capacity

    • truncateLast

      public void truncateLast(int newSize)
      Alias for truncate(int).
      Parameters:
      newSize - the size this deque should have after this call completes, if smaller than the current size

    • truncate

      public void truncate(int newSize)
      Reduces the size of the deque to the specified size by bulk-removing items from the tail end. If the deque is already smaller than the specified size, no action is taken.
      Overrides:
      truncate in class IntList
      Parameters:
      newSize - the size this deque should have after this call completes, if smaller than the current size

    • truncateFirst

      public void truncateFirst(int newSize)
      Reduces the size of the deque to the specified size by bulk-removing from the head. If the deque is already smaller than the specified size, no action is taken.
      Parameters:
      newSize - the size this deque should have after this call completes, if smaller than the current size

    • removeRange

      public void removeRange(int fromIndex, int toIndex)
      Removes from this list all the elements whose index is between fromIndex, inclusive, and toIndex, exclusive. Shifts any succeeding elements to the left (reduces their index). This call shrinks the list by (toIndex - fromIndex) elements. If toIndex==fromIndex, this operation has no effect. If fromIndex is 0 or less, this delegates to truncateFirst(int); if toIndex is equal to or greater than the size of this collection, this delegates to truncate(int).
      This is public here, not protected as in most JDK collections, because there are actually sometimes needs for this in user code.
      Specified by:
      removeRange in interface Ordered.OfInt
      Overrides:
      removeRange in class IntList
      Parameters:
      fromIndex - index of first element to be removed (inclusive)
      toIndex - index after last element to be removed (exclusive)

    • indexOf

      public int indexOf(int value)
      Returns the index of the first occurrence of value in the deque, or -1 if no such value exists.
      Overrides:
      indexOf in class IntList
      Parameters:
      value - the int to look for
      Returns:
      An index of the first occurrence of value in the deque or -1 if no such value exists

    • indexOf

      public int indexOf(int value, int fromIndex)
      Returns the index of the first occurrence of value in the deque, or -1 if no such value exists. This returns fromIndex if value is present at that point, so if you chain calls to indexOf(), the subsequent fromIndex should be larger than the last-returned index.
      Parameters:
      value - the int to look for
      fromIndex - the initial index to check (zero-indexed, starts at the head, inclusive)
      Returns:
      An index of first occurrence of value at or after fromIndex in the deque, or -1 if no such value exists

    • lastIndexOf

      public int lastIndexOf(int value)
      Returns the index of the last occurrence of value in the deque, or -1 if no such value exists.
      Overrides:
      lastIndexOf in class IntList
      Parameters:
      value - the int to look for
      Returns:
      An index of the last occurrence of value in the deque or -1 if no such value exists

    • lastIndexOf

      public int lastIndexOf(int value, int fromIndex)
      Returns the index of last occurrence of value in the deque, starting from fromIndex and going backwards, or -1 if no such value exists. This returns fromIndex if value is present at that point, so if you chain calls to indexOf(), the subsequent fromIndex should be smaller than the last-returned index.
      Parameters:
      value - the int to look for
      fromIndex - the initial index to check (zero-indexed, starts at the head, inclusive)
      Returns:
      An index of last occurrence of value at or before fromIndex in the deque, or -1 if no such value exists

    • listIterator

      public IntList.IntListIterator listIterator()

    • listIterator

      public IntList.IntListIterator listIterator(int index)
      Gets an iterator over this deque that starts at the given index.
      Parameters:
      index - the index to start iterating from in this deque
      Returns:
      a reused iterator starting at the given index

    • removeValue

      public boolean removeValue(int value)
      Removes the first instance of the specified value in the deque.
      Parameters:
      value - the int to remove
      Returns:
      true if value was found and removed, false otherwise

    • removeLastValue

      public boolean removeLastValue(int value)
      Removes the last instance of the specified value in the deque.
      Parameters:
      value - the int to remove
      Returns:
      true if value was found and removed, false otherwise

    • removeAt

      public int removeAt(int index)
      Removes the element at the specified position in this deque. Shifts any subsequent elements to the left (subtracts one from their indices). Returns the element that was removed from the deque.
      Overrides:
      removeAt in class IntList
      Parameters:
      index - the index of the element to be removed
      Returns:
      the element previously at the specified position

    • pollAt

      public int pollAt(int index)
      Removes the element at the specified position in this deque. Shifts any subsequent elements to the left (subtracts one from their indices). Returns the element that was removed from the deque, or the default value if this is empty. This will not throw an Exception in normal usage, even if index is negative (which makes this simply return pollFirst()) or greater than or equal to size() (which makes this return pollLast()).
      This is an alias for poll(int) for compatibility with primitive-backed lists and deques; poll(int) can refer to the method that removes an item by value, not by index, in those types.
      Parameters:
      index - the index of the element to be removed
      Returns:
      the element previously at the specified position

    • poll

      public int poll(int index)
      Removes the element at the specified position in this deque. Shifts any subsequent elements to the left (subtracts one from their indices). Returns the element that was removed from the deque, or the default value if this is empty. This will not throw an Exception in normal usage, even if index is negative (which makes this simply return pollFirst()) or greater than or equal to size() (which makes this return pollLast()).
      Parameters:
      index - the index of the element to be removed
      Returns:
      the element previously at the specified position

    • removeAll

      public boolean removeAll(PrimitiveCollection.OfInt c)
      Description copied from class: IntList
      Removes from this IntList all occurrences of any elements contained in the specified collection.
      Specified by:
      removeAll in interface PrimitiveCollection.OfInt
      Overrides:
      removeAll in class IntList
      Parameters:
      c - a primitive collection of int items to remove fully, such as another IntList or a IntDeque
      Returns:
      true if this list was modified.

    • removeEach

      public boolean removeEach(PrimitiveCollection.OfInt c)
      Description copied from class: IntList
      Removes from this IntList element-wise occurrences of elements contained in the specified collection. Note that if a value is present more than once in this IntList, only one of those occurrences will be removed for each occurrence of that value in c. If c has the same contents as this IntList or has additional items, then removing each of c will clear this.
      Specified by:
      removeEach in interface PrimitiveCollection.OfInt
      Overrides:
      removeEach in class IntList
      Parameters:
      c - a primitive collection of int items to remove one-by-one, such as another IntList or a IntDeque
      Returns:
      true if this list was modified.

    • retainAll

      public boolean retainAll(PrimitiveCollection.OfInt other)
      Description copied from class: IntList
      Removes all items from this IntList that are not present somewhere in other, any number of times.
      Specified by:
      retainAll in interface PrimitiveCollection.OfInt
      Overrides:
      retainAll in class IntList
      Parameters:
      other - a PrimitiveCollection.OfInt that contains the items that this should keep, whenever present
      Returns:
      true if this IntList changed as a result of this call, otherwise false

    • notEmpty

      public boolean notEmpty()
      Returns true if the deque has one or more items.
      Specified by:
      notEmpty in interface PrimitiveCollection<Integer>
      Overrides:
      notEmpty in class IntList
      Returns:
      true if the list has one or more items, or false otherwise

    • isEmpty

      public boolean isEmpty()
      Returns true if the deque is empty.
      Specified by:
      isEmpty in interface PrimitiveCollection<Integer>
      Overrides:
      isEmpty in class IntList
      Returns:
      true if the list is empty, or false if it has any items

    • first

      public int first()
      Returns the first (head) item in the deque (without removing it).
      Specified by:
      first in interface PrimitiveCollection.OfInt
      Overrides:
      first in class IntList
      Returns:
      the first item, without modifying this
      Throws:
      NoSuchElementException - when the deque is empty
      See Also:

    • last

      public int last()
      Returns the last (tail) item in the deque (without removing it).
      Throws:
      NoSuchElementException - when the deque is empty
      See Also:

    • get

      public int get(int index)
      Returns the element at the specified position in this deque. Like ArrayList or IntList, but unlike LinkedList, this runs in O(1) time. It is expected to be slightly slower than IntList.get(int), which also runs in O(1) time. Unlike get() in ArrayList or IntList, this considers negative indices to refer to the first item, and too-large indices to refer to the last item. That means it delegates to getFirst() or getLast() in those cases instead of throwing an IndexOutOfBoundsException, though it may throw a NoSuchElementException if the deque is empty and there is no item it can get.
      Overrides:
      get in class IntList
      Parameters:
      index - index of the element to return
      Returns:
      the element at the specified position in this deque
      Throws:
      NoSuchElementException - if the deque is empty

    • peekAt

      public int peekAt(int index)
      Returns the element at the specified position in this deque. Like ArrayList or IntList, but unlike LinkedList, this runs in O(1) time. It is expected to be slightly slower than IntList.get(int), which also runs in O(1) time. Unlike get() in ArrayList or IntList, this considers negative indices to refer to the first item, and too-large indices to refer to the last item. That means it delegates to peekFirst() or peekLast() in those cases instead of throwing an IndexOutOfBoundsException, and it will return the default value if the deque is empty. Unless changed, the default value is usually null.
      Parameters:
      index - index of the element to return
      Returns:
      the element at the specified position in this deque

    • assign

      public int assign(int index, int item)
      Replaces the element at the specified position in this list with the specified element. If this deque is empty or the index is larger than the largest index currently in this deque, this delegates to addLast(int) and returns the default value. If the index is negative, this delegates to addFirst(int) and returns the default value.
      Parameters:
      index - index of the element to replace
      item - element to be stored at the specified position
      Returns:
      the element previously at the specified position

    • set

      public void set(int index, int item)
      Replaces the element at the specified position in this list with the specified element. If this deque is empty or the index is larger than the largest index currently in this deque, this delegates to addLast(int) and returns the default value. If the index is negative, this delegates to addFirst(int) and returns the default value.
      Overrides:
      set in class IntList
      Parameters:
      index - index of the element to replace
      item - element to be stored at the specified position

    • plus

      public void plus(int index, int value)
      Overrides:
      plus in class IntList

    • plus

      public IntList plus(int value)
      Description copied from class: IntList
      Adds value to each item in this IntList, stores it in this and returns it. The presence of this method allows Kotlin code to use the + operator (though it shouldn't be used more than once in an expression, because this method modifies this IntList).
      Overrides:
      plus in class IntList
      Parameters:
      value - each item in this will be assigned item + value
      Returns:
      this for chaining and Kotlin compatibility

    • times

      public void times(int index, int value)
      Overrides:
      times in class IntList

    • times

      public IntList times(int value)
      Description copied from class: IntList
      Multiplies each item in this IntList by value, stores it in this and returns it. The presence of this method allows Kotlin code to use the * operator (though it shouldn't be used more than once in an expression, because this method modifies this IntList).
      Overrides:
      times in class IntList
      Parameters:
      value - each item in this will be assigned item * value
      Returns:
      this for chaining and Kotlin compatibility

    • minus

      public void minus(int index, int value)
      Overrides:
      minus in class IntList

    • minus

      public IntList minus(int value)
      Description copied from class: IntList
      Takes each item in this IntList and subtracts value, stores it in this and returns it. This is just a minor convenience in Java, but the presence of this method allows Kotlin code to use the - operator (though it shouldn't be used more than once in an expression, because this method modifies this IntList).
      Overrides:
      minus in class IntList
      Parameters:
      value - each item in this will be assigned item - value
      Returns:
      this for chaining and Kotlin compatibility

    • div

      public void div(int index, int value)
      Overrides:
      div in class IntList

    • div

      public IntList div(int value)
      Description copied from class: IntList
      Divides each item in this IntList by value, stores it in this and returns it. The presence of this method allows Kotlin code to use the / operator (though it shouldn't be used more than once in an expression, because this method modifies this IntList).
      Overrides:
      div in class IntList
      Parameters:
      value - each item in this will be assigned item / value
      Returns:
      this for chaining and Kotlin compatibility

    • rem

      public void rem(int index, int value)
      Overrides:
      rem in class IntList

    • rem

      public IntList rem(int value)
      Description copied from class: IntList
      Gets the remainder of each item in this IntList with value, stores it in this and returns it. The presence of this method allows Kotlin code to use the % operator (though it shouldn't be used more than once in an expression, because this method modifies this IntList).
      Overrides:
      rem in class IntList
      Parameters:
      value - each item in this will be assigned item % value
      Returns:
      this for chaining and Kotlin compatibility

    • replaceAll

      public void replaceAll(com.github.tommyettinger.function.IntToIntFunction operator)
      Description copied from class: IntList
      Replaces each element of this list with the result of applying the given operator to that element.
      Overrides:
      replaceAll in class IntList
      Parameters:
      operator - an IntToIntFunction (a functional interface defined in funderby)

    • replaceFirst

      public boolean replaceFirst(int find, int replace)
      Replaces the first occurrence of find with replace. Returns true if it performed the replacement, or false if there was nothing to replace. This also returns false if find and replace are the same.
      Overrides:
      replaceFirst in class IntList
      Parameters:
      find - the item to search for
      replace - the item to replace find with, if possible
      Returns:
      true if this changed, or false otherwise

    • replaceAll

      public int replaceAll(int find, int replace)
      Replaces every occurrence of find with replace. Returns the number of changed items, which is 0 if nothing was found or in the case that find and replace are the same.
      Overrides:
      replaceAll in class IntList
      Parameters:
      find - the item to search for
      replace - the item to replace find with, if possible
      Returns:
      the number of replacements that occurred; 0 if nothing was found or replaced

    • duplicateRange

      public boolean duplicateRange(int index, int count)
      Inserts the specified number of items at the specified index. The new items will have values equal to the values at those indices before the insertion, and the previous values will be pushed to after the duplicated range.
      Overrides:
      duplicateRange in class IntList
      Parameters:
      index - the first index to duplicate
      count - how many items to duplicate

    • clear

      public void clear()
      Removes all values from this deque. This operates in O(1) time.
      Specified by:
      clear in interface PrimitiveCollection<Integer>
      Overrides:
      clear in class IntList

    • iterator

      public IntList.IntListIterator iterator()
      Returns an iterator for the items in the deque. Remove is supported.
      Reuses one of two iterators for this deque. For nested or multithreaded iteration, use IntDequeIterator(IntDeque).
      Specified by:
      iterator in interface PrimitiveCollection<Integer>
      Specified by:
      iterator in interface PrimitiveCollection.OfInt
      Overrides:
      iterator in class IntList
      Returns:
      a IntIterator; use its nextInt() method instead of next()

    • descendingIterator

      public IntList.IntListIterator descendingIterator()
      Returns an iterator over the elements in this deque in reverse sequential order. The elements will be returned in order from last (tail) to first (head).
      Reuses one of two descending iterators for this deque. For nested or multithreaded iteration, use IntDequeIterator(IntDeque, boolean).
      Returns:
      an iterator over the elements in this deque in reverse sequence

    • descendingIterator

      public IntList.IntListIterator descendingIterator(int index)
      Returns an iterator over the elements in this deque in reverse sequential order. The elements will be returned in order from index backwards to first (head).
      Reuses one of two descending iterators for this deque. For nested or multithreaded iteration, use IntDequeIterator(IntDeque, boolean).
      Parameters:
      index - the index to start iterating from in this deque
      Returns:
      an iterator over the elements in this deque in reverse sequence

    • toString

      public String toString()
      Delegates to PrimitiveCollection.OfInt.toString(String, boolean) with a delimiter of ", " and square brackets enabled.
      Overrides:
      toString in class IntList
      Returns:
      the square-bracketed String representation of this IntDeque, with items separated by ", "

    • hashCode

      public int hashCode()
      Specified by:
      hashCode in interface PrimitiveCollection<Integer>
      Overrides:
      hashCode in class IntList

    • equals

      public boolean equals(Object o)
      Using == between each item in order, compares for equality with other subtypes of IntList. If o is not an IntList (and is also not somehow reference-equivalent to this collection), this returns false. This uses the PrimitiveCollection.OfInt.iterator() of both this and o, so if either is in the middle of a concurrent iteration that modifies the collection, this may fail.
      Specified by:
      equals in interface PrimitiveCollection<Integer>
      Overrides:
      equals in class IntList
      Parameters:
      o - object to be compared for equality with this collection
      Returns:
      true if this is equal to o, or false otherwise

    • swap

      public void swap(int first, int second)
      Switches the ordering of positions first and second, without changing any items beyond that.
      Specified by:
      swap in interface Arrangeable
      Specified by:
      swap in interface Ordered.OfInt
      Overrides:
      swap in class IntList
      Parameters:
      first - the first position, must not be negative and must be less than size()
      second - the second position, must not be negative and must be less than size()

    • reverse

      public void reverse()
      Reverses this IntDeque in-place.
      Specified by:
      reverse in interface Arrangeable
      Specified by:
      reverse in interface Ordered.OfInt
      Overrides:
      reverse in class IntList

    • shuffle

      public void shuffle(Random rng)
      Description copied from interface: Ordered.OfInt
      Pseudo-randomly shuffles the order of this Ordered in-place. You can seed rng, the random number generator, with an identical seed to reproduce a shuffle on two Ordered with the same Arrangeable.size().
      Specified by:
      shuffle in interface Arrangeable
      Specified by:
      shuffle in interface Ordered.OfInt
      Overrides:
      shuffle in class IntList
      Parameters:
      rng - any Random class, such as one from juniper

    • sort

      public void sort()
      Sorts this deque in-place using Arrays.sort(int[], int, int) in ascending order.
      Overrides:
      sort in class IntList

    • sort

      public void sort(int from, int to)
      Uses Arrays.sort(int[], int, int) to sort a (clamped) subrange of this deque.
      Overrides:
      sort in class IntList
      Parameters:
      from - first index to use, inclusive
      to - last index to use, exclusive

    • sort

      public void sort(IntComparator comparator)
      Sorts this deque in-place using IntComparators.sort(int[], int, int, IntComparator). This should operate in O(n log(n)) time or less when the internals of the deque are continuous (the head is before the tail in the array). If the internals are not continuous, this takes an additional O(n) step (where n is less than the size of the deque) to rearrange the internals before sorting. You can pass null as the value for comparator, which will make this use the natural ordering for int.
      Specified by:
      sort in interface Ordered.OfInt
      Overrides:
      sort in class IntList
      Parameters:
      comparator - the Comparator to use for int items; may be null to use the natural order of int items when int implements Comparable of int

    • sort

      public void sort(int from, int to, IntComparator comparator)
      Description copied from class: IntList
      Sorts the specified range of elements according to the order induced by the specified comparator using mergesort, or Arrays.sort(int[], int, int) if c is null. This purely uses IntComparators.sort(int[], int, int, IntComparator), and you can see its docs for more information. This clamps from and to to the valid range.
      Overrides:
      sort in class IntList
      Parameters:
      from - the index of the first element (inclusive) to be sorted
      to - the index of the last element (exclusive) to be sorted
      comparator - the comparator to determine the order of the IntList

    • getRandom

      public int getRandom(Random random)
      Gets a randomly selected item from this IntDeque, using the given random number generator. Throws a NoSuchElementException if empty.
      Parameters:
      random - any Random or subclass of it, such as AlternateRandom.
      Returns:
      a randomly selected item from this deque

    • random

      public int random(Random random)
      Gets a randomly selected item from this IntDeque, using the given random number generator.
      Specified by:
      random in interface Ordered.OfInt
      Overrides:
      random in class IntList
      Parameters:
      random - any Random or subclass of it, such as AlternateRandom.
      Returns:
      a randomly selected item from this deque, or the default value if empty

    • with

      public static IntDeque with()
      Constructs an empty deque. This is usually less useful than just using the constructor, but can be handy in some code-generation scenarios when you don't know how many arguments you will have.
      Returns:
      a new deque containing nothing

    • with

      public static IntDeque with(int item)
      Creates a new IntDeque that holds only the given item, but can be resized.
      Parameters:
      item - one int item
      Returns:
      a new IntDeque that holds the given item

    • with

      public static IntDeque with(int item0, int item1)
      Creates a new IntDeque that holds only the given items, but can be resized.
      Parameters:
      item0 - an int item
      item1 - an int item
      Returns:
      a new IntDeque that holds the given items

    • with

      public static IntDeque with(int item0, int item1, int item2)
      Creates a new IntDeque that holds only the given items, but can be resized.
      Parameters:
      item0 - an int item
      item1 - an int item
      item2 - an int item
      Returns:
      a new IntDeque that holds the given items

    • with

      public static IntDeque with(int item0, int item1, int item2, int item3)
      Creates a new IntDeque that holds only the given items, but can be resized.
      Parameters:
      item0 - an int item
      item1 - an int item
      item2 - an int item
      item3 - an int item
      Returns:
      a new IntDeque that holds the given items

    • with

      public static IntDeque with(int item0, int item1, int item2, int item3, int item4)
      Creates a new IntDeque that holds only the given items, but can be resized.
      Parameters:
      item0 - an int item
      item1 - an int item
      item2 - an int item
      item3 - an int item
      item4 - an int item
      Returns:
      a new IntDeque that holds the given items

    • with

      public static IntDeque with(int item0, int item1, int item2, int item3, int item4, int item5)
      Creates a new IntDeque that holds only the given items, but can be resized.
      Parameters:
      item0 - an int item
      item1 - an int item
      item2 - an int item
      item3 - an int item
      item4 - an int item
      item5 - an int item
      Returns:
      a new IntDeque that holds the given items

    • with

      public static IntDeque with(int item0, int item1, int item2, int item3, int item4, int item5, int item6)
      Creates a new IntDeque that holds only the given items, but can be resized.
      Parameters:
      item0 - an int item
      item1 - an int item
      item2 - an int item
      item3 - an int item
      item4 - an int item
      item5 - an int item
      item6 - an int item
      Returns:
      a new IntDeque that holds the given items

    • with

      public static IntDeque with(int item0, int item1, int item2, int item3, int item4, int item5, int item6, int item7)
      Creates a new IntDeque that holds only the given items, but can be resized.
      Parameters:
      item0 - an int item
      item1 - an int item
      item2 - an int item
      item3 - an int item
      item4 - an int item
      item5 - an int item
      item6 - an int item
      item7 - an int item
      Returns:
      a new IntDeque that holds the given items

    • with

      public static IntDeque with(int... varargs)
      Creates a new IntDeque that will hold the items in the given array or varargs. This overload will only be used when an int array is supplied, or if varargs are used and there are 9 or more arguments.
      Parameters:
      varargs - either 0 or more int items, or an array of int
      Returns:
      a new IntDeque that holds the given int items

    • parse

      public static IntDeque parse(String str, String delimiter)
      Calls parse(String, String, boolean) with brackets set to false.
      Parameters:
      str - a String that will be parsed in full
      delimiter - the delimiter between items in str
      Returns:
      a new collection parsed from str

    • parse

      public static IntDeque parse(String str, String delimiter, boolean brackets)
      Creates a new collection and fills it by calling PrimitiveCollection.OfInt.addLegible(String, String, int, int) on either all of str (if brackets is false) or str without its first and last chars (if brackets is true). Each item is expected to be separated by delimiter.
      Parameters:
      str - a String that will be parsed in full (depending on brackets)
      delimiter - the delimiter between items in str
      brackets - if true, the first and last chars in str will be ignored
      Returns:
      a new collection parsed from str

    • parse

      public static IntDeque parse(String str, String delimiter, int offset, int length)
      Creates a new collection and fills it by calling PrimitiveCollection.OfInt.addLegible(String, String, int, int) with the given four parameters as-is.
      Parameters:
      str - a String that will have the given section parsed
      delimiter - the delimiter between items in str
      offset - the first position to parse in str, inclusive
      length - how many chars to parse, starting from offset
      Returns:
      a new collection parsed from str