Package kotlin.collections
Collection types, such as Iterable, Collection, List, Set, Map and related top-level and extension functions.
Types
AbstractCollection
Provides a skeletal implementation of the read-only Collection interface.
abstract class AbstractCollection<out E> : Collection<E>AbstractIterator
A base class to simplify implementing iterators so that implementations only have to implement computeNext to implement the iterator, calling done when the iteration is complete.
abstract class AbstractIterator<T> : Iterator<T>AbstractList
Provides a skeletal implementation of the read-only List interface.
abstract class AbstractList<out E> :
AbstractCollection<E>,
List<E>AbstractMutableCollection
Provides a skeletal implementation of the MutableCollection interface.
abstract class AbstractMutableCollection<E> :
MutableCollection<E>abstract class AbstractMutableCollection<E> :
MutableCollection<E>,
AbstractCollection<E>abstract class AbstractMutableCollection<E> :
MutableCollection<E>,
AbstractCollection<E>AbstractMutableList
Provides a skeletal implementation of the MutableList interface.
abstract class AbstractMutableList<E> : MutableList<E>abstract class AbstractMutableList<E> :
MutableList<E>,
AbstractList<E>abstract class AbstractMutableList<E> :
AbstractMutableCollection<E>,
MutableList<E>AbstractMutableMap
Provides a skeletal implementation of the MutableMap interface.
abstract class AbstractMutableMap<K, V> : MutableMap<K, V>abstract class AbstractMutableMap<K, V> :
MutableMap<K, V>,
AbstractMap<K, V>abstract class AbstractMutableMap<K, V> :
AbstractMap<K, V>,
MutableMap<K, V>AbstractMutableSet
Provides a skeletal implementation of the MutableSet interface.
abstract class AbstractMutableSet<E> : MutableSet<E>abstract class AbstractMutableSet<E> :
MutableSet<E>,
AbstractSet<E>abstract class AbstractMutableSet<E> :
AbstractMutableCollection<E>,
MutableSet<E>AbstractSet
Provides a skeletal implementation of the read-only Set interface.
abstract class AbstractSet<out E> :
AbstractCollection<E>,
Set<E>ArrayDeque
Resizable-array implementation of the deque data structure.
class ArrayDeque<E> : AbstractMutableList<E>ArrayList
Provides a MutableList implementation, which uses a resizable array as its backing storage.
class ArrayList<E> : MutableList<E>, RandomAccesstypealias ArrayList<E> = ArrayList<E>open class ArrayList<E> :
AbstractMutableList<E>,
MutableList<E>,
RandomAccessclass ArrayList<E> :
MutableList<E>,
RandomAccess,
AbstractMutableList<E>BooleanIterator
An iterator over a sequence of values of type Boolean.
abstract class BooleanIterator : Iterator<Boolean>ByteIterator
An iterator over a sequence of values of type Byte.
abstract class ByteIterator : Iterator<Byte>CharIterator
An iterator over a sequence of values of type Char.
abstract class CharIterator : Iterator<Char>Collection
A generic collection of elements. Methods in this interface support only read-only access to the collection; read/write access is supported through the MutableCollection interface.
interface Collection<out E> : Iterable<E>DoubleIterator
An iterator over a sequence of values of type Double.
abstract class DoubleIterator : Iterator<Double>FloatIterator
An iterator over a sequence of values of type Float.
abstract class FloatIterator : Iterator<Float>Grouping
Represents a source of elements with a keyOf function, which can be applied to each element to get its key.
interface Grouping<T, out K>HashMap
Hash table based implementation of the MutableMap interface.
class HashMap<K, V> : MutableMap<K, V>typealias HashMap<K, V> = HashMap<K, V>open class HashMap<K, V> :
AbstractMutableMap<K, V>,
MutableMap<K, V>HashSet
The implementation of the MutableSet interface, backed by a InternalMap implementation.
class HashSet<E> : MutableSet<E>typealias HashSet<E> = HashSet<E>open class HashSet<E> : AbstractMutableSet<E>, MutableSet<E>class HashSet<E> :
MutableSet<E>,
KonanSet<E>,
AbstractMutableSet<E>IndexedValue
Data class representing a value from a collection or sequence, along with its index in that collection or sequence.
data class IndexedValue<out T>IntIterator
An iterator over a sequence of values of type Int.
abstract class IntIterator : Iterator<Int>Iterable
Classes that inherit from this interface can be represented as a sequence of elements that can be iterated over.
interface Iterable<out T>Iterator
An iterator over a collection or another entity that can be represented as a sequence of elements. Allows to sequentially access the elements.
interface Iterator<out T>LinkedHashMap
Hash table based implementation of the MutableMap interface, which additionally preserves the insertion order of entries during the iteration.
class LinkedHashMap<K, V> : MutableMap<K, V>typealias LinkedHashMap<K, V> = LinkedHashMap<K, V>open class LinkedHashMap<K, V> :
HashMap<K, V>,
MutableMap<K, V>typealias LinkedHashMap<K, V> = HashMap<K, V>LinkedHashSet
The implementation of the MutableSet interface, backed by a InternalMap implementation.
class LinkedHashSet<E> : MutableSet<E>typealias LinkedHashSet<E> = LinkedHashSet<E>open class LinkedHashSet<E> : HashSet<E>, MutableSet<E>typealias LinkedHashSet<V> = HashSet<V>List
A generic ordered collection of elements. Methods in this interface support only read-only access to the list; read/write access is supported through the MutableList interface.
interface List<out E> : Collection<E>ListIterator
An iterator over a collection that supports indexed access.
interface ListIterator<out T> : Iterator<T>LongIterator
An iterator over a sequence of values of type Long.
abstract class LongIterator : Iterator<Long>Map
A collection that holds pairs of objects (keys and values) and supports efficiently retrieving the value corresponding to each key. Map keys are unique; the map holds only one value for each key. Methods in this interface support only read-only access to the map; read-write access is supported through the MutableMap interface.
interface Map<K, out V>MutableCollection
A generic collection of elements that supports adding and removing elements.
interface MutableCollection<E> :
Collection<E>,
MutableIterable<E>MutableIterable
Classes that inherit from this interface can be represented as a sequence of elements that can be iterated over and that supports removing elements during iteration.
interface MutableIterable<out T> : Iterable<T>MutableIterator
An iterator over a mutable collection. Provides the ability to remove elements while iterating.
interface MutableIterator<out T> : Iterator<T>MutableList
A generic ordered collection of elements that supports adding and removing elements.
interface MutableList<E> : List<E>, MutableCollection<E>MutableListIterator
An iterator over a mutable collection that supports indexed access. Provides the ability to add, modify and remove elements while iterating.
interface MutableListIterator<T> :
ListIterator<T>,
MutableIterator<T>MutableMap
A modifiable collection that holds pairs of objects (keys and values) and supports efficiently retrieving the value corresponding to each key. Map keys are unique; the map holds only one value for each key.
interface MutableMap<K, V> : Map<K, V>MutableSet
A generic unordered collection of elements that does not support duplicate elements, and supports adding and removing elements.
interface MutableSet<E> : Set<E>, MutableCollection<E>RandomAccess
Marker interface indicating that the List implementation supports fast indexed access.
interface RandomAccesstypealias RandomAccess = RandomAccessSet
A generic unordered collection of elements that does not support duplicate elements. Methods in this interface support only read-only access to the set; read/write access is supported through the MutableSet interface.
interface Set<out E> : Collection<E>ShortIterator
An iterator over a sequence of values of type Short.
abstract class ShortIterator : Iterator<Short>Extensions for External Classes
Properties
indices
Returns the range of valid indices for the array.
val <T> Array<out T>.indices: IntRangeval ShortArray.indices: IntRangeval FloatArray.indices: IntRangeval DoubleArray.indices: IntRangeval BooleanArray.indices: IntRangeval ULongArray.indices: IntRangeval UByteArray.indices: IntRangeval UShortArray.indices: IntRangeReturns an IntRange of the valid indices for this collection.
val Collection<*>.indices: IntRangelastIndex
Returns the last valid index for the array.
val <T> Array<out T>.lastIndex: Intval ByteArray.lastIndex: Intval ShortArray.lastIndex: Intval IntArray.lastIndex: Intval LongArray.lastIndex: Intval FloatArray.lastIndex: Intval DoubleArray.lastIndex: Intval BooleanArray.lastIndex: Intval CharArray.lastIndex: Intval UIntArray.lastIndex: Intval ULongArray.lastIndex: Intval UByteArray.lastIndex: Intval UShortArray.lastIndex: IntReturns the index of the last item in the list or -1 if the list is empty.
val <T> List<T>.lastIndex: IntFunctions
addAll
Adds all elements of the given elements collection to this MutableCollection.
fun <T> MutableCollection<in T>.addAll(
elements: Iterable<T>
): BooleanAdds all elements of the given elements sequence to this MutableCollection.
fun <T> MutableCollection<in T>.addAll(
elements: Sequence<T>
): BooleanAdds all elements of the given elements array to this MutableCollection.
fun <T> MutableCollection<in T>.addAll(
elements: Array<out T>
): Booleanaggregate
aggregateTo
Groups elements from the Grouping source by key and applies operation to the elements of each group sequentially, passing the previously accumulated value and the current element as arguments, and stores the results in the given destination map.
fun <T, K, R, M : MutableMap<in K, R>> Grouping<T, K>.aggregateTo(
destination: M,
operation: (key: K, accumulator: R?, element: T, first: Boolean) -> R
): Mall
Returns true if all elements match the given predicate.
fun <T> Array<out T>.all(predicate: (T) -> Boolean): Booleanfun ByteArray.all(predicate: (Byte) -> Boolean): Booleanfun ShortArray.all(predicate: (Short) -> Boolean): Booleanfun IntArray.all(predicate: (Int) -> Boolean): Booleanfun LongArray.all(predicate: (Long) -> Boolean): Booleanfun FloatArray.all(predicate: (Float) -> Boolean): Booleanfun DoubleArray.all(predicate: (Double) -> Boolean): Booleanfun BooleanArray.all(
predicate: (Boolean) -> Boolean
): Booleanfun CharArray.all(predicate: (Char) -> Boolean): Booleanfun <T> Iterable<T>.all(predicate: (T) -> Boolean): Booleanfun ULongArray.all(predicate: (ULong) -> Boolean): Booleanfun UByteArray.all(predicate: (UByte) -> Boolean): Booleanfun UShortArray.all(predicate: (UShort) -> Boolean): Booleanany
Returns true if array has at least one element.
fun <T> Array<out T>.any(): Booleanfun ByteArray.any(): Booleanfun ShortArray.any(): Booleanfun IntArray.any(): Booleanfun LongArray.any(): Booleanfun FloatArray.any(): Booleanfun DoubleArray.any(): Booleanfun BooleanArray.any(): Booleanfun CharArray.any(): Booleanfun UIntArray.any(): Booleanfun ULongArray.any(): Booleanfun UByteArray.any(): Booleanfun UShortArray.any(): BooleanReturns true if at least one element matches the given predicate.
fun <T> Array<out T>.any(predicate: (T) -> Boolean): Booleanfun ByteArray.any(predicate: (Byte) -> Boolean): Booleanfun ShortArray.any(predicate: (Short) -> Boolean): Booleanfun IntArray.any(predicate: (Int) -> Boolean): Booleanfun LongArray.any(predicate: (Long) -> Boolean): Booleanfun FloatArray.any(predicate: (Float) -> Boolean): Booleanfun DoubleArray.any(predicate: (Double) -> Boolean): Booleanfun BooleanArray.any(
predicate: (Boolean) -> Boolean
): Booleanfun CharArray.any(predicate: (Char) -> Boolean): Booleanfun <T> Iterable<T>.any(predicate: (T) -> Boolean): Booleanfun ULongArray.any(predicate: (ULong) -> Boolean): Booleanfun UByteArray.any(predicate: (UByte) -> Boolean): Booleanfun UShortArray.any(predicate: (UShort) -> Boolean): BooleanReturns true if collection has at least one element.
fun <T> Iterable<T>.any(): BooleanReturns true if map has at least one entry.
fun <K, V> Map<out K, V>.any(): BooleanasByteArray
Returns an array of type ByteArray, which is a view of this array where each element is a signed reinterpretation of the corresponding element of this array.
fun UByteArray.asByteArray(): ByteArrayasIterable
asList
Returns a List that wraps the original array.
fun <ERROR CLASS>.asList(): List<<ERROR CLASS>>fun <T> Array<out T>.asList(): List<T>fun ShortArray.asList(): List<Short>fun FloatArray.asList(): List<Float>fun DoubleArray.asList(): List<Double>fun BooleanArray.asList(): List<Boolean>fun ULongArray.asList(): List<ULong>fun UByteArray.asList(): List<UByte>fun UShortArray.asList(): List<UShort>asLongArray
Returns an array of type LongArray, which is a view of this array where each element is a signed reinterpretation of the corresponding element of this array.
fun ULongArray.asLongArray(): LongArrayasReversed
Returns a reversed read-only view of the original List. All changes made in the original list will be reflected in the reversed one.
Returns a reversed mutable view of the original mutable List. All changes made in the original list will be reflected in the reversed one and vice versa.
fun <T> MutableList<T>.asReversed(): MutableList<T>asSequence
Creates a Sequence instance that wraps the original array returning its elements when being iterated.
fun <T> any_array<T>.asSequence(): Sequence<T>Creates a Sequence instance that wraps the original collection returning its elements when being iterated.
asShortArray
Returns an array of type ShortArray, which is a view of this array where each element is a signed reinterpretation of the corresponding element of this array.
fun UShortArray.asShortArray(): ShortArrayassociate
associateBy
Returns a Map containing the elements from the given array indexed by the key returned from keySelector function applied to each element.
fun <T, K> any_array<T>.associateBy(
keySelector: (T) -> K
): Map<K, T>Returns a Map containing the values provided by valueTransform and indexed by keySelector functions applied to elements of the given array.
fun <T, K, V> any_array<T>.associateBy(
keySelector: (T) -> K,
valueTransform: (T) -> V
): Map<K, V>Returns a Map containing the elements from the given collection indexed by the key returned from keySelector function applied to each element.
Returns a Map containing the values provided by valueTransform and indexed by keySelector functions applied to elements of the given collection.
associateByTo
Populates and returns the destination mutable map with key-value pairs, where key is provided by the keySelector function applied to each element of the given array and value is the element itself.
fun <T, K, M : MutableMap<in K, in T>> any_array<T>.associateByTo(
destination: M,
keySelector: (T) -> K
): MPopulates and returns the destination mutable map with key-value pairs, where key is provided by the keySelector function and and value is provided by the valueTransform function applied to elements of the given array.
fun <T, K, V, M : MutableMap<in K, in V>> any_array<T>.associateByTo(
destination: M,
keySelector: (T) -> K,
valueTransform: (T) -> V
): MPopulates and returns the destination mutable map with key-value pairs, where key is provided by the keySelector function applied to each element of the given collection and value is the element itself.
fun <T, K, M : MutableMap<in K, in T>> Iterable<T>.associateByTo(
destination: M,
keySelector: (T) -> K
): MPopulates and returns the destination mutable map with key-value pairs, where key is provided by the keySelector function and and value is provided by the valueTransform function applied to elements of the given collection.
fun <T, K, V, M : MutableMap<in K, in V>> Iterable<T>.associateByTo(
destination: M,
keySelector: (T) -> K,
valueTransform: (T) -> V
): MassociateTo
Populates and returns the destination mutable map with key-value pairs provided by transform function applied to each element of the given array.
fun <T, K, V, M : MutableMap<in K, in V>> any_array<T>.associateTo(
destination: M,
transform: (T) -> Pair<K, V>
): MPopulates and returns the destination mutable map with key-value pairs provided by transform function applied to each element of the given collection.
fun <T, K, V, M : MutableMap<in K, in V>> Iterable<T>.associateTo(
destination: M,
transform: (T) -> Pair<K, V>
): MassociateWith
Returns a Map where keys are elements from the given array and values are produced by the valueSelector function applied to each element.
fun <K, V> Array<out K>.associateWith(
valueSelector: (K) -> V
): Map<K, V>fun <V> ShortArray.associateWith(
valueSelector: (Short) -> V
): Map<Short, V>fun <V> FloatArray.associateWith(
valueSelector: (Float) -> V
): Map<Float, V>fun <V> DoubleArray.associateWith(
valueSelector: (Double) -> V
): Map<Double, V>fun <V> BooleanArray.associateWith(
valueSelector: (Boolean) -> V
): Map<Boolean, V>fun <V> ULongArray.associateWith(
valueSelector: (ULong) -> V
): Map<ULong, V>fun <V> UByteArray.associateWith(
valueSelector: (UByte) -> V
): Map<UByte, V>fun <V> UShortArray.associateWith(
valueSelector: (UShort) -> V
): Map<UShort, V>Returns a Map where keys are elements from the given collection and values are produced by the valueSelector function applied to each element.
associateWithTo
Populates and returns the destination mutable map with key-value pairs for each element of the given array, where key is the element itself and value is provided by the valueSelector function applied to that key.
fun <K, V, M : MutableMap<in K, in V>> Array<out K>.associateWithTo(
destination: M,
valueSelector: (K) -> V
): Mfun <V, M : MutableMap<in Byte, in V>> ByteArray.associateWithTo(
destination: M,
valueSelector: (Byte) -> V
): Mfun <V, M : MutableMap<in Short, in V>> ShortArray.associateWithTo(
destination: M,
valueSelector: (Short) -> V
): Mfun <V, M : MutableMap<in Int, in V>> IntArray.associateWithTo(
destination: M,
valueSelector: (Int) -> V
): Mfun <V, M : MutableMap<in Long, in V>> LongArray.associateWithTo(
destination: M,
valueSelector: (Long) -> V
): Mfun <V, M : MutableMap<in Float, in V>> FloatArray.associateWithTo(
destination: M,
valueSelector: (Float) -> V
): Mfun <V, M : MutableMap<in Double, in V>> DoubleArray.associateWithTo(
destination: M,
valueSelector: (Double) -> V
): Mfun <V, M : MutableMap<in Boolean, in V>> BooleanArray.associateWithTo(
destination: M,
valueSelector: (Boolean) -> V
): Mfun <V, M : MutableMap<in Char, in V>> CharArray.associateWithTo(
destination: M,
valueSelector: (Char) -> V
): Mfun <V, M : MutableMap<in UInt, in V>> UIntArray.associateWithTo(
destination: M,
valueSelector: (UInt) -> V
): Mfun <V, M : MutableMap<in ULong, in V>> ULongArray.associateWithTo(
destination: M,
valueSelector: (ULong) -> V
): Mfun <V, M : MutableMap<in UByte, in V>> UByteArray.associateWithTo(
destination: M,
valueSelector: (UByte) -> V
): Mfun <V, M : MutableMap<in UShort, in V>> UShortArray.associateWithTo(
destination: M,
valueSelector: (UShort) -> V
): MPopulates and returns the destination mutable map with key-value pairs for each element of the given collection, where key is the element itself and value is provided by the valueSelector function applied to that key.
fun <K, V, M : MutableMap<in K, in V>> Iterable<K>.associateWithTo(
destination: M,
valueSelector: (K) -> V
): MasUByteArray
Returns an array of type UByteArray, which is a view of this array where each element is an unsigned reinterpretation of the corresponding element of this array.
fun ByteArray.asUByteArray(): UByteArrayasULongArray
Returns an array of type ULongArray, which is a view of this array where each element is an unsigned reinterpretation of the corresponding element of this array.
fun LongArray.asULongArray(): ULongArrayasUShortArray
Returns an array of type UShortArray, which is a view of this array where each element is an unsigned reinterpretation of the corresponding element of this array.
fun ShortArray.asUShortArray(): UShortArrayaverage
Returns an average value of elements in the array.
fun Array<out Byte>.average(): Doublefun Array<out Short>.average(): Doublefun Array<out Int>.average(): Doublefun Array<out Long>.average(): Doublefun Array<out Float>.average(): Doublefun Array<out Double>.average(): Doublefun ByteArray.average(): Doublefun ShortArray.average(): Doublefun IntArray.average(): Doublefun LongArray.average(): Doublefun FloatArray.average(): Doublefun DoubleArray.average(): DoublebinarySearch
Searches this list or its range for the provided element using the binary search algorithm. The list is expected to be sorted into ascending order according to the Comparable natural ordering of its elements, otherwise the result is undefined.
fun <T : Comparable<T>> List<T?>.binarySearch(
element: T?,
fromIndex: Int = 0,
toIndex: Int = size
): IntSearches this list or its range for the provided element using the binary search algorithm. The list is expected to be sorted into ascending order according to the specified comparator, otherwise the result is undefined.
fun <T> List<T>.binarySearch(
element: T,
comparator: Comparator<in T>,
fromIndex: Int = 0,
toIndex: Int = size
): IntSearches this list or its range for an element for which the given comparison function returns zero using the binary search algorithm.
fun <T> List<T>.binarySearch(
fromIndex: Int = 0,
toIndex: Int = size,
comparison: (T) -> Int
): IntSearches the array or the range of the array for the provided element using the binary search algorithm. The array is expected to be sorted according to the specified comparator, otherwise the result is undefined.
fun <T> Array<out T>.binarySearch(
element: T,
comparator: Comparator<in T>,
fromIndex: Int = 0,
toIndex: Int = size
): IntSearches the array or the range of the array for the provided element using the binary search algorithm. The array is expected to be sorted, otherwise the result is undefined.
fun <T> Array<out T>.binarySearch(
element: T,
fromIndex: Int = 0,
toIndex: Int = size
): Intfun ByteArray.binarySearch(
element: Byte,
fromIndex: Int = 0,
toIndex: Int = size
): Intfun ShortArray.binarySearch(
element: Short,
fromIndex: Int = 0,
toIndex: Int = size
): Intfun IntArray.binarySearch(
element: Int,
fromIndex: Int = 0,
toIndex: Int = size
): Intfun LongArray.binarySearch(
element: Long,
fromIndex: Int = 0,
toIndex: Int = size
): Intfun FloatArray.binarySearch(
element: Float,
fromIndex: Int = 0,
toIndex: Int = size
): Intfun DoubleArray.binarySearch(
element: Double,
fromIndex: Int = 0,
toIndex: Int = size
): Intfun CharArray.binarySearch(
element: Char,
fromIndex: Int = 0,
toIndex: Int = size
): Intfun ULongArray.binarySearch(
element: ULong,
fromIndex: Int = 0,
toIndex: Int = size
): Intfun UByteArray.binarySearch(
element: UByte,
fromIndex: Int = 0,
toIndex: Int = size
): Intfun UShortArray.binarySearch(
element: UShort,
fromIndex: Int = 0,
toIndex: Int = size
): IntbinarySearchBy
Searches this list or its range for an element having the key returned by the specified selector function equal to the provided key value using the binary search algorithm. The list is expected to be sorted into ascending order according to the Comparable natural ordering of keys of its elements. otherwise the result is undefined.
fun <T, K : Comparable<K>> List<T>.binarySearchBy(
key: K?,
fromIndex: Int = 0,
toIndex: Int = size,
selector: (T) -> K?
): IntbuildList
Builds a new read-only List by populating a MutableList using the given builderAction and returning a read-only list with the same elements.
fun <E> buildList(
builderAction: MutableList<E>.() -> Unit
): List<E>fun <E> buildList(
capacity: Int,
builderAction: MutableList<E>.() -> Unit
): List<E>buildMap
Builds a new read-only Map by populating a MutableMap using the given builderAction and returning a read-only map with the same key-value pairs.
fun <K, V> buildMap(
builderAction: MutableMap<K, V>.() -> Unit
): Map<K, V>fun <K, V> buildMap(
capacity: Int,
builderAction: MutableMap<K, V>.() -> Unit
): Map<K, V>buildSet
Builds a new read-only Set by populating a MutableSet using the given builderAction and returning a read-only set with the same elements.
fun <E> buildSet(
builderAction: MutableSet<E>.() -> Unit
): Set<E>fun <E> buildSet(
capacity: Int,
builderAction: MutableSet<E>.() -> Unit
): Set<E>component1
Returns 1st element from the array.
operator fun <T> Array<out T>.component1(): Toperator fun ByteArray.component1(): Byteoperator fun ShortArray.component1(): Shortoperator fun IntArray.component1(): Intoperator fun LongArray.component1(): Longoperator fun FloatArray.component1(): Floatoperator fun DoubleArray.component1(): Doubleoperator fun BooleanArray.component1(): Booleanoperator fun CharArray.component1(): Charoperator fun ULongArray.component1(): ULongoperator fun UByteArray.component1(): UByteoperator fun UShortArray.component1(): UShortReturns 1st element from the list.
operator fun <T> List<T>.component1(): TReturns the key component of the map entry.
operator fun <K, V> Entry<K, V>.component1(): Kcomponent2
Returns 2nd element from the array.
operator fun <T> Array<out T>.component2(): Toperator fun ByteArray.component2(): Byteoperator fun ShortArray.component2(): Shortoperator fun IntArray.component2(): Intoperator fun LongArray.component2(): Longoperator fun FloatArray.component2(): Floatoperator fun DoubleArray.component2(): Doubleoperator fun BooleanArray.component2(): Booleanoperator fun CharArray.component2(): Charoperator fun ULongArray.component2(): ULongoperator fun UByteArray.component2(): UByteoperator fun UShortArray.component2(): UShortReturns 2nd element from the list.
operator fun <T> List<T>.component2(): TReturns the value component of the map entry.
operator fun <K, V> Entry<K, V>.component2(): Vcomponent3
Returns 3rd element from the array.
operator fun <T> Array<out T>.component3(): Toperator fun ByteArray.component3(): Byteoperator fun ShortArray.component3(): Shortoperator fun IntArray.component3(): Intoperator fun LongArray.component3(): Longoperator fun FloatArray.component3(): Floatoperator fun DoubleArray.component3(): Doubleoperator fun BooleanArray.component3(): Booleanoperator fun CharArray.component3(): Charoperator fun ULongArray.component3(): ULongoperator fun UByteArray.component3(): UByteoperator fun UShortArray.component3(): UShortReturns 3rd element from the list.
operator fun <T> List<T>.component3(): Tcomponent4
Returns 4th element from the array.
operator fun <T> Array<out T>.component4(): Toperator fun ByteArray.component4(): Byteoperator fun ShortArray.component4(): Shortoperator fun IntArray.component4(): Intoperator fun LongArray.component4(): Longoperator fun FloatArray.component4(): Floatoperator fun DoubleArray.component4(): Doubleoperator fun BooleanArray.component4(): Booleanoperator fun CharArray.component4(): Charoperator fun ULongArray.component4(): ULongoperator fun UByteArray.component4(): UByteoperator fun UShortArray.component4(): UShortReturns 4th element from the list.
operator fun <T> List<T>.component4(): Tcomponent5
Returns 5th element from the array.
operator fun <T> Array<out T>.component5(): Toperator fun ByteArray.component5(): Byteoperator fun ShortArray.component5(): Shortoperator fun IntArray.component5(): Intoperator fun LongArray.component5(): Longoperator fun FloatArray.component5(): Floatoperator fun DoubleArray.component5(): Doubleoperator fun BooleanArray.component5(): Booleanoperator fun CharArray.component5(): Charoperator fun ULongArray.component5(): ULongoperator fun UByteArray.component5(): UByteoperator fun UShortArray.component5(): UShortReturns 5th element from the list.
operator fun <T> List<T>.component5(): Tcontains
Returns true if element is found in the array.
operator fun <T> any_array<T>.contains(element: T): BooleanReturns true if element is found in the collection.
operator fun <T> Iterable<T>.contains(element: T): BooleanChecks if the map contains the given key.
operator fun <K, V> Map<out K, V>.contains(key: K): BooleancontainsAll
Checks if all elements in the specified collection are contained in this collection.
fun <T> Collection<T>.containsAll(
elements: Collection<T>
): BooleancontentDeepEquals
Checks if the two specified arrays are deeply equal to one another.
infix fun <T> any_array<T>.contentDeepEquals(
other: Array<out T>
): BooleancontentDeepHashCode
Returns a hash code based on the contents of this array as if it is List. Nested arrays are treated as lists too.
fun <T> any_array<T>.contentDeepHashCode(): IntcontentDeepToString
Returns a string representation of the contents of this array as if it is a List. Nested arrays are treated as lists too.
fun <T> any_array<T>.contentDeepToString(): StringcontentEquals
Checks if the two specified arrays are structurally equal to one another.
infix fun ULongArray?.contentEquals(
other: ULongArray?
): Booleaninfix fun UByteArray?.contentEquals(
other: UByteArray?
): Booleaninfix fun UShortArray?.contentEquals(
other: UShortArray?
): Booleaninfix fun <T> Array<out T>.contentEquals(
other: Array<out T>
): Booleaninfix fun ShortArray.contentEquals(
other: ShortArray
): Booleaninfix fun FloatArray.contentEquals(
other: FloatArray
): Booleaninfix fun DoubleArray.contentEquals(
other: DoubleArray
): Booleaninfix fun BooleanArray.contentEquals(
other: BooleanArray
): Booleaninfix fun ULongArray.contentEquals(
other: ULongArray
): Booleaninfix fun UByteArray.contentEquals(
other: UByteArray
): Booleaninfix fun UShortArray.contentEquals(
other: UShortArray
): Booleaninfix fun <T> Array<out T>?.contentEquals(
other: Array<out T>?
): Booleaninfix fun ShortArray?.contentEquals(
other: ShortArray?
): Booleaninfix fun FloatArray?.contentEquals(
other: FloatArray?
): Booleaninfix fun DoubleArray?.contentEquals(
other: DoubleArray?
): Booleaninfix fun BooleanArray?.contentEquals(
other: BooleanArray?
): BooleancontentHashCode
Returns a hash code based on the contents of this array as if it is List.
fun UIntArray?.contentHashCode(): Intfun ULongArray?.contentHashCode(): Intfun UByteArray?.contentHashCode(): Intfun UShortArray?.contentHashCode(): Intfun <T> Array<out T>.contentHashCode(): Intfun ByteArray.contentHashCode(): Intfun ShortArray.contentHashCode(): Intfun IntArray.contentHashCode(): Intfun LongArray.contentHashCode(): Intfun FloatArray.contentHashCode(): Intfun DoubleArray.contentHashCode(): Intfun BooleanArray.contentHashCode(): Intfun CharArray.contentHashCode(): Intfun UIntArray.contentHashCode(): Intfun ULongArray.contentHashCode(): Intfun UByteArray.contentHashCode(): Intfun UShortArray.contentHashCode(): Intfun <T> Array<out T>?.contentHashCode(): Intfun ByteArray?.contentHashCode(): Intfun ShortArray?.contentHashCode(): Intfun IntArray?.contentHashCode(): Intfun LongArray?.contentHashCode(): Intfun FloatArray?.contentHashCode(): Intfun DoubleArray?.contentHashCode(): Intfun BooleanArray?.contentHashCode(): Intfun CharArray?.contentHashCode(): IntcontentToString
Returns a string representation of the contents of the specified array as if it is List.
fun UIntArray?.contentToString(): Stringfun ULongArray?.contentToString(): Stringfun UByteArray?.contentToString(): Stringfun UShortArray?.contentToString(): Stringfun <T> Array<out T>.contentToString(): Stringfun ByteArray.contentToString(): Stringfun ShortArray.contentToString(): Stringfun IntArray.contentToString(): Stringfun LongArray.contentToString(): Stringfun FloatArray.contentToString(): Stringfun DoubleArray.contentToString(): Stringfun BooleanArray.contentToString(): Stringfun CharArray.contentToString(): Stringfun UIntArray.contentToString(): Stringfun ULongArray.contentToString(): Stringfun UByteArray.contentToString(): Stringfun UShortArray.contentToString(): Stringfun <T> Array<out T>?.contentToString(): Stringfun ByteArray?.contentToString(): Stringfun ShortArray?.contentToString(): Stringfun IntArray?.contentToString(): Stringfun LongArray?.contentToString(): Stringfun FloatArray?.contentToString(): Stringfun DoubleArray?.contentToString(): Stringfun BooleanArray?.contentToString(): Stringfun CharArray?.contentToString(): StringcopyInto
Copies this array or its subrange into the destination array and returns that array.
fun ULongArray.copyInto(
destination: ULongArray,
destinationOffset: Int = 0,
startIndex: Int = 0,
endIndex: Int = size
): ULongArrayfun UByteArray.copyInto(
destination: UByteArray,
destinationOffset: Int = 0,
startIndex: Int = 0,
endIndex: Int = size
): UByteArrayfun UShortArray.copyInto(
destination: UShortArray,
destinationOffset: Int = 0,
startIndex: Int = 0,
endIndex: Int = size
): UShortArrayfun <T> Array<out T>.copyInto(
destination: Array<T>,
destinationOffset: Int = 0,
startIndex: Int = 0,
endIndex: Int = size
): Array<T>fun ShortArray.copyInto(
destination: ShortArray,
destinationOffset: Int = 0,
startIndex: Int = 0,
endIndex: Int = size
): ShortArrayfun FloatArray.copyInto(
destination: FloatArray,
destinationOffset: Int = 0,
startIndex: Int = 0,
endIndex: Int = size
): FloatArrayfun DoubleArray.copyInto(
destination: DoubleArray,
destinationOffset: Int = 0,
startIndex: Int = 0,
endIndex: Int = size
): DoubleArrayfun BooleanArray.copyInto(
destination: BooleanArray,
destinationOffset: Int = 0,
startIndex: Int = 0,
endIndex: Int = size
): BooleanArraycopyOf
Returns new array which is a copy of the original array.
fun ULongArray.copyOf(): ULongArrayfun UByteArray.copyOf(): UByteArrayfun UShortArray.copyOf(): UShortArrayfun <T> Array<T>.copyOf(): Array<T>fun <T> Array<out T>.copyOf(): Array<T>fun ShortArray.copyOf(): ShortArrayfun FloatArray.copyOf(): FloatArrayfun DoubleArray.copyOf(): DoubleArrayfun BooleanArray.copyOf(): BooleanArrayReturns new array which is a copy of the original array, resized to the given newSize. The copy is either truncated or padded at the end with zero values if necessary.
fun ULongArray.copyOf(newSize: Int): ULongArrayfun UByteArray.copyOf(newSize: Int): UByteArrayfun UShortArray.copyOf(newSize: Int): UShortArrayfun ShortArray.copyOf(newSize: Int): ShortArrayfun FloatArray.copyOf(newSize: Int): FloatArrayfun DoubleArray.copyOf(newSize: Int): DoubleArrayReturns new array which is a copy of the original array, resized to the given newSize.
The copy is either truncated or padded at the end with false values if necessary.
fun BooleanArray.copyOf(newSize: Int): BooleanArrayReturns new array which is a copy of the original array, resized to the given newSize.
The copy is either truncated or padded at the end with null char (\u0000) values if necessary.
Returns new array which is a copy of the original array, resized to the given newSize.
The copy is either truncated or padded at the end with null values if necessary.
fun <T> any_array<T>.copyOf(newSize: Int): Array<T?>copyOfRange
Returns a new array which is a copy of the specified range of the original array.
fun ULongArray.copyOfRange(
fromIndex: Int,
toIndex: Int
): ULongArrayfun UByteArray.copyOfRange(
fromIndex: Int,
toIndex: Int
): UByteArrayfun UShortArray.copyOfRange(
fromIndex: Int,
toIndex: Int
): UShortArrayfun <T> Array<T>.copyOfRange(
fromIndex: Int,
toIndex: Int
): Array<T>fun <T> Array<out T>.copyOfRange(
fromIndex: Int,
toIndex: Int
): Array<T>fun ShortArray.copyOfRange(
fromIndex: Int,
toIndex: Int
): ShortArrayfun FloatArray.copyOfRange(
fromIndex: Int,
toIndex: Int
): FloatArrayfun DoubleArray.copyOfRange(
fromIndex: Int,
toIndex: Int
): DoubleArrayfun BooleanArray.copyOfRange(
fromIndex: Int,
toIndex: Int
): BooleanArraycount
Returns the number of elements in this array.
fun <T> any_array<T>.count(): IntReturns the number of elements matching the given predicate.
fun <T> Array<out T>.count(predicate: (T) -> Boolean): Intfun ByteArray.count(predicate: (Byte) -> Boolean): Intfun ShortArray.count(predicate: (Short) -> Boolean): Intfun IntArray.count(predicate: (Int) -> Boolean): Intfun LongArray.count(predicate: (Long) -> Boolean): Intfun FloatArray.count(predicate: (Float) -> Boolean): Intfun DoubleArray.count(predicate: (Double) -> Boolean): Intfun BooleanArray.count(predicate: (Boolean) -> Boolean): Intfun CharArray.count(predicate: (Char) -> Boolean): Intfun <T> Iterable<T>.count(predicate: (T) -> Boolean): Intfun ULongArray.count(predicate: (ULong) -> Boolean): Intfun UByteArray.count(predicate: (UByte) -> Boolean): Intfun UShortArray.count(predicate: (UShort) -> Boolean): IntReturns the number of elements in this collection.
fun <T> Iterable<T>.count(): Intfun <T> Collection<T>.count(): IntReturns the number of entries in this map.
fun <K, V> Map<out K, V>.count(): Intdistinct
Returns a list containing only distinct elements from the given array.
fun <T> any_array<T>.distinct(): List<T>distinctBy
drop
Returns a list containing all elements except first n elements.
fun <T> Array<out T>.drop(n: Int): List<T>fun ShortArray.drop(n: Int): List<Short>fun FloatArray.drop(n: Int): List<Float>fun DoubleArray.drop(n: Int): List<Double>fun BooleanArray.drop(n: Int): List<Boolean>fun ULongArray.drop(n: Int): List<ULong>fun UByteArray.drop(n: Int): List<UByte>fun UShortArray.drop(n: Int): List<UShort>dropLast
Returns a list containing all elements except last n elements.
fun <T> Array<out T>.dropLast(n: Int): List<T>fun ShortArray.dropLast(n: Int): List<Short>fun FloatArray.dropLast(n: Int): List<Float>fun DoubleArray.dropLast(n: Int): List<Double>fun BooleanArray.dropLast(n: Int): List<Boolean>fun ULongArray.dropLast(n: Int): List<ULong>fun UByteArray.dropLast(n: Int): List<UByte>fun UShortArray.dropLast(n: Int): List<UShort>dropLastWhile
Returns a list containing all elements except last elements that satisfy the given predicate.
fun <T> Array<out T>.dropLastWhile(
predicate: (T) -> Boolean
): List<T>fun ShortArray.dropLastWhile(
predicate: (Short) -> Boolean
): List<Short>fun FloatArray.dropLastWhile(
predicate: (Float) -> Boolean
): List<Float>fun DoubleArray.dropLastWhile(
predicate: (Double) -> Boolean
): List<Double>fun BooleanArray.dropLastWhile(
predicate: (Boolean) -> Boolean
): List<Boolean>fun ULongArray.dropLastWhile(
predicate: (ULong) -> Boolean
): List<ULong>fun UByteArray.dropLastWhile(
predicate: (UByte) -> Boolean
): List<UByte>fun UShortArray.dropLastWhile(
predicate: (UShort) -> Boolean
): List<UShort>dropWhile
Returns a list containing all elements except first elements that satisfy the given predicate.
fun <T> Array<out T>.dropWhile(
predicate: (T) -> Boolean
): List<T>fun ShortArray.dropWhile(
predicate: (Short) -> Boolean
): List<Short>fun FloatArray.dropWhile(
predicate: (Float) -> Boolean
): List<Float>fun DoubleArray.dropWhile(
predicate: (Double) -> Boolean
): List<Double>fun BooleanArray.dropWhile(
predicate: (Boolean) -> Boolean
): List<Boolean>fun ULongArray.dropWhile(
predicate: (ULong) -> Boolean
): List<ULong>fun UByteArray.dropWhile(
predicate: (UByte) -> Boolean
): List<UByte>fun UShortArray.dropWhile(
predicate: (UShort) -> Boolean
): List<UShort>eachCount
eachCountTo
Groups elements from the Grouping source by key and counts elements in each group to the given destination map.
fun <T, K, M : MutableMap<in K, Int>> Grouping<T, K>.eachCountTo(
destination: M
): MelementAt
Returns an element at the given index or throws an IndexOutOfBoundsException if the index is out of bounds of this collection.
fun <T> Iterable<T>.elementAt(index: Int): TReturns an element at the given index or throws an IndexOutOfBoundsException if the index is out of bounds of this list.
fun <T> List<T>.elementAt(index: Int): TReturns an element at the given index or throws an IndexOutOfBoundsException if the index is out of bounds of this array.
fun <ERROR CLASS>.elementAt(index: Int): <ERROR CLASS>fun <T> Array<out T>.elementAt(index: Int): Tfun ByteArray.elementAt(index: Int): Bytefun ShortArray.elementAt(index: Int): Shortfun IntArray.elementAt(index: Int): Intfun LongArray.elementAt(index: Int): Longfun FloatArray.elementAt(index: Int): Floatfun DoubleArray.elementAt(index: Int): Doublefun BooleanArray.elementAt(index: Int): Booleanfun CharArray.elementAt(index: Int): Charfun ULongArray.elementAt(index: Int): ULongfun UByteArray.elementAt(index: Int): UBytefun UShortArray.elementAt(index: Int): UShortelementAtOrElse
Returns an element at the given index or the result of calling the defaultValue function if the index is out of bounds of this array.
fun <T> Array<out T>.elementAtOrElse(
index: Int,
defaultValue: (Int) -> T
): Tfun ByteArray.elementAtOrElse(
index: Int,
defaultValue: (Int) -> Byte
): Bytefun ShortArray.elementAtOrElse(
index: Int,
defaultValue: (Int) -> Short
): Shortfun IntArray.elementAtOrElse(
index: Int,
defaultValue: (Int) -> Int
): Intfun LongArray.elementAtOrElse(
index: Int,
defaultValue: (Int) -> Long
): Longfun FloatArray.elementAtOrElse(
index: Int,
defaultValue: (Int) -> Float
): Floatfun DoubleArray.elementAtOrElse(
index: Int,
defaultValue: (Int) -> Double
): Doublefun BooleanArray.elementAtOrElse(
index: Int,
defaultValue: (Int) -> Boolean
): Booleanfun CharArray.elementAtOrElse(
index: Int,
defaultValue: (Int) -> Char
): Charfun ULongArray.elementAtOrElse(
index: Int,
defaultValue: (Int) -> ULong
): ULongfun UByteArray.elementAtOrElse(
index: Int,
defaultValue: (Int) -> UByte
): UBytefun UShortArray.elementAtOrElse(
index: Int,
defaultValue: (Int) -> UShort
): UShortReturns an element at the given index or the result of calling the defaultValue function if the index is out of bounds of this collection.
fun <T> Iterable<T>.elementAtOrElse(
index: Int,
defaultValue: (Int) -> T
): TReturns an element at the given index or the result of calling the defaultValue function if the index is out of bounds of this list.
fun <T> List<T>.elementAtOrElse(
index: Int,
defaultValue: (Int) -> T
): TelementAtOrNull
Returns an element at the given index or null if the index is out of bounds of this array.
fun <T> Array<out T>.elementAtOrNull(index: Int): T?fun ByteArray.elementAtOrNull(index: Int): Byte?fun ShortArray.elementAtOrNull(index: Int): Short?fun IntArray.elementAtOrNull(index: Int): Int?fun LongArray.elementAtOrNull(index: Int): Long?fun FloatArray.elementAtOrNull(index: Int): Float?fun DoubleArray.elementAtOrNull(index: Int): Double?fun BooleanArray.elementAtOrNull(index: Int): Boolean?fun CharArray.elementAtOrNull(index: Int): Char?fun ULongArray.elementAtOrNull(index: Int): ULong?fun UByteArray.elementAtOrNull(index: Int): UByte?fun UShortArray.elementAtOrNull(index: Int): UShort?emptyList
Returns an empty read-only list. The returned list is serializable (JVM).
fun <T> emptyList(): List<T>emptySet
Returns an empty read-only set. The returned set is serializable (JVM).
fun <T> emptySet(): Set<T>fill
Fills this array or its subrange with the specified element value.
fun ULongArray.fill(
element: ULong,
fromIndex: Int = 0,
toIndex: Int = size)fun UByteArray.fill(
element: UByte,
fromIndex: Int = 0,
toIndex: Int = size)fun UShortArray.fill(
element: UShort,
fromIndex: Int = 0,
toIndex: Int = size)fun <T> Array<T>.fill(
element: T,
fromIndex: Int = 0,
toIndex: Int = size)fun ByteArray.fill(
element: Byte,
fromIndex: Int = 0,
toIndex: Int = size)fun ShortArray.fill(
element: Short,
fromIndex: Int = 0,
toIndex: Int = size)fun IntArray.fill(
element: Int,
fromIndex: Int = 0,
toIndex: Int = size)fun LongArray.fill(
element: Long,
fromIndex: Int = 0,
toIndex: Int = size)fun FloatArray.fill(
element: Float,
fromIndex: Int = 0,
toIndex: Int = size)fun DoubleArray.fill(
element: Double,
fromIndex: Int = 0,
toIndex: Int = size)fun BooleanArray.fill(
element: Boolean,
fromIndex: Int = 0,
toIndex: Int = size)fun CharArray.fill(
element: Char,
fromIndex: Int = 0,
toIndex: Int = size)Fills the list with the provided value.
fun <T> MutableList<T>.fill(value: T)filter
Returns a list containing only elements matching the given predicate.
fun <T> Array<out T>.filter(
predicate: (T) -> Boolean
): List<T>fun ShortArray.filter(
predicate: (Short) -> Boolean
): List<Short>fun FloatArray.filter(
predicate: (Float) -> Boolean
): List<Float>fun DoubleArray.filter(
predicate: (Double) -> Boolean
): List<Double>fun BooleanArray.filter(
predicate: (Boolean) -> Boolean
): List<Boolean>fun ULongArray.filter(
predicate: (ULong) -> Boolean
): List<ULong>fun UByteArray.filter(
predicate: (UByte) -> Boolean
): List<UByte>fun UShortArray.filter(
predicate: (UShort) -> Boolean
): List<UShort>filterIndexed
Returns a list containing only elements matching the given predicate.
fun <T> Array<out T>.filterIndexed(
predicate: (index: Int, T) -> Boolean
): List<T>fun ShortArray.filterIndexed(
predicate: (index: Int, Short) -> Boolean
): List<Short>fun FloatArray.filterIndexed(
predicate: (index: Int, Float) -> Boolean
): List<Float>fun DoubleArray.filterIndexed(
predicate: (index: Int, Double) -> Boolean
): List<Double>fun BooleanArray.filterIndexed(
predicate: (index: Int, Boolean) -> Boolean
): List<Boolean>fun ULongArray.filterIndexed(
predicate: (index: Int, ULong) -> Boolean
): List<ULong>fun UByteArray.filterIndexed(
predicate: (index: Int, UByte) -> Boolean
): List<UByte>fun UShortArray.filterIndexed(
predicate: (index: Int, UShort) -> Boolean
): List<UShort>filterIndexedTo
Appends all elements matching the given predicate to the given destination.
fun <T, C : MutableCollection<in T>> Array<out T>.filterIndexedTo(
destination: C,
predicate: (index: Int, T) -> Boolean
): Cfun <C : MutableCollection<in Byte>> ByteArray.filterIndexedTo(
destination: C,
predicate: (index: Int, Byte) -> Boolean
): Cfun <C : MutableCollection<in Short>> ShortArray.filterIndexedTo(
destination: C,
predicate: (index: Int, Short) -> Boolean
): Cfun <C : MutableCollection<in Int>> IntArray.filterIndexedTo(
destination: C,
predicate: (index: Int, Int) -> Boolean
): Cfun <C : MutableCollection<in Long>> LongArray.filterIndexedTo(
destination: C,
predicate: (index: Int, Long) -> Boolean
): Cfun <C : MutableCollection<in Float>> FloatArray.filterIndexedTo(
destination: C,
predicate: (index: Int, Float) -> Boolean
): Cfun <C : MutableCollection<in Double>> DoubleArray.filterIndexedTo(
destination: C,
predicate: (index: Int, Double) -> Boolean
): Cfun <C : MutableCollection<in Boolean>> BooleanArray.filterIndexedTo(
destination: C,
predicate: (index: Int, Boolean) -> Boolean
): Cfun <C : MutableCollection<in Char>> CharArray.filterIndexedTo(
destination: C,
predicate: (index: Int, Char) -> Boolean
): Cfun <T, C : MutableCollection<in T>> Iterable<T>.filterIndexedTo(
destination: C,
predicate: (index: Int, T) -> Boolean
): Cfun <C : MutableCollection<in UInt>> UIntArray.filterIndexedTo(
destination: C,
predicate: (index: Int, UInt) -> Boolean
): Cfun <C : MutableCollection<in ULong>> ULongArray.filterIndexedTo(
destination: C,
predicate: (index: Int, ULong) -> Boolean
): Cfun <C : MutableCollection<in UByte>> UByteArray.filterIndexedTo(
destination: C,
predicate: (index: Int, UByte) -> Boolean
): Cfun <C : MutableCollection<in UShort>> UShortArray.filterIndexedTo(
destination: C,
predicate: (index: Int, UShort) -> Boolean
): CfilterIsInstance
Returns a list containing all elements that are instances of specified type parameter R.
fun <R> Array<*>.filterIsInstance(): List<R>filterIsInstanceTo
Appends all elements that are instances of specified type parameter R to the given destination.
fun <R, C : MutableCollection<in R>> Array<*>.filterIsInstanceTo(
destination: C
): Cfun <R, C : MutableCollection<in R>> Iterable<*>.filterIsInstanceTo(
destination: C
): CAppends all elements that are instances of specified class to the given destination.
fun <C : MutableCollection<in R>, R> Array<*>.filterIsInstanceTo(
destination: C,
klass: Class<R>
): Cfun <C : MutableCollection<in R>, R> Iterable<*>.filterIsInstanceTo(
destination: C,
klass: Class<R>
): CfilterNot
Returns a list containing all elements not matching the given predicate.
fun <T> Array<out T>.filterNot(
predicate: (T) -> Boolean
): List<T>fun ShortArray.filterNot(
predicate: (Short) -> Boolean
): List<Short>fun FloatArray.filterNot(
predicate: (Float) -> Boolean
): List<Float>fun DoubleArray.filterNot(
predicate: (Double) -> Boolean
): List<Double>fun BooleanArray.filterNot(
predicate: (Boolean) -> Boolean
): List<Boolean>fun ULongArray.filterNot(
predicate: (ULong) -> Boolean
): List<ULong>fun UByteArray.filterNot(
predicate: (UByte) -> Boolean
): List<UByte>fun UShortArray.filterNot(
predicate: (UShort) -> Boolean
): List<UShort>filterNotNullTo
Appends all elements that are not null to the given destination.
fun <C : MutableCollection<in T>, T : Any> Array<out T?>.filterNotNullTo(
destination: C
): Cfun <C : MutableCollection<in T>, T : Any> Iterable<T?>.filterNotNullTo(
destination: C
): CfilterNotTo
Appends all elements not matching the given predicate to the given destination.
fun <T, C : MutableCollection<in T>> Array<out T>.filterNotTo(
destination: C,
predicate: (T) -> Boolean
): Cfun <C : MutableCollection<in Byte>> ByteArray.filterNotTo(
destination: C,
predicate: (Byte) -> Boolean
): Cfun <C : MutableCollection<in Short>> ShortArray.filterNotTo(
destination: C,
predicate: (Short) -> Boolean
): Cfun <C : MutableCollection<in Int>> IntArray.filterNotTo(
destination: C,
predicate: (Int) -> Boolean
): Cfun <C : MutableCollection<in Long>> LongArray.filterNotTo(
destination: C,
predicate: (Long) -> Boolean
): Cfun <C : MutableCollection<in Float>> FloatArray.filterNotTo(
destination: C,
predicate: (Float) -> Boolean
): Cfun <C : MutableCollection<in Double>> DoubleArray.filterNotTo(
destination: C,
predicate: (Double) -> Boolean
): Cfun <C : MutableCollection<in Boolean>> BooleanArray.filterNotTo(
destination: C,
predicate: (Boolean) -> Boolean
): Cfun <C : MutableCollection<in Char>> CharArray.filterNotTo(
destination: C,
predicate: (Char) -> Boolean
): Cfun <T, C : MutableCollection<in T>> Iterable<T>.filterNotTo(
destination: C,
predicate: (T) -> Boolean
): Cfun <C : MutableCollection<in UInt>> UIntArray.filterNotTo(
destination: C,
predicate: (UInt) -> Boolean
): Cfun <C : MutableCollection<in ULong>> ULongArray.filterNotTo(
destination: C,
predicate: (ULong) -> Boolean
): Cfun <C : MutableCollection<in UByte>> UByteArray.filterNotTo(
destination: C,
predicate: (UByte) -> Boolean
): Cfun <C : MutableCollection<in UShort>> UShortArray.filterNotTo(
destination: C,
predicate: (UShort) -> Boolean
): CAppends all entries not matching the given predicate into the given destination.
fun <K, V, M : MutableMap<in K, in V>> Map<out K, V>.filterNotTo(
destination: M,
predicate: (Entry<K, V>) -> Boolean
): MfilterTo
Appends all elements matching the given predicate to the given destination.
fun <T, C : MutableCollection<in T>> Array<out T>.filterTo(
destination: C,
predicate: (T) -> Boolean
): Cfun <C : MutableCollection<in Byte>> ByteArray.filterTo(
destination: C,
predicate: (Byte) -> Boolean
): Cfun <C : MutableCollection<in Short>> ShortArray.filterTo(
destination: C,
predicate: (Short) -> Boolean
): Cfun <C : MutableCollection<in Int>> IntArray.filterTo(
destination: C,
predicate: (Int) -> Boolean
): Cfun <C : MutableCollection<in Long>> LongArray.filterTo(
destination: C,
predicate: (Long) -> Boolean
): Cfun <C : MutableCollection<in Float>> FloatArray.filterTo(
destination: C,
predicate: (Float) -> Boolean
): Cfun <C : MutableCollection<in Double>> DoubleArray.filterTo(
destination: C,
predicate: (Double) -> Boolean
): Cfun <C : MutableCollection<in Boolean>> BooleanArray.filterTo(
destination: C,
predicate: (Boolean) -> Boolean
): Cfun <C : MutableCollection<in Char>> CharArray.filterTo(
destination: C,
predicate: (Char) -> Boolean
): Cfun <T, C : MutableCollection<in T>> Iterable<T>.filterTo(
destination: C,
predicate: (T) -> Boolean
): Cfun <C : MutableCollection<in UInt>> UIntArray.filterTo(
destination: C,
predicate: (UInt) -> Boolean
): Cfun <C : MutableCollection<in ULong>> ULongArray.filterTo(
destination: C,
predicate: (ULong) -> Boolean
): Cfun <C : MutableCollection<in UByte>> UByteArray.filterTo(
destination: C,
predicate: (UByte) -> Boolean
): Cfun <C : MutableCollection<in UShort>> UShortArray.filterTo(
destination: C,
predicate: (UShort) -> Boolean
): CAppends all entries matching the given predicate into the mutable map given as destination parameter.
fun <K, V, M : MutableMap<in K, in V>> Map<out K, V>.filterTo(
destination: M,
predicate: (Entry<K, V>) -> Boolean
): Mfind
Returns the first element matching the given predicate, or null if no such element was found.
fun <T> Array<out T>.find(predicate: (T) -> Boolean): T?fun ByteArray.find(predicate: (Byte) -> Boolean): Byte?fun ShortArray.find(predicate: (Short) -> Boolean): Short?fun IntArray.find(predicate: (Int) -> Boolean): Int?fun LongArray.find(predicate: (Long) -> Boolean): Long?fun FloatArray.find(predicate: (Float) -> Boolean): Float?fun DoubleArray.find(predicate: (Double) -> Boolean): Double?fun BooleanArray.find(
predicate: (Boolean) -> Boolean
): Boolean?fun CharArray.find(predicate: (Char) -> Boolean): Char?fun <T> Iterable<T>.find(predicate: (T) -> Boolean): T?fun ULongArray.find(predicate: (ULong) -> Boolean): ULong?fun UByteArray.find(predicate: (UByte) -> Boolean): UByte?fun UShortArray.find(predicate: (UShort) -> Boolean): UShort?findLast
Returns the last element matching the given predicate, or null if no such element was found.
fun <T> Array<out T>.findLast(predicate: (T) -> Boolean): T?fun ByteArray.findLast(predicate: (Byte) -> Boolean): Byte?fun ShortArray.findLast(
predicate: (Short) -> Boolean
): Short?fun IntArray.findLast(predicate: (Int) -> Boolean): Int?fun LongArray.findLast(predicate: (Long) -> Boolean): Long?fun FloatArray.findLast(
predicate: (Float) -> Boolean
): Float?fun DoubleArray.findLast(
predicate: (Double) -> Boolean
): Double?fun BooleanArray.findLast(
predicate: (Boolean) -> Boolean
): Boolean?fun CharArray.findLast(predicate: (Char) -> Boolean): Char?fun <T> Iterable<T>.findLast(predicate: (T) -> Boolean): T?fun <T> List<T>.findLast(predicate: (T) -> Boolean): T?fun ULongArray.findLast(
predicate: (ULong) -> Boolean
): ULong?fun UByteArray.findLast(
predicate: (UByte) -> Boolean
): UByte?fun UShortArray.findLast(
predicate: (UShort) -> Boolean
): UShort?first
Returns the first element.
fun <T> Array<out T>.first(): Tfun ByteArray.first(): Bytefun ShortArray.first(): Shortfun IntArray.first(): Intfun LongArray.first(): Longfun FloatArray.first(): Floatfun DoubleArray.first(): Doublefun BooleanArray.first(): Booleanfun CharArray.first(): Charfun <T> Iterable<T>.first(): Tfun <T> List<T>.first(): Tfun ULongArray.first(): ULongfun UByteArray.first(): UBytefun UShortArray.first(): UShortReturns the first element matching the given predicate.
fun <T> Array<out T>.first(predicate: (T) -> Boolean): Tfun ByteArray.first(predicate: (Byte) -> Boolean): Bytefun ShortArray.first(predicate: (Short) -> Boolean): Shortfun IntArray.first(predicate: (Int) -> Boolean): Intfun LongArray.first(predicate: (Long) -> Boolean): Longfun FloatArray.first(predicate: (Float) -> Boolean): Floatfun DoubleArray.first(predicate: (Double) -> Boolean): Doublefun BooleanArray.first(
predicate: (Boolean) -> Boolean
): Booleanfun CharArray.first(predicate: (Char) -> Boolean): Charfun <T> Iterable<T>.first(predicate: (T) -> Boolean): Tfun ULongArray.first(predicate: (ULong) -> Boolean): ULongfun UByteArray.first(predicate: (UByte) -> Boolean): UBytefun UShortArray.first(predicate: (UShort) -> Boolean): UShortfirstNotNullOf
Returns the first non-null value produced by transform function being applied to elements of this array in iteration order, or throws NoSuchElementException if no non-null value was produced.
fun <T, R : Any> Array<out T>.firstNotNullOf(
transform: (T) -> R?
): RReturns the first non-null value produced by transform function being applied to elements of this collection in iteration order, or throws NoSuchElementException if no non-null value was produced.
fun <T, R : Any> Iterable<T>.firstNotNullOf(
transform: (T) -> R?
): RReturns the first non-null value produced by transform function being applied to entries of this map in iteration order, or throws NoSuchElementException if no non-null value was produced.
firstNotNullOfOrNull
Returns the first non-null value produced by transform function being applied to elements of this array in iteration order,
or null if no non-null value was produced.
fun <T, R : Any> Array<out T>.firstNotNullOfOrNull(
transform: (T) -> R?
): R?firstOrNull
Returns the first element, or null if the array is empty.
fun <T> Array<out T>.firstOrNull(): T?fun ByteArray.firstOrNull(): Byte?fun ShortArray.firstOrNull(): Short?fun IntArray.firstOrNull(): Int?fun LongArray.firstOrNull(): Long?fun FloatArray.firstOrNull(): Float?fun DoubleArray.firstOrNull(): Double?fun BooleanArray.firstOrNull(): Boolean?fun CharArray.firstOrNull(): Char?fun ULongArray.firstOrNull(): ULong?fun UByteArray.firstOrNull(): UByte?fun UShortArray.firstOrNull(): UShort?Returns the first element matching the given predicate, or null if element was not found.
fun <T> Array<out T>.firstOrNull(
predicate: (T) -> Boolean
): T?fun ByteArray.firstOrNull(
predicate: (Byte) -> Boolean
): Byte?fun ShortArray.firstOrNull(
predicate: (Short) -> Boolean
): Short?fun IntArray.firstOrNull(predicate: (Int) -> Boolean): Int?fun LongArray.firstOrNull(
predicate: (Long) -> Boolean
): Long?fun FloatArray.firstOrNull(
predicate: (Float) -> Boolean
): Float?fun DoubleArray.firstOrNull(
predicate: (Double) -> Boolean
): Double?fun BooleanArray.firstOrNull(
predicate: (Boolean) -> Boolean
): Boolean?fun CharArray.firstOrNull(
predicate: (Char) -> Boolean
): Char?fun <T> Iterable<T>.firstOrNull(
predicate: (T) -> Boolean
): T?fun ULongArray.firstOrNull(
predicate: (ULong) -> Boolean
): ULong?fun UByteArray.firstOrNull(
predicate: (UByte) -> Boolean
): UByte?fun UShortArray.firstOrNull(
predicate: (UShort) -> Boolean
): UShort?Returns the first element, or null if the collection is empty.
fun <T> Iterable<T>.firstOrNull(): T?Returns the first element, or null if the list is empty.
fun <T> List<T>.firstOrNull(): T?flatMap
Returns a single list of all elements yielded from results of transform function being invoked on each element of original array.
fun <R> ShortArray.flatMap(
transform: (Short) -> Iterable<R>
): List<R>fun <R> FloatArray.flatMap(
transform: (Float) -> Iterable<R>
): List<R>fun <R> DoubleArray.flatMap(
transform: (Double) -> Iterable<R>
): List<R>fun <R> BooleanArray.flatMap(
transform: (Boolean) -> Iterable<R>
): List<R>fun <R> ULongArray.flatMap(
transform: (ULong) -> Iterable<R>
): List<R>fun <R> UByteArray.flatMap(
transform: (UByte) -> Iterable<R>
): List<R>fun <R> UShortArray.flatMap(
transform: (UShort) -> Iterable<R>
): List<R>Returns a single list of all elements yielded from results of transform function being invoked on each element of original collection.
flatMapIndexed
Returns a single list of all elements yielded from results of transform function being invoked on each element and its index in the original array.
fun <R> ShortArray.flatMapIndexed(
transform: (index: Int, Short) -> Iterable<R>
): List<R>fun <R> FloatArray.flatMapIndexed(
transform: (index: Int, Float) -> Iterable<R>
): List<R>fun <R> DoubleArray.flatMapIndexed(
transform: (index: Int, Double) -> Iterable<R>
): List<R>fun <R> BooleanArray.flatMapIndexed(
transform: (index: Int, Boolean) -> Iterable<R>
): List<R>fun <R> ULongArray.flatMapIndexed(
transform: (index: Int, ULong) -> Iterable<R>
): List<R>fun <R> UByteArray.flatMapIndexed(
transform: (index: Int, UByte) -> Iterable<R>
): List<R>fun <R> UShortArray.flatMapIndexed(
transform: (index: Int, UShort) -> Iterable<R>
): List<R>Returns a single list of all elements yielded from results of transform function being invoked on each element and its index in the original collection.
flatMapIndexedTo
Appends all elements yielded from results of transform function being invoked on each element and its index in the original array, to the given destination.
fun <T, R, C : MutableCollection<in R>> Array<out T>.flatMapIndexedTo(
destination: C,
transform: (index: Int, T) -> Iterable<R>
): Cfun <R, C : MutableCollection<in R>> ByteArray.flatMapIndexedTo(
destination: C,
transform: (index: Int, Byte) -> Iterable<R>
): Cfun <R, C : MutableCollection<in R>> ShortArray.flatMapIndexedTo(
destination: C,
transform: (index: Int, Short) -> Iterable<R>
): Cfun <R, C : MutableCollection<in R>> IntArray.flatMapIndexedTo(
destination: C,
transform: (index: Int, Int) -> Iterable<R>
): Cfun <R, C : MutableCollection<in R>> LongArray.flatMapIndexedTo(
destination: C,
transform: (index: Int, Long) -> Iterable<R>
): Cfun <R, C : MutableCollection<in R>> FloatArray.flatMapIndexedTo(
destination: C,
transform: (index: Int, Float) -> Iterable<R>
): Cfun <R, C : MutableCollection<in R>> DoubleArray.flatMapIndexedTo(
destination: C,
transform: (index: Int, Double) -> Iterable<R>
): Cfun <R, C : MutableCollection<in R>> BooleanArray.flatMapIndexedTo(
destination: C,
transform: (index: Int, Boolean) -> Iterable<R>
): Cfun <R, C : MutableCollection<in R>> CharArray.flatMapIndexedTo(
destination: C,
transform: (index: Int, Char) -> Iterable<R>
): Cfun <T, R, C : MutableCollection<in R>> Array<out T>.flatMapIndexedTo(
destination: C,
transform: (index: Int, T) -> Sequence<R>
): Cfun <R, C : MutableCollection<in R>> UIntArray.flatMapIndexedTo(
destination: C,
transform: (index: Int, UInt) -> Iterable<R>
): Cfun <R, C : MutableCollection<in R>> ULongArray.flatMapIndexedTo(
destination: C,
transform: (index: Int, ULong) -> Iterable<R>
): Cfun <R, C : MutableCollection<in R>> UByteArray.flatMapIndexedTo(
destination: C,
transform: (index: Int, UByte) -> Iterable<R>
): Cfun <R, C : MutableCollection<in R>> UShortArray.flatMapIndexedTo(
destination: C,
transform: (index: Int, UShort) -> Iterable<R>
): CAppends all elements yielded from results of transform function being invoked on each element and its index in the original collection, to the given destination.
fun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapIndexedTo(
destination: C,
transform: (index: Int, T) -> Iterable<R>
): Cfun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapIndexedTo(
destination: C,
transform: (index: Int, T) -> Sequence<R>
): CflatMapTo
Appends all elements yielded from results of transform function being invoked on each element of original array, to the given destination.
fun <T, R, C : MutableCollection<in R>> Array<out T>.flatMapTo(
destination: C,
transform: (T) -> Iterable<R>
): Cfun <R, C : MutableCollection<in R>> ByteArray.flatMapTo(
destination: C,
transform: (Byte) -> Iterable<R>
): Cfun <R, C : MutableCollection<in R>> ShortArray.flatMapTo(
destination: C,
transform: (Short) -> Iterable<R>
): Cfun <R, C : MutableCollection<in R>> IntArray.flatMapTo(
destination: C,
transform: (Int) -> Iterable<R>
): Cfun <R, C : MutableCollection<in R>> LongArray.flatMapTo(
destination: C,
transform: (Long) -> Iterable<R>
): Cfun <R, C : MutableCollection<in R>> FloatArray.flatMapTo(
destination: C,
transform: (Float) -> Iterable<R>
): Cfun <R, C : MutableCollection<in R>> DoubleArray.flatMapTo(
destination: C,
transform: (Double) -> Iterable<R>
): Cfun <R, C : MutableCollection<in R>> BooleanArray.flatMapTo(
destination: C,
transform: (Boolean) -> Iterable<R>
): Cfun <R, C : MutableCollection<in R>> CharArray.flatMapTo(
destination: C,
transform: (Char) -> Iterable<R>
): Cfun <T, R, C : MutableCollection<in R>> Array<out T>.flatMapTo(
destination: C,
transform: (T) -> Sequence<R>
): Cfun <R, C : MutableCollection<in R>> UIntArray.flatMapTo(
destination: C,
transform: (UInt) -> Iterable<R>
): Cfun <R, C : MutableCollection<in R>> ULongArray.flatMapTo(
destination: C,
transform: (ULong) -> Iterable<R>
): Cfun <R, C : MutableCollection<in R>> UByteArray.flatMapTo(
destination: C,
transform: (UByte) -> Iterable<R>
): C