Kubit/kubit.collections.list/MutableFloatList

MutableFloatList

class MutableFloatList(initialCapacity: Int = 16) : FloatList(source)

MutableFloatList is a MutableList-like collection for Float values. It allows storing and retrieving the elements without boxing. Immutable access is available through its base class FloatList, which has a List-like interface.

This implementation is not thread-safe: if multiple threads access this container concurrently, and one or more threads modify the structure of the list (insertion or removal for instance), the calling code must provide the appropriate synchronization. It is also not safe to mutate during reentrancy -- in the middle of a forEach, for example. However, concurrent reads are safe.

Constructors

MutableFloatList

constructor(initialCapacity: Int = 16)

Creates a MutableFloatList with a capacity of initialCapacity.

Properties

capacity

val capacity: Int

Returns the total number of elements that can be held before the MutableFloatList must grow.

indices

val indices: IntRange

Returns an IntRange of the valid indices for this FloatList.

lastIndex

val lastIndex: Int

Returns the last valid index in the FloatList. This can be -1 when the list is empty.

size

val size: Int

The number of elements in the FloatList.

Functions

add

fun add(element: Float): Boolean

Adds element to the MutableFloatList and returns true.

fun add(index: Int, element: Float)

Adds element to the MutableFloatList at the given index, shifting over any elements at index and after, if any.

addAll

inline fun addAll(elements: FloatArray): Boolean

inline fun addAll(elements: List<Float>): Boolean

inline fun addAll(elements: FloatList): Boolean

Adds all elements to the end of the MutableFloatList and returns true if the MutableFloatList was changed or false if elements was empty.

fun addAll(index: Int, elements: FloatArray): Boolean

fun addAll(index: Int, elements: FloatList): Boolean

Adds all elements to the MutableFloatList at the given index, shifting over any elements at index and after, if any.

all

inline fun all(predicate: (element: Float) -> Boolean): Boolean

Returns true if all elements match the given predicate.

any

inline fun any(): Boolean

Returns true if there's at least one element in the collection.

inline fun any(predicate: (element: Float) -> Boolean): Boolean

Returns true if any of the elements give a true return value for predicate.

atLeast

inline fun atLeast(n: Int, predicate: (Float) -> Boolean): Boolean

Returns true if at least n elements in the list match the given predicate.

atMost

inline fun atMost(n: Int, predicate: (Float) -> Boolean): Boolean

Returns true if at most n elements in the list match the given predicate.

binarySearch

@JvmOverloads

fun binarySearch(element: Int, fromIndex: Int = 0, toIndex: Int = size): Int

Searches this list the specified element in the range defined by fromIndex and toIndex. The list is expected to be sorted into ascending order according to the natural ordering of its elements, otherwise the result is undefined.

chunked

fun chunked(chunkSize: Int): List<FloatList>

Splits this list into chunks of specified size.

chunkedInPlace

fun FloatList.chunkedInPlace(chunkSize: Int): WindowedFloatList

Splits this list into a list of InPlaceFloatSubList each not exceeding the given chunkSize. The last list may have less elements than the given chunkSize.

clear

fun clear()

Removes all elements in the MutableFloatList. The storage isn't released.

contains

operator fun contains(element: Float): Boolean

Returns true if the FloatList contains element or false otherwise.

containsAll

fun containsAll(elements: FloatList): Boolean

Returns true if the FloatList contains all elements in elements or false if one or more are missing.

copy

fun copy(): FloatList

Returns a new list that is a copy of the current list.

count

inline fun count(): Int

Returns the number of elements in this list.

inline fun count(predicate: (element: Float) -> Boolean): Int

Counts the number of elements matching predicate.

distinct

fun distinct(): FloatList

Returns a new list containing only distinct elements from the current list.

drop

fun drop(n: Int): FloatList

Returns a new list containing all elements except first n elements.

dropLast

fun dropLast(n: Int): FloatList

Returns a new list containing all elements except last n elements.

dropLastWhile

inline fun dropLastWhile(predicate: (Float) -> Boolean): FloatList

Returns a new FloatList containing all elements except the last elements that satisfy the given predicate.

dropWhile

inline fun dropWhile(predicate: (Float) -> Boolean): FloatList

Returns a new list containing all elements except the first elements that satisfy the given predicate.

elementAt

fun elementAt(index: Int): Float

Returns the element at the given index or throws IndexOutOfBoundsException if the index is out of bounds of this collection.

elementAtOrElse

inline fun elementAtOrElse(index: Int, defaultValue: (index: Int) -> Float): Float

Returns the element at the given index or defaultValue if index is out of bounds of the collection.

ensureCapacity

fun ensureCapacity(capacity: Int)

Ensures that there is enough space to store capacity elements in the MutableFloatList.

equals

open operator override fun equals(other: Any?): Boolean

Returns true if other is a FloatList and the contents of this and other are the same.

filter

inline fun filter(predicate: (Float) -> Boolean): FloatList

Returns a list containing only elements matching the given predicate.

first

fun first(): Float

