Compukters Core/kotlin.collections

Package-level declarations

Types

class ArrayList<T>(initialCapacity: Int = 10) : MutableList<T>

A mutable list backed by an array whose capacity grows as elements are added.

BooleanIterator

abstract class BooleanIterator : Iterator<Boolean>

abstract class ByteIterator : Iterator<Byte>

abstract class CharIterator : Iterator<Char>

interface Collection<out T> : Iterable<T>

abstract class DoubleIterator : Iterator<Double>

abstract class FloatIterator : Iterator<Float>

abstract class IntIterator : Iterator<Int>

interface Iterable<out T>

interface Iterator<out T>

interface List<out T> : Collection<T>

abstract class LongIterator : Iterator<Long>

MutableCollection

interface MutableCollection<T> : Collection<T> , MutableIterable<T>

MutableIterable

interface MutableIterable<out T> : Iterable<T>

MutableIterator

interface MutableIterator<out T> : Iterator<T>

interface MutableList<T> : List<T> , MutableCollection<T>

abstract class ShortIterator : Iterator<Short>

Functions

inline fun <T> Iterable<T>.all(predicate: (T) -> Boolean): Boolean

Returns true when every element matches predicate.

inline fun <T> Iterable<T>.any(predicate: (T) -> Boolean): Boolean

Returns true when at least one element matches predicate.

operator fun <T> Iterable<T>.contains(element: T): Boolean

Checks whether this iterable has an element equal to element.

external fun <T> Array<out T>.copyInto(destination: Array<T>, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): Array<T>

external fun BooleanArray.copyInto(destination: BooleanArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): BooleanArray

external fun ByteArray.copyInto(destination: ByteArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): ByteArray

external fun CharArray.copyInto(destination: CharArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): CharArray

external fun DoubleArray.copyInto(destination: DoubleArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): DoubleArray

external fun FloatArray.copyInto(destination: FloatArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): FloatArray

external fun IntArray.copyInto(destination: IntArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): IntArray

external fun LongArray.copyInto(destination: LongArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): LongArray

external fun ShortArray.copyInto(destination: ShortArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): ShortArray

external fun UByteArray.copyInto(destination: UByteArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): UByteArray

external fun UIntArray.copyInto(destination: UIntArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): UIntArray

external fun ULongArray.copyInto(destination: ULongArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): ULongArray

external fun UShortArray.copyInto(destination: UShortArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size): UShortArray

Copies this range into destination, supporting overlapping ranges, and returns it.

external fun <T> Array<T>.copyOf(): Array<T>

external fun BooleanArray.copyOf(): BooleanArray

external fun ByteArray.copyOf(): ByteArray

external fun CharArray.copyOf(): CharArray

external fun DoubleArray.copyOf(): DoubleArray

external fun FloatArray.copyOf(): FloatArray

external fun IntArray.copyOf(): IntArray

external fun LongArray.copyOf(): LongArray

external fun ShortArray.copyOf(): ShortArray

external fun UByteArray.copyOf(): UByteArray

external fun UIntArray.copyOf(): UIntArray

external fun ULongArray.copyOf(): ULongArray

external fun UShortArray.copyOf(): UShortArray

Returns a new array containing the same elements.

external fun <T> Array<T>.copyOf(newSize: Int): Array<T?>

Returns a resized copy, padding extra elements with null.

external fun BooleanArray.copyOf(newSize: Int): BooleanArray

Returns a resized copy, padding extra elements with false.

external fun ByteArray.copyOf(newSize: Int): ByteArray

external fun DoubleArray.copyOf(newSize: Int): DoubleArray

external fun FloatArray.copyOf(newSize: Int): FloatArray

external fun IntArray.copyOf(newSize: Int): IntArray

external fun LongArray.copyOf(newSize: Int): LongArray

external fun ShortArray.copyOf(newSize: Int): ShortArray

