Package com.github.tommyettinger.ds

Class DoubleList

java.lang.Object
com.github.tommyettinger.ds.DoubleList
All Implemented Interfaces:
Arrangeable, Ordered.OfDouble, PrimitiveCollection<Double>, PrimitiveCollection.OfDouble
Direct Known Subclasses:
DoubleBag, DoubleDeque
public class DoubleList extends Object implements PrimitiveCollection.OfDouble, Ordered.OfDouble, Arrangeable
A resizable, insertion-ordered double list. Primitive-backed, so it avoids the boxing that occurs with an ArrayList of Double. This tries to imitate most of the List interface, though it can't implement it without boxing its items. Has a primitive iterator accessible via iterator().
See Also:

  • Field Details

  • Constructor Details

    • DoubleList

      public DoubleList()
      Creates an ordered list with a capacity of 10.

    • DoubleList

      public DoubleList(int capacity)
      Creates an ordered list with the specified capacity.
      Parameters:
      capacity - Any elements added beyond this will cause the backing array to be grown.

    • DoubleList

      @Deprecated public DoubleList(boolean ordered, int capacity)
      Deprecated.
      DoubleList is always ordered; for an unordered list use DoubleBag
      Creates an ordered list with the specified capacity.
      Parameters:
      ordered - ignored; for an unordered list use DoubleBag
      capacity - Any elements added beyond this will cause the backing array to be grown.

    • DoubleList

      public DoubleList(DoubleList list)
      Creates a new list containing the elements in the given list. The new list will be ordered. The capacity is set to the number of elements, so any subsequent elements added will cause the backing array to be grown.
      Parameters:
      list - another DoubleList (or DoubleBag) to copy from

    • DoubleList

      public DoubleList(double[] array)
      Creates a new list containing the elements in the specified array. The capacity is set to the number of elements, so any subsequent elements added will cause the backing array to be grown.
      Parameters:
      array - a double array to copy from

    • DoubleList

      public DoubleList(double[] array, int startIndex, int count)
      Creates a new list containing the elements in the specified array. The capacity is set to the number of elements, so any subsequent elements added will cause the backing array to be grown.
      Parameters:
      array - a non-null double array to add to this list
      startIndex - the first index in array to use
      count - how many items to use from array

    • DoubleList

      @Deprecated public DoubleList(boolean ordered, double[] array, int startIndex, int count)
      Deprecated.
      DoubleList is always ordered; for an unordered list use DoubleBag
      Creates a new list containing the elements in the specified array. The capacity is set to the number of elements, so any subsequent elements added will cause the backing array to be grown.
      Parameters:
      ordered - ignored; for an unordered list use DoubleBag
      array - a non-null double array to add to this list
      startIndex - the first index in array to use
      count - how many items to use from array

    • DoubleList

      public DoubleList(PrimitiveCollection.OfDouble coll)
      Creates a new list containing the items in the specified PrimitiveCollection.OfDouble.
      Parameters:
      coll - a primitive collection that will have its contents added to this

    • DoubleList

      public DoubleList(DoubleIterator coll)
      Creates a new instance containing the items in the specified iterator.
      Parameters:
      coll - an iterator that will have its remaining contents added to this

    • DoubleList

      public DoubleList(Ordered.OfDouble other)
      Copies the given Ordered.OfDouble into a new DoubleList.
      Parameters:
      other - another Ordered.OfDouble that will have its contents copied into this

    • DoubleList

      public DoubleList(Ordered.OfDouble other, int offset, int count)
      Creates a new list by copying count items from the given Ordered, starting at offset in that Ordered, into this.
      Parameters:
      other - another Ordered.OfDouble
      offset - the first index in other's ordering to draw an item from
      count - how many items to copy from other

  • Method Details

    • keepsOrder

      public boolean keepsOrder()
      Returns true if this implementation retains order, which it does.
      Returns:
      true

    • size

      public int size()
      Description copied from interface: Arrangeable
      Returns the number of elements in this Arrangeable. Often this is shared with Collection.size(), but isn't always.
      Specified by:
      size in interface Arrangeable
      Specified by:
      size in interface PrimitiveCollection<Double>
      Returns:
      the number of elements in this Arrangeable

    • add

      public boolean add(double value)
      Specified by:
      add in interface PrimitiveCollection.OfDouble

    • add

      public void add(double value1, double value2)

    • add

      public void add(double value1, double value2, double value3)

    • add

      public void add(double value1, double value2, double value3, double value4)

    • addAll

      public boolean addAll(DoubleList list)

    • addAll

      public boolean addAll(DoubleList list, int offset, int count)

    • addAll

      public boolean addAll(Ordered.OfDouble other, int offset, int count)
      Adds up to count items, starting from offset, in the Ordered.OfDouble other to this list, inserting at the end of the iteration order.
      Parameters:
      other - a non-null Ordered.OfDouble
      offset - the first index in other to use
      count - how many indices in other to use
      Returns:
      true if this is modified by this call, as addAll(DoubleList) does

    • addAll

      public boolean addAll(int insertionIndex, Ordered.OfDouble other, int offset, int count)
      Adds up to count items, starting from offset, in the Ordered.OfDouble other to this list, inserting starting at insertionIndex in the iteration order.
      Parameters:
      insertionIndex - where to insert into the iteration order
      other - a non-null Ordered.OfDouble
      offset - the first index in other to use
      count - how many indices in other to use
      Returns:
      true if this is modified by this call, as addAll(DoubleList) does

    • addAll

      public boolean addAll(double... array)
      Specified by:
      addAll in interface PrimitiveCollection.OfDouble

    • addAll

      public boolean addAll(double[] array, int offset, int length)
      Specified by:
      addAll in interface PrimitiveCollection.OfDouble

    • get

      public double get(int index)

    • set

      public void set(int index, double value)

    • plus

      public void plus(int index, double value)

    • plus

      public DoubleList plus(double value)
      Adds value to each item in this DoubleList, 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 DoubleList).
      Parameters:
      value - each item in this will be assigned item + value
      Returns:
      this for chaining and Kotlin compatibility

    • times

      public void times(int index, double value)

    • times

      public DoubleList times(double value)
      Multiplies each item in this DoubleList 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 DoubleList).
      Parameters:
      value - each item in this will be assigned item * value
      Returns:
      this for chaining and Kotlin compatibility

    • minus

      public void minus(int index, double value)

    • minus

      public DoubleList minus(double value)
      Takes each item in this DoubleList 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 DoubleList).
      Parameters:
      value - each item in this will be assigned item - value
      Returns:
      this for chaining and Kotlin compatibility

    • div

      public void div(int index, double value)

    • div

      public DoubleList div(double value)
      Divides each item in this DoubleList 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 DoubleList).
      Parameters:
      value - each item in this will be assigned item / value
      Returns:
      this for chaining and Kotlin compatibility

    • rem

      public void rem(int index, double value)

    • rem

      public DoubleList rem(double value)
      Gets the remainder of each item in this DoubleList 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 DoubleList).
      Parameters:
      value - each item in this will be assigned item % value
      Returns:
      this for chaining and Kotlin compatibility

    • insert

      public void insert(int index, double value)

    • 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.
      Parameters:
      index - the first index to duplicate
      count - how many items to duplicate

    • order

      public DoubleList order()
      Returns this DoubleList, since it is its own order. This is only here to satisfy the Ordered.OfDouble interface.
      Specified by:
      order in interface Ordered.OfDouble
      Returns:
      this DoubleList

    • swap

      public void swap(int first, int second)
      Description copied from interface: Ordered.OfDouble
      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.OfDouble
      Parameters:
      first - the first position, must not be negative and must be less than Arrangeable.size()
      second - the second position, must not be negative and must be less than Arrangeable.size()

    • contains

      public boolean contains(double value)
      Specified by:
      contains in interface PrimitiveCollection.OfDouble

    • containsAll

      public boolean containsAll(DoubleList other)
      Returns true if this DoubleList contains, at least once, every item in other; otherwise returns false.
      Parameters:
      other - an DoubleList
      Returns:
      true if this contains every item in other, otherwise false

    • indexOf

      public int indexOf(double value)
      Returns the first index in this list that contains the specified value, or -1 if it is not present.
      Parameters:
      value - a double value to search for
      Returns:
      the first index of the given value, or -1 if it is not present

    • lastIndexOf

      public int lastIndexOf(double value)
      Returns the last index in this list that contains the specified value, or -1 if it is not present.
      Parameters:
      value - a double value to search for
      Returns:
      the last index of the given value, or -1 if it is not present

    • remove

      public boolean remove(double value)
      Removes the first occurrence of value from this DoubleList, returning true if anything was removed. Otherwise, this returns false.
      Specified by:
      remove in interface PrimitiveCollection.OfDouble
      Parameters:
      value - the value to (attempt to) remove
      Returns:
      true if a value was removed, false if the DoubleList is unchanged

    • removeAt

      public double removeAt(int index)
      Removes and returns the item at the specified index. Note that this is equivalent to List.remove(int), but can't have that name because we also have remove(double) that removes a value, rather than an index.
      Parameters:
      index - the index of the item to remove and return
      Returns:
      the removed item

    • removeRange

      public void removeRange(int start, int end)
      Removes the items between the specified start index, inclusive, and end index, exclusive. Note that this takes different arguments than some other range-related methods; this needs a start index and an end index, rather than a count of items. This matches the behavior in the JDK collections.
      Specified by:
      removeRange in interface Ordered.OfDouble
      Parameters:
      start - the first index to remove, inclusive
      end - the last index (after what should be removed), exclusive

    • removeAll

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

    • removeEach

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

    • retainAll

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

    • replaceAll

      public void replaceAll(com.github.tommyettinger.function.DoubleToDoubleFunction operator)
      Replaces each element of this list with the result of applying the given operator to that element.
      Parameters:
      operator - a DoubleToDoubleFunction (a functional interface defined in funderby)

    • replaceFirst

      public boolean replaceFirst(double find, double 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.
      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(double find, double 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.
      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

    • replaceFirst

      public boolean replaceFirst(double find, double replace, double tolerance)
      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. Takes a tolerance to permit some doubleing-point imprecision in the search.
      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(double find, double replace, double tolerance)
      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. Takes a tolerance to permit some doubleing-point imprecision in the search.
      Parameters:
      find - the item to search for
      replace - the item to replace find with, if possible
      tolerance - how much an item can be different from find and still be replaced
      Returns:
      the number of replacements that occurred; 0 if nothing was found or replaced

    • replaceFirstNaN

      public boolean replaceFirstNaN(double replace)
      Replaces the first occurrence of NaN with replace. Returns true if it performed the replacement, or false if there was nothing to replace.
      Parameters:
      replace - the item to replace NaN with, if possible
      Returns:
      true if this changed, or false otherwise

    • replaceAllNaN

      public int replaceAllNaN(double replace)
      Replaces every occurrence of NaN with replace. Returns the number of changed items, which is 0 if nothing was found.
      Parameters:
      replace - the item to replace NaN with, if possible
      Returns:
      the number of replacements that occurred; 0 if nothing was found or replaced

    • pop

      public double pop()
      Removes and returns the last item.
      Returns:
      the last item, removed from this

    • peek

      public double peek()
      Returns the last item.
      Returns:
      the last item, without modifying this

    • first

      public double first()
      Returns the first item.
      Specified by:
      first in interface PrimitiveCollection.OfDouble
      Returns:
      the first item, without modifying this

    • notEmpty

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

    • isEmpty

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

    • clear

      public void clear()
      Effectively removes all items from this DoubleList. This is done simply by setting size to 0; because a double item isn't a reference, it doesn't need to be set to null.
      Specified by:
      clear in interface PrimitiveCollection<Double>

    • shrink

      public double[] shrink()
      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.
      Returns:
      items; this will be a different reference if this resized

    • trimToSize

      public void trimToSize()

    • ensureCapacity

      public double[] ensureCapacity(int additionalCapacity)
      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.
      Returns:
      items; this will be a different reference if this resized

    • setSize

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

    • resize

      protected double[] resize(int newSize)

    • sort

      public void sort()
      Sorts this entire collection using Arrays.sort(double[], int, int) in ascending order.

    • sort

      public void sort(int from, int to)
      Uses Arrays.sort(double[], int, int) to sort a (clamped) subrange of this collection in ascending order.
      Parameters:
      from - the index of the first element (inclusive) to be sorted
      to - the index of the last element (exclusive) to be sorted

    • sort

      public void sort(DoubleComparator c)
      Sorts all elements according to the order induced by the specified comparator using DoubleComparators.sort(double[], int, int, DoubleComparator). If c is null, this instead delegates to sort(), which uses Arrays.sort(double[]), and does not always run in-place.

      This sort is guaranteed to be stable: equal elements will not be reordered as a result of the sort. The sorting algorithm is an in-place mergesort that is significantly slower than a standard mergesort, as its running time is O(n (log n)2), but it does not allocate additional memory; as a result, it can be used as a generic sorting algorithm.

      Specified by:
      sort in interface Ordered.OfDouble
      Parameters:
      c - the comparator to determine the order of the DoubleList

    • sort

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

    • reverse

      public void reverse()
      Description copied from interface: Ordered.OfDouble
      Reverses the order of this Ordered in-place.
      Specified by:
      reverse in interface Arrangeable
      Specified by:
      reverse in interface Ordered.OfDouble

    • shuffle

      public void shuffle(Random random)
      Description copied from interface: Ordered.OfDouble
      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.OfDouble
      Parameters:
      random - any Random class, such as one from juniper

    • truncate

      public void truncate(int newSize)
      Reduces the size of the list to the specified size. If the list is already smaller than the specified size, no action is taken.

    • random

      public double random(Random random)
      Returns a random item from the list, or zero if the list is empty.
      Specified by:
      random in interface Ordered.OfDouble
      Parameters:
      random - a Random or a subclass, such as any from juniper
      Returns:
      a randomly selected item from this, or 0 if this is empty

    • toArray

      public double[] toArray()
      Allocates a new double array with size elements and fills it with the items in this.
      Specified by:
      toArray in interface PrimitiveCollection.OfDouble
      Returns:
      a new double array with the same contents as this

    • toArray

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

    • hashCode

      public int hashCode()
      Specified by:
      hashCode in interface PrimitiveCollection<Double>
      Overrides:
      hashCode in class Object

    • equals

      public boolean equals(Object object)
      Specified by:
      equals in interface PrimitiveCollection<Double>
      Overrides:
      equals in class Object

    • equals

      public boolean equals(Object object, double tolerance)
      Compares double items with the given tolerance for error.

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • iterator

      public DoubleList.DoubleListIterator iterator()
      Returns a Java 8 primitive iterator over the int items in this DoubleList. Iterates in order if keepsOrder() returns true, which it does for a DoubleList but not a DoubleBag.
      This will reuse one of two iterators in this DoubleList; this does not allow nested iteration. Use DoubleListIterator(DoubleList) to nest iterators.
      Specified by:
      iterator in interface PrimitiveCollection<Double>
      Specified by:
      iterator in interface PrimitiveCollection.OfDouble
      Returns:
      a DoubleIterator; use its nextDouble() method instead of next()

    • with

      public static DoubleList with()
      Constructs an empty list. 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 list containing nothing

    • with

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

    • with

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

    • with

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

    • with

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

    • with

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

    • with

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

    • with

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

    • with

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

    • with

      public static DoubleList with(double... varargs)
      Creates a new DoubleList that holds only the given items, but can be resized. This overload will only be used when an array is supplied and the type of the items requested is the component type of the array, or if varargs are used and there are 9 or more arguments.
      Parameters:
      varargs - a double varargs or double array; remember that varargs allocate
      Returns:
      a new DoubleList that holds the given items

    • parse

      public static DoubleList 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 DoubleList parse(String str, String delimiter, boolean brackets)
      Creates a new collection and fills it by calling PrimitiveCollection.OfDouble.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 DoubleList parse(String str, String delimiter, int offset, int length)
      Creates a new collection and fills it by calling PrimitiveCollection.OfDouble.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