Returns the first element in the FloatList or throws a NoSuchElementException if it isEmpty.

inline fun first(predicate: (element: Float) -> Boolean): Float

Returns the first element in the FloatList for which predicate returns true or throws NoSuchElementException if nothing matches.

fold

inline fun <R> fold(initial: R, operation: (acc: R, element: Float) -> R): R

Accumulates values, starting with initial, and applying operation to each element in the FloatList in order.

foldIndexed

inline fun <R> foldIndexed(initial: R, operation: (index: Int, acc: R, element: Float) -> R): R

Accumulates values, starting with initial, and applying operation to each element in the FloatList in order.

foldRight

inline fun <R> foldRight(initial: R, operation: (element: Float, acc: R) -> R): R

Accumulates values, starting with initial, and applying operation to each element in the FloatList in reverse order.

foldRightIndexed

inline fun <R> foldRightIndexed(initial: R, operation: (index: Int, element: Float, acc: R) -> R): R

Accumulates values, starting with initial, and applying operation to each element in the FloatList in reverse order.

forEach

inline fun forEach(block: (element: Float) -> Unit)

Calls block for each element in the FloatList, in order.

forEachChunk

inline fun FloatList.forEachChunk(chunkSize: Int, action: (InPlaceFloatSubList) -> Unit)

Iterates through the windowed chunks of this collection with given chunkSize, where window step is equals to chunkSize and calls action on each chunk.

forEachChunkIndexed

inline fun FloatList.forEachChunkIndexed(chunkSize: Int, action: (index: Int, InPlaceFloatSubList) -> Unit)

Iterates through the windowed chunks of this collection with given chunkSize, where window step is equals to chunkSize and calls action on each chunk with its index.

forEachIndexed

inline fun forEachIndexed(block: (index: Int, element: Float) -> Unit)

Calls block for each element in the FloatList along with its index, in order.

forEachReversed

inline fun forEachReversed(block: (element: Float) -> Unit)

Calls block for each element in the FloatList in reverse order.

forEachReversedIndexed

inline fun forEachReversedIndexed(block: (index: Int, element: Float) -> Unit)

Calls block for each element in the FloatList along with its index, in reverse order.

forEachWindow

inline fun FloatList.forEachWindow(windowSize: Int, step: Int = 1, partialWindows: Boolean = false, action: (InPlaceFloatSubList) -> Unit)

Iterates through the windows of the list and performs the given action on each window.

forEachWindowIndexed

inline fun FloatList.forEachWindowIndexed(windowSize: Int, step: Int = 1, partialWindows: Boolean = false, action: (index: Int, InPlaceFloatSubList) -> Unit)

Iterates through the windows of the list with their indices and performs the given action on each window.

get

operator fun get(index: Int): Float

Returns the element at the given index or throws IndexOutOfBoundsException if the index is out of bounds of this collection.

hashCode

open override fun hashCode(): Int

Returns a hash code based on the contents of the FloatList.

indexOf

fun indexOf(element: Float): Int

Returns the index of element in the FloatList or -1 if element is not there.

indexOfFirst

inline fun indexOfFirst(predicate: (element: Float) -> Boolean): Int

Returns the index if the first element in the FloatList for which predicate returns true.

indexOfLast

inline fun indexOfLast(predicate: (element: Float) -> Boolean): Int

Returns the index if the last element in the FloatList for which predicate returns true.

isEmpty

inline fun isEmpty(): Boolean

Returns true if the FloatList has no elements in it or false otherwise.

isNotEmpty

inline fun isNotEmpty(): Boolean

Returns true if there are elements in the FloatList or false if it is empty.

joinToString

@JvmOverloads

fun joinToString(separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "..."): String

Creates a String from the elements separated by separator and using prefix before and postfix after, if supplied.

@JvmOverloads

