MutableVector

fun add(element: T): Boolean

Adds element to the MutableVector and returns true.

fun add(index: Int, element: T): Unit

Adds element to the MutableVector at the given index, shifting over any elements that are in the way.

fun addAll(elements: Array<T>): Boolean

Adds all elements to the end of the MutableVector and returns true if the MutableVector was changed.

fun addAll(elements: Collection<T>): Boolean

Adds all elements to the end of the MutableVector and returns true if the MutableVector was changed.

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

Adds all elements to the end of the MutableVector and returns true if the MutableVector was changed.

inline fun addAll(elements: MutableVector<T>): Boolean

Adds all elements to the end of the MutableVector and returns true if the MutableVector was changed.

fun addAll(index: Int, elements: Collection<T>): Boolean

Adds all elements to the MutableVector at the given index, shifting over any elements that are in the way.

fun addAll(index: Int, elements: List<T>): Boolean

Adds all elements to the MutableVector at the given index, shifting over any elements that are in the way.

fun addAll(index: Int, elements: MutableVector<T>): Boolean

Adds all elements to the MutableVector at the given index, shifting over any elements that are in the way.

inline fun any(predicate: (T) -> Boolean): Boolean

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

fun asMutableList(): MutableList<T>

Returns MutableList interface access to the MutableVector.

fun clear(): Unit

Removes all elements in the MutableVector.

operator fun contains(element: T): Boolean

Returns true if the MutableVector contains element or false otherwise.

fun containsAll(elements: Collection<T>): Boolean

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

fun containsAll(elements: List<T>): Boolean

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

fun containsAll(elements: MutableVector<T>): Boolean

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

fun contentEquals(other: MutableVector<T>): Boolean

Returns true if the contents of the MutableVector are the same or false if there is any difference. This uses equality comparisons on each element rather than reference equality.

inline fun ensureCapacity(capacity: Int): Unit

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

fun first(): T

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

inline fun first(predicate: (T) -> Boolean): T

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

inline fun firstOrNull(): T?

Returns the first element in the MutableVector or null if it isEmpty.

inline fun firstOrNull(predicate: (T) -> Boolean): T?

Returns the first element in the MutableVector for which predicate returns true or returns null if nothing matches.

inline fun <R : Any?> fold(initial: R, operation: (acc, T) -> R): R

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

inline fun <R : Any?> foldIndexed(initial: R, operation: (index: Int, acc, T) -> R): R

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

inline fun <R : Any?> foldRight(initial: R, operation: (T, acc) -> R): R

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

inline fun <R : Any?> foldRightIndexed(initial: R, operation: (index: Int, T, acc) -> R): R

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

inline fun forEach(block: (T) -> Unit): Unit

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

inline fun forEachIndexed(block: (Int, T) -> Unit): Unit

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

inline fun forEachReversed(block: (T) -> Unit): Unit

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

inline fun forEachReversedIndexed(block: (Int, T) -> Unit): Unit

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

inline operator fun get(index: Int): T

Returns the element at the given index.

fun indexOf(element: T): Int

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

inline fun indexOfFirst(predicate: (T) -> Boolean): Int

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

inline fun indexOfLast(predicate: (T) -> Boolean): Int

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

inline fun isEmpty(): Boolean

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

inline fun isNotEmpty(): Boolean

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

fun last(): T

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

inline fun last(predicate: (T) -> Boolean): T

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

fun lastIndexOf(element: T): Int

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

inline fun lastOrNull(): T?

Returns the last element in the MutableVector or null if it isEmpty.

inline fun lastOrNull(predicate: (T) -> Boolean): T?

Returns the last element in the MutableVector for which predicate returns true or returns null if nothing matches.

inline fun <R : Any?> map(transform: (T) -> R): Array<R>

Returns an Array of results of transforming each element in the MutableVector. The Array will be the same size as this.

inline fun <R : Any?> mapIndexed(transform: (index: Int, T) -> R): Array<R>

Returns an Array of results of transforming each element in the MutableVector. The Array will be the same size as this.

inline fun <R : Any?> mapIndexedNotNull(transform: (index: Int, T) -> R?): MutableVector<R>

Returns an MutableVector of results of transforming each element in the MutableVector, excluding those transformed values that are null.

inline fun <R : Any?> mapNotNull(transform: (T) -> R?): MutableVector<R>

Returns an MutableVector of results of transforming each element in the MutableVector, excluding those transformed values that are null.

inline operator fun minusAssign(element: T): Unit

remove from the MutableVector

inline operator fun plusAssign(element: T): Unit

add to the MutableVector.

fun remove(element: T): Boolean

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

fun removeAll(elements: Collection<T>): Boolean

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

fun removeAll(elements: List<T>): Boolean

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

fun removeAll(elements: MutableVector<T>): Boolean

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

fun removeAt(index: Int): T

Removes the element at the given index and returns it.

inline fun removeIf(predicate: (T) -> Boolean): Unit

Removes items that satisfy predicate

fun removeRange(start: Int, end: Int): Unit

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

fun retainAll(elements: Collection<T>): Boolean

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

inline fun reversedAny(predicate: (T) -> Boolean): Boolean

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

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

Sets the value at index to element.

fun sortWith(comparator: Comparator<T>): Unit

Sorts the MutableVector using comparator to order the items.

inline fun sumBy(selector: (T) -> Int): Int

Returns the sum of all values produced by selector for each element in the MutableVector.

val indices: IntRange

Returns an IntRange of the valid indices for this MutableVector.

val lastIndex: Int

Returns the last valid index in the MutableVector.

val size: Int

The number of elements in the MutableVector.