Compukters Core/kotlin.collections/ArrayList

ArrayList

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

A mutable ordered list backed by an array that grows as elements are added.

Duplicates are retained. Nullable element types may store null. A List view refers to the same object and observes later mutations. Removed storage slots are cleared; clear retains backing capacity for reuse. Insertion and removal shift following elements.

Adding, removing, or calling clear invalidates existing iterators, except for removal through that iterator itself. set replaces an element without changing size or invalidating iterators. Allocation uses the VM heap budget.

Parameters

initialCapacity

initial backing capacity, not the list's initial size.

Type Parameters

element type.

Throws

IllegalArgumentException

if initialCapacity is negative.

Constructors

ArrayList

constructor(initialCapacity: Int = 10)

creates an empty list with the requested non-negative capacity; the default is 10.

Properties

isEmpty

open override val isEmpty: Boolean

size

open override var size: Int

Number of elements currently stored in this list.

Functions

add

open override fun add(element: T): Boolean

Appends element to the end of this list, growing the backing array when needed.

open override fun add(index: Int, element: T)

Inserts element at index, shifting following elements one position to the right.

addAll

abstract fun addAll(p0: Collection<out T?>?): Boolean

abstract fun addAll(p0: Int, p1: Collection<out T?>?): Boolean

all

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

Returns true when every element matches predicate.

any

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

Returns true when at least one element matches predicate.

asSequence

fun <T> Iterable<T>.asSequence(): Sequence<T>

Borrows this iterable as a lazy sequence without traversing or copying it. Each traversal requests a new source iterator; later mutations and invalidation follow the iterable's own contract. Wrappers and iterators use ordinary managed heap quotas.

clear

open override fun clear()

Removes all elements while retaining backing capacity for reuse.

contains

open operator override fun contains(element: T): Boolean

Checks whether this list contains an element equal to element.

contains

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

Checks whether this iterable has an element equal to element.

containsAll

abstract fun containsAll(p0: Collection<*>?): Boolean

equals

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

Compares elements using the list's ordering rules and nullable generic equality.

filter

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

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

filterNotNull

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

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

filterTo

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

Appends matching elements to destination in iteration order.

find

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

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

first

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.

firstOrNull

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.

fold

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

Accumulates elements in iteration order.

forEach

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

Calls action for each element in iteration order.

forEachIndexed

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

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

get

open operator override fun get(index: Int): T

Returns the element at index without removing it.

getOrNull

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

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

hashCode

open override fun hashCode(): Int

Combines element hashes with ordinary Int overflow; null contributes zero.

indexOf

open override fun indexOf(element: T): Int

Returns the first index whose element equals element, or -1 when no match exists.

indexOf

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

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

isEmpty

open override fun isEmpty(): Boolean

Checks whether this list has no elements.

isNotEmpty

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

Checks whether this collection contains at least one element.

iterator

open operator override fun iterator(): MutableIterator<T>

Creates a new mutable iterator that visits this list in index order.

lastIndexOf

open override fun lastIndexOf(element: T): Int

Returns the last index whose element equals element, or -1 when no match exists.

lastIndexOf

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

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

lastOrNull

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 element satisfying predicate, or null when no element matches.

listIterator

abstract fun listIterator(): ListIterator<T?>?

abstract fun listIterator(p0: Int): ListIterator<T?>?

map

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

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.

mapNotNull

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.

mapNotNullTo

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 in iteration order.

mapTo

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.

none

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

Returns true when no element matches predicate.

remove

open override fun remove(element: T): Boolean

Removes the first element equal to element.

removeAll

abstract fun removeAll(p0: Collection<*>?): Boolean

removeAt

open override fun removeAt(index: Int): T

Removes the element at index and shifts following elements one position to the left.

retainAll

abstract fun retainAll(p0: Collection<*>?): Boolean

set

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

Replaces the element at index and returns the previous element.

subList

abstract fun subList(p0: Int, p1: Int): List<T?>?

sum

fun Iterable<Byte>.sum(): Int

Numeric accumulation traverses once in iteration order without an intermediate collection. Empty iterables return positive numeric zero. Integer arithmetic wraps at the result width; Float/Double addition retains ordinary rounding, infinities and NaN. Byte/Short widen to Int; UByte/UShort widen to UInt. Iterator failures propagate unchanged.

fun Iterable<Double>.sum(): Double

fun Iterable<Float>.sum(): Float

fun Iterable<Int>.sum(): Int

fun Iterable<Long>.sum(): Long

fun Iterable<Short>.sum(): Int

fun Iterable<UByte>.sum(): UInt

fun Iterable<UInt>.sum(): UInt

fun Iterable<ULong>.sum(): ULong

fun Iterable<UShort>.sum(): UInt

sumOf

inline fun <T> Iterable<T>.sumOf(selector: (T) -> Double): Double

Sums selector once per element in iteration order, returning Double zero when empty. No collection is allocated; selector/iterator exceptions and inline non-local returns propagate. Addition retains ordinary Double rounding, infinities and NaN.

inline fun <T> Iterable<T>.sumOf(selector: (T) -> Int): Int

Sums selector once per element in iteration order, returning Int zero when empty. No collection is allocated; selector/iterator exceptions and inline non-local returns propagate. Addition uses ordinary wrapping Int arithmetic.

inline fun <T> Iterable<T>.sumOf(selector: (T) -> Long): Long

Sums selector once per element in iteration order, returning Long zero when empty. No collection is allocated; selector/iterator exceptions and inline non-local returns propagate. Addition uses ordinary wrapping Long arithmetic.

inline fun <T> Iterable<T>.sumOf(selector: (T) -> UInt): UInt

Sums selector once per element in iteration order, returning UInt zero when empty. No collection is allocated; selector/iterator exceptions and inline non-local returns propagate. Addition uses ordinary wrapping UInt arithmetic.

inline fun <T> Iterable<T>.sumOf(selector: (T) -> ULong): ULong

Sums selector once per element in iteration order, returning ULong zero when empty. No collection is allocated; selector/iterator exceptions and inline non-local returns propagate. Addition uses ordinary wrapping ULong arithmetic.

toString

open override fun toString(): String

Formats elements in brackets; a direct self reference uses (this Collection).

ArrayList

Parameters

Type Parameters

See also

Throws

Constructors

Properties

Functions