inline fun joinToString(separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", crossinline transform: (Float) -> CharSequence): String

Creates a String from the elements separated by separator and using prefix before and postfix after, if supplied. transform dictates how each element will be represented.

last

fun last(): Float

Returns the last element in the FloatList or throws a NoSuchElementException if it isEmpty.

inline fun last(predicate: (element: Float) -> Boolean): Float

Returns the last element in the FloatList for which predicate returns true or throws NoSuchElementException if nothing matches.

lastIndexOf

fun lastIndexOf(element: Float): Int

Returns the index of the last element in the FloatList that is the same as element or -1 if no elements match.

map

inline fun <R> FloatList.map(transform: (Float) -> R): List<R>

Returns an List containing the results of applying the given transform function to each element in the original FloatList.

inline fun FloatList.map(transform: (Float) -> Double): DoubleList

Returns a DoubleList containing the results of applying the given transform function to each element in the original FloatList.

inline fun FloatList.map(transform: (Float) -> Float): FloatList

Returns a FloatList containing the results of applying the given transform function to each element in the original FloatList.

inline fun FloatList.map(transform: (Float) -> Int): IntList

Returns a IntList containing the results of applying the given transform function to each element in the original FloatList.

inline fun FloatList.map(transform: (Float) -> Long): LongList

Returns a LongList containing the results of applying the given transform function to each element in the original FloatList.

mapIndexed

inline fun <R> FloatList.mapIndexed(transform: (Int, Float) -> R): List<R>

Returns a List containing the results of applying the given transform function to each element and its index in the original FloatList.

inline fun FloatList.mapIndexed(transform: (Int, Float) -> Double): DoubleList

Returns a DoubleList containing the results of applying the given transform function to each element and its index in the original FloatList.

inline fun FloatList.mapIndexed(transform: (Int, Float) -> Float): FloatList

Returns a FloatList containing the results of applying the given transform function to each element and its index in the original FloatList.

inline fun FloatList.mapIndexed(transform: (Int, Float) -> Int): IntList

Returns a IntList containing the results of applying the given transform function to each element and its index in the original FloatList.

inline fun FloatList.mapIndexed(transform: (Int, Float) -> Long): LongList

Returns a LongList containing the results of applying the given transform function to each element and its index in the original FloatList.

minusAssign

inline operator fun minusAssign(element: Float)

remove from the MutableFloatList

operator fun minusAssign(elements: FloatArray)

operator fun minusAssign(elements: FloatList)

Removes all elements from the MutableFloatList.

none

inline fun none(): Boolean

Returns true if the collection has no elements in it.

inline fun none(predicate: (element: Float) -> Boolean): Boolean

Returns true if none of the elements give a true return value for predicate.

orEmpty

fun FloatList?.orEmpty(): FloatList

Returns the FloatList itself if it's not null; otherwise returns an empty FloatList.

plusAssign

inline operator fun plusAssign(element: Float)

add to the MutableFloatList.

inline operator fun plusAssign(elements: FloatArray)

inline operator fun plusAssign(elements: FloatList)

Adds all elements to the end of the MutableFloatList.

remove

fun remove(element: Float): Boolean

Removes element from the MutableFloatList. If element was in the MutableFloatList and was removed, true will be returned, or false will be returned if the element was not found.

removeAll

fun removeAll(elements: FloatArray): Boolean

fun removeAll(elements: FloatList): Boolean

Removes all elements from the MutableFloatList and returns true if anything was removed.

removeAt

fun removeAt(index: Int): Float

Removes the element at the given index and returns it.

removeRange

fun removeRange(start: Int, end: Int)

Removes items from index start (inclusive) to end (exclusive).

retainAll

fun retainAll(elements: FloatArray): Boolean

fun retainAll(elements: FloatList): Boolean

Keeps only elements in the MutableFloatList and removes all other values.

reversed

fun reversed(): FloatList

Returns a new list with all elements in reversed order.

reversedAll

inline fun reversedAll(predicate: (element: Float) -> Boolean): Boolean

Returns true if all elements match the given predicate while iterating in the reverse order.

reversedAny

inline fun reversedAny(predicate: (element: Float) -> Boolean): Boolean

Returns true if any of the elements give a true return value for predicate while iterating in the reverse order.

set

operator fun set(index: Int, element: Float): Float

Sets the value at index to element.

sort

fun sort()

Sorts the MutableFloatList elements in ascending order.

sortDescending

fun sortDescending()

Sorts the MutableFloatList elements in descending order.

sorted

fun sorted(): FloatList

Returns a new list of all elements sorted according to natural sort order.

sortedDescending

fun sortedDescending(): FloatList

Returns a new list of all elements sorted according to descending natural sort order.

sum

fun sum(): Float

Returns the sum of all elements in the list.

sumOf

inline fun sumOf(element: (Float) -> Float): Float

Returns the sum of all elements in the list after transforming them by the given element function.

take

fun take(n: Int): FloatList

Returns a new list containing the first n elements of this list.

takeLast

fun takeLast(n: Int): FloatList

Returns a new list containing the last n elements of this list.

takeLastWhile

inline fun takeLastWhile(predicate: (Float) -> Boolean): FloatList

Returns a new FloatList containing the last elements that satisfy the given predicate.

takeWhile

inline fun takeWhile(predicate: (Float) -> Boolean): FloatList

Returns a new FloatList containing the first elements that satisfy the given predicate.

toFloatArray

fun toFloatArray(): FloatArray

Returns a FloatArray containing all elements from this list in the same order.

toMutableSet

fun toMutableSet(): MutableSet<Float>

Return a MutableSet of all elements. The returned set does NOT guarantee the element iteration order of the list.

toSet

fun toSet(): Set<Float>

Return a Set of all elements. The returned set does NOT guarantee the element iteration order of the list.

toString

open override fun toString(): String

Returns a String representation of the list, surrounded by "[]" and each element separated by ", ".

trim

fun trim(minCapacity: Int = _size)

Reduces the internal storage. If capacity is greater than minCapacity and size, the internal storage is reduced to the maximum of size and minCapacity.

windowedInPlace

fun FloatList.windowedInPlace(windowSize: Int, step: Int = 1, partialWindows: Boolean = false): WindowedFloatList

Returns a WindowedFloatList with the given windowSize sliding by step. Each window is a view into the original list.