external fun UByteArray.copyOf(newSize: Int): UByteArray

external fun UIntArray.copyOf(newSize: Int): UIntArray

external fun ULongArray.copyOf(newSize: Int): ULongArray

external fun UShortArray.copyOf(newSize: Int): UShortArray

Returns a resized copy, padding extra elements with zero.

external fun CharArray.copyOf(newSize: Int): CharArray

Returns a resized copy, padding extra elements with zero characters.

external fun <T> Array<T>.copyOfRange(fromIndex: Int, toIndex: Int): Array<T>

external fun <T> emptyList(): List<T>

Creates a new empty ArrayList exposed through the read-only List interface.

inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T>

Returns a list containing elements matching predicate, in their original iteration order.

fun <T : Any> Iterable<T?>.filterNotNull(): List<T>

Returns a list of non-null elements in their original iteration order.

inline fun <T, C : MutableCollection<in T>> Iterable<T>.filterTo(destination: C, predicate: (T) -> Boolean): C

Appends matching elements to destination in iteration order and returns that destination.

inline fun <T> Iterable<T>.find(predicate: (T) -> Boolean): T?

Returns the first matching element, or null when no element matches predicate.

fun <T> Iterable<T>.first(): T

Returns the first element, throwing NoSuchElementException when empty.

inline fun <T> Iterable<T>.first(predicate: (T) -> Boolean): T

Returns the first matching element, throwing NoSuchElementException when no element matches.

fun <T> Iterable<T>.firstOrNull(): T?

Returns the first element, or null when this iterable is empty.

fun <T> List<T>.firstOrNull(): T?

Returns the first element, or null when this list is empty.

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

Returns the first matching element, or null when no element matches predicate.

inline fun <T, R> Iterable<T>.fold(initial: R, operation: (R, T) -> R): R

Accumulates elements in iteration order, passing the current result and each element to operation. Returns initial unchanged when this iterable is empty.

inline fun <T> Iterable<T>.forEach(action: (T) -> Unit)

Calls action for each element in iteration order.

inline fun <T> Iterable<T>.forEachIndexed(action: (Int, T) -> Unit)

Calls action for each element and its zero-based index in iteration order.

fun <T> List<T>.getOrNull(index: Int): T?

Returns the element at index, or null when the index is outside this list.

fun <T> Iterable<T>.indexOf(element: T): Int

Returns the index of the first equal element, or -1 when no element matches.

fun <T> Collection<T>.isNotEmpty(): Boolean

Checks whether this collection has at least one element.

fun <T> Iterable<T>.lastIndexOf(element: T): Int

Returns the index of the last equal element, or -1 when no element matches.

fun <T> Iterable<T>.lastOrNull(): T?

Returns the last element, or null when this iterable is empty.

fun <T> List<T>.lastOrNull(): T?

Returns the last element, or null when this list is empty.

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

Returns the last matching element after traversing this iterable in iteration order.

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

Returns the last matching element, searching from the end until a match is found.

external fun <T> listOf(vararg elements: T): List<T>

Creates an ArrayList from the given elements and exposes it through the read-only List interface.

inline fun <T, R> Collection<T>.map(transform: (T) -> R): List<R>

Maps a collection in iteration order, reserving its known size for the result.

inline fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R>

Returns a list containing transform applied once to each element in iteration order.

inline fun <T, R : Any> Iterable<T>.mapNotNull(transform: (T) -> R?): List<R>

Applies transform once per element in iteration order and retains only non-null results.

inline fun <T, R : Any, C : MutableCollection<in R>> Iterable<T>.mapNotNullTo(destination: C, transform: (T) -> R?): C

Appends non-null transformed elements to destination and returns that destination.

inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.mapTo(destination: C, transform: (T) -> R): C

Appends transformed elements to destination in iteration order and returns that destination.

inline fun <T> Iterable<T>.none(predicate: (T) -> Boolean): Boolean

Returns true when no element matches predicate.