Пакет kotlin.collections
Типы коллекций, такие как Iterable, Collection, List, Set, Map и связанные с ними функции верхнего уровня и расширения.
Типы
AbstractCollection
Предоставляет скелетное (базовое) реализацию интерфейса Collection для только для чтения.
abstract class AbstractCollection<out E> : Collection<E>
AbstractIterator
Базовый класс для упрощения реализации итераторов, таким образом, что реализации нужно только реализовать computeNext для реализации итератора, вызывая done, когда итерация завершена.
abstract class AbstractIterator<T> : Iterator<T>
AbstractList
Предоставляет скелетную (базовую) реализацию интерфейса List для только для чтения.
abstract class AbstractList<out E> : AbstractCollection<E>, List<E>
AbstractMap
Предоставляет скелетную (базовую) реализацию интерфейса Map для только для чтения.
abstract class AbstractMap<K, out V> : Map<K, V>
AbstractMutableCollection
Предоставляет скелетную (базовую) реализацию интерфейса MutableCollection.
abstract class AbstractMutableCollection<E> : MutableCollection<E>
abstract class AbstractMutableCollection<E> : MutableCollection<E>, AbstractCollection<E>
abstract class AbstractMutableCollection<E> : AbstractCollection<E>, MutableCollection<E>
AbstractMutableList
Предоставляет скелетную (базовую) реализацию интерфейса MutableList.
abstract class AbstractMutableList<E> : MutableList<E>
abstract class AbstractMutableList<E> : MutableList<E>, AbstractList<E>
abstract class AbstractMutableList<E> : AbstractMutableCollection<E>, MutableList<E>
AbstractMutableMap
Предоставляет скелетную (базовую) реализацию интерфейса MutableMap.
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
Предоставляет скелетную (базовую) реализацию интерфейса MutableSet.
abstract class AbstractMutableSet<E> : MutableSet<E>
abstract class AbstractMutableSet<E> : MutableSet<E>, AbstractSet<E>
abstract class AbstractMutableSet<E> : AbstractMutableCollection<E>, MutableSet<E>
AbstractSet
Предоставляет скелетную (базовую) реализацию интерфейса Set для только для чтения.
abstract class AbstractSet<out E> : AbstractCollection<E>, Set<E>
ArrayDeque
Реализация структуры данных deque с изменяемым размером массива.
class ArrayDeque<E> : AbstractMutableList<E>
ArrayList
Предоставляет реализацию MutableList, которая использует изменяемый массив в качестве базового хранилища.
class ArrayList<E> : MutableList<E>, RandomAccess
typealias ArrayList<E> = ArrayList<E>
open class ArrayList<E> : AbstractMutableList<E>, MutableList<E>, RandomAccess
BooleanIterator
Итератор по последовательности значений типа Boolean.
abstract class BooleanIterator : Iterator<Boolean>
ByteIterator
Итератор по последовательности значений типа Byte.
abstract class ByteIterator : Iterator<Byte>
CharIterator
Итератор по последовательности значений типа Char.
abstract class CharIterator : Iterator<Char>
Collection
Обобщенное множество элементов. Методы в этом интерфейсе поддерживают только чтение множества; доступ для чтения/записи поддерживается интерфейсом MutableCollection.
interface Collection<out E> : Iterable<E>
DoubleIterator
Итератор по последовательности значений типа Double.
abstract class DoubleIterator : Iterator<Double>
FloatIterator
Итератор по последовательности значений типа Float.
abstract class FloatIterator : Iterator<Float>
Группировка
Представляет источник элементов с функцией keyOf, которая может быть применена к каждому элементу для получения его ключа.
interface Grouping<T, out K>
HashMap
Реализация интерфейса MutableMap на основе хеш-таблицы.
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
Реализация интерфейса MutableSet, основанная на экземпляре HashMap.
class HashSet<E> : MutableSet<E>
typealias HashSet<E> = HashSet<E>
open class HashSet<E> : AbstractMutableSet<E>, MutableSet<E>
IndexedValue
Класс данных, представляющий значение из коллекции или последовательности вместе с его индексом в этой коллекции или последовательности.
data class IndexedValue<out T>
IntIterator
Итератор по последовательности значений типа Int.
abstract class IntIterator : Iterator<Int>
Iterable
Классы, которые наследуют от этого интерфейса, могут быть представлены как последовательность элементов, по которым можно перебрать.
interface Iterable<out T>
Iterator
Итератор по коллекции или другому объекту, который может быть представлен как последовательность элементов. Позволяет последовательно обращаться к элементам.
interface Iterator<out T>
LinkedHashMap
Реализация интерфейса MutableMap на основе хеш-таблицы, которая дополнительно сохраняет порядок вставки записей во время итерации.
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>
LinkedHashSet
Реализация интерфейса MutableSet, основанная на экземпляре LinkedHashMap.
class LinkedHashSet<E> : MutableSet<E>
typealias LinkedHashSet<E> = LinkedHashSet<E>
open class LinkedHashSet<E> : HashSet<E>, MutableSet<E>
Список
Обобщенная упорядоченная коллекция элементов. Методы в этом интерфейсе поддерживают только чтение списка; чтение/запись поддерживается через интерфейс MutableList.
interface List<out E> : Collection<E>
Итератор списка
Итератор по коллекции, поддерживающий индексированный доступ.
interface ListIterator<out T> : Iterator<T>
LongIterator
Итератор по последовательности значений типа Long.
abstract class LongIterator : Iterator<Long>
Карта
Коллекция, которая хранит пары объектов (ключи и значения) и поддерживает эффективное получение значения, соответствующего каждому ключу. Ключи карты уникальны; карта хранит только одно значение для каждого ключа. Методы в этом интерфейсе поддерживают только чтение карты; чтение/запись поддерживается через интерфейс MutableMap.
interface Map<K, out V>
Изменяемая коллекция
Обобщенная коллекция элементов, которая поддерживает добавление и удаление элементов.
interface MutableCollection<E> : Collection<E>, MutableIterable<E>
Изменяемая последовательность
Классы, которые наследуют от этого интерфейса, могут быть представлены как последовательность элементов, по которым можно перебрать, и которые поддерживают удаление элементов во время итерации.
interface MutableIterable<out T> : Iterable<T>
Изменяемый итератор
Итератор по изменяемой коллекции. Предоставляет возможность удаления элементов во время итерации.
interface MutableIterator<out T> : Iterator<T>
Изменяемый список
Обобщенная упорядоченная коллекция элементов, которая поддерживает добавление и удаление элементов.
interface MutableList<E> : List<E>, MutableCollection<E>
MutableListIterator
Итератор по изменяемой коллекции, поддерживающий индексированный доступ. Обеспечивает возможность добавления, изменения и удаления элементов во время итерации.
interface MutableListIterator<T> : ListIterator<T>, MutableIterator<T>
MutableMap
Изменяемая коллекция, хранящая пары объектов (ключи и значения) и поддерживающая эффективное получение значения, соответствующего каждому ключу. Ключи карты уникальны; карта содержит только одно значение для каждого ключа.
interface MutableMap<K, V> : Map<K, V>
MutableSet
Обобщенная неупорядоченная коллекция элементов, не поддерживающая дубликаты элементов и поддерживающая добавление и удаление элементов.
interface MutableSet<E> : Set<E>, MutableCollection<E>
RandomAccess
Маркерный интерфейс, указывающий, что реализация List поддерживает быстрый индексированный доступ.
interface RandomAccess
typealias RandomAccess = RandomAccess
Set
Обобщенная неупорядоченная коллекция элементов, не поддерживающая дубликаты элементов. Методы в этом интерфейсе поддерживают только чтение коллекции; чтение/запись поддерживается через интерфейс MutableSet.
interface Set<out E> : Collection<E>
ShortIterator
Итератор по последовательности значений типа Short.
abstract class ShortIterator : Iterator<Short>
Расширения для внешних классов
java.util.concurrent.ConcurrentMap
java.util.Enumeration
Свойства
indices
Возвращает диапазон допустимых индексов для массива.
val <T> Array<out T>.indices: IntRange
val ByteArray.indices: IntRange
val ShortArray.indices: IntRange
val IntArray.indices: IntRange
val LongArray.indices: IntRange
val FloatArray.indices: IntRange
val DoubleArray.indices: IntRange
val BooleanArray.indices: IntRange
val CharArray.indices: IntRange
val UIntArray.indices: IntRange
val ULongArray.indices: IntRange
val UByteArray.indices: IntRange
val UShortArray.indices: IntRange
Возвращает IntRange допустимых индексов для этой коллекции.
val Collection<*>.indices: IntRange
lastIndex
Возвращает последний допустимый индекс для массива.
val <T> Array<out T>.lastIndex: Int
val ByteArray.lastIndex: Int
val ShortArray.lastIndex: Int
val IntArray.lastIndex: Int
val LongArray.lastIndex: Int
val FloatArray.lastIndex: Int
val DoubleArray.lastIndex: Int
val BooleanArray.lastIndex: Int
val CharArray.lastIndex: Int
val UIntArray.lastIndex: Int
val ULongArray.lastIndex: Int
val UByteArray.lastIndex: Int
val UShortArray.lastIndex: Int
Возвращает индекс последнего элемента в списке или -1, если список пуст.
val <T> List<T>.lastIndex: Int
Функции
addAll
Добавляет все элементы заданного элемента коллекции в эту MutableCollection.
fun <T> MutableCollection<in T>.addAll( elements: Iterable<T> ): Boolean
Добавляет все элементы заданной последовательности элементов в эту MutableCollection.
fun <T> MutableCollection<in T>.addAll( elements: Sequence<T> ): Boolean
Добавляет все элементы заданного массива элементов в эту MutableCollection.
fun <T> MutableCollection<in T>.addAll( elements: Array<out T> ): Boolean
aggregate
Группирует элементы из источника Grouping по ключу и применяет операцию к элементам каждой группы последовательно, передавая предыдущее накопленное значение и текущий элемент в качестве аргументов, и сохраняет результаты в новой карте.
fun <T, K, R> Grouping<T, K>.aggregate( operation: (key: K, accumulator: R?, element: T, first: Boolean) -> R ): Map<K, R>
aggregateTo
Группирует элементы из источника Grouping по ключу и применяет операцию к элементам каждой группы последовательно, передавая предыдущее накопленное значение и текущий элемент в качестве аргументов, и сохраняет результаты в заданной целевой карте.
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 ): M
all
Возвращает true если все элементы соответствуют заданному предикату.
fun <T> Array<out T>.all(predicate: (T) -> Boolean): Boolean
fun ByteArray.all(predicate: (Byte) -> Boolean): Boolean
fun ShortArray.all(predicate: (Short) -> Boolean): Boolean
fun IntArray.all(predicate: (Int) -> Boolean): Boolean
fun LongArray.all(predicate: (Long) -> Boolean): Boolean
fun FloatArray.all(predicate: (Float) -> Boolean): Boolean
fun DoubleArray.all(predicate: (Double) -> Boolean): Boolean
fun BooleanArray.all( predicate: (Boolean) -> Boolean ): Boolean
fun CharArray.all(predicate: (Char) -> Boolean): Boolean
fun <T> Iterable<T>.all(predicate: (T) -> Boolean): Boolean
fun UIntArray.all(predicate: (UInt) -> Boolean): Boolean
fun ULongArray.all(predicate: (ULong) -> Boolean): Boolean
fun UByteArray.all(predicate: (UByte) -> Boolean): Boolean
fun UShortArray.all(predicate: (UShort) -> Boolean): Boolean
Возвращает true если все записи соответствуют заданному предикату.
fun <K, V> Map<out K, V>.all( predicate: (Entry<K, V>) -> Boolean ): Boolean
any
Возвращает true если массив содержит хотя бы один элемент.
fun <T> Array<out T>.any(): Boolean
fun ByteArray.any(): Boolean
fun ShortArray.any(): Boolean
fun IntArray.any(): Boolean
fun LongArray.any(): Boolean
fun FloatArray.any(): Boolean
fun DoubleArray.any(): Boolean
fun BooleanArray.any(): Boolean
fun CharArray.any(): Boolean
fun UIntArray.any(): Boolean
fun ULongArray.any(): Boolean
fun UByteArray.any(): Boolean
fun UShortArray.any(): Boolean
Возвращает true если хотя бы один элемент соответствует заданному предикату.
fun <T> Array<out T>.any(predicate: (T) -> Boolean): Boolean
fun ByteArray.any(predicate: (Byte) -> Boolean): Boolean
fun ShortArray.any(predicate: (Short) -> Boolean): Boolean
fun IntArray.any(predicate: (Int) -> Boolean): Boolean
fun LongArray.any(predicate: (Long) -> Boolean): Boolean
fun FloatArray.any(predicate: (Float) -> Boolean): Boolean
fun DoubleArray.any(predicate: (Double) -> Boolean): Boolean
fun BooleanArray.any( predicate: (Boolean) -> Boolean ): Boolean
fun CharArray.any(predicate: (Char) -> Boolean): Boolean
fun <T> Iterable<T>.any(predicate: (T) -> Boolean): Boolean
fun UIntArray.any(predicate: (UInt) -> Boolean): Boolean
fun ULongArray.any(predicate: (ULong) -> Boolean): Boolean
fun UByteArray.any(predicate: (UByte) -> Boolean): Boolean
fun UShortArray.any(predicate: (UShort) -> Boolean): Boolean
Возвращает true если коллекция содержит хотя бы один элемент.
fun <T> Iterable<T>.any(): Boolean
Возвращает true если карта содержит хотя бы одну запись.
fun <K, V> Map<out K, V>.any(): Boolean
Возвращает true если хотя бы одна запись соответствует заданному предикату.
fun <K, V> Map<out K, V>.any( predicate: (Entry<K, V>) -> Boolean ): Boolean
arrayListOf
Возвращает пустой новый ArrayList.
fun <T> arrayListOf(): ArrayList<T>
Возвращает новый ArrayList с заданными элементами.
fun <T> arrayListOf(vararg elements: T): ArrayList<T>
asByteArray
Возвращает массив типа ByteArray, который является представлением этого массива, где каждый элемент — это знаковое повторное толкование соответствующего элемента этого массива.
fun UByteArray.asByteArray(): ByteArray
asIntArray
Возвращает массив типа IntArray, который является представлением этого массива, где каждый элемент — это знаковое повторное толкование соответствующего элемента этого массива.
fun UIntArray.asIntArray(): IntArray
asIterable
Создает экземпляр Iterable, который оборачивает исходный массив, возвращая его элементы при итерации.
fun <T> any_array<T>.asIterable(): Iterable<T>
Возвращает эту коллекцию в виде Iterable.
fun <T> Iterable<T>.asIterable(): Iterable<T>
Создает экземпляр Iterable, который оборачивает исходную карту, возвращая её записи при итерации.
fun <K, V> Map<out K, V>.asIterable(): Iterable<Entry<K, V>>
asList
Возвращает List, который оборачивает исходный массив.
fun <T> Array<out T>.asList(): List<T>
fun ByteArray.asList(): List<Byte>
fun ShortArray.asList(): List<Short>
fun IntArray.asList(): List<Int>
fun LongArray.asList(): List<Long>
fun FloatArray.asList(): List<Float>
fun DoubleArray.asList(): List<Double>
fun BooleanArray.asList(): List<Boolean>
fun CharArray.asList(): List<Char>
fun UIntArray.asList(): List<UInt>
fun ULongArray.asList(): List<ULong>
fun UByteArray.asList(): List<UByte>
fun UShortArray.asList(): List<UShort>
asLongArray
Возвращает массив типа LongArray, который является представлением этого массива, где каждый элемент — это знаковое повторное толкование соответствующего элемента этого массива.
fun ULongArray.asLongArray(): LongArray
asReversed
Возвращает инвертированный вид для чтения исходного списка. Все изменения, внесенные в исходный список, будут отражены в инвертированном.
fun <T> List<T>.asReversed(): List<T>
Возвращает инвертированный изменяемый вид исходного изменяемого списка. Все изменения, внесенные в исходный список, будут отражены в инвертированном и наоборот.
fun <T> MutableList<T>.asReversed(): MutableList<T>
asSequence
Создаёт экземпляр Sequence, который оборачивает исходный массив, возвращая его элементы при итерации.
fun <T> any_array<T>.asSequence(): Sequence<T>
Создаёт экземпляр Sequence, который оборачивает исходную коллекцию, возвращая её элементы при итерации.
fun <T> Iterable<T>.asSequence(): Sequence<T>
Создаёт экземпляр Sequence, который оборачивает исходный map, возвращая его пары ключ-значение при итерации.
fun <K, V> Map<out K, V>.asSequence(): Sequence<Entry<K, V>>
asShortArray
Возвращает массив типа ShortArray, который является представлением этого массива, где каждый элемент является знаковым переинтерпретацией соответствующего элемента этого массива.
fun UShortArray.asShortArray(): ShortArray
associate
associateBy
Возвращает Map, содержащий элементы из данного массива, индексированные по ключу, полученному из функции keySelector, применённой к каждому элементу.
fun <T, K> any_array<T>.associateBy( keySelector: (T) -> K ): Map<K, T>
Возвращает Map, содержащий значения, полученные из функций valueTransform и индексированные по функциям keySelector, применённым к элементам данного массива.
fun <T, K, V> any_array<T>.associateBy( keySelector: (T) -> K, valueTransform: (T) -> V ): Map<K, V>
Возвращает Map, содержащий элементы из данной коллекции, индексированные по ключу, полученному из функции keySelector, применённой к каждому элементу.
fun <T, K> Iterable<T>.associateBy( keySelector: (T) -> K ): Map<K, T>
Возвращает Map, содержащий значения, полученные из функций valueTransform и индексированные по функциям keySelector, применённым к элементам данной коллекции.
fun <T, K, V> Iterable<T>.associateBy( keySelector: (T) -> K, valueTransform: (T) -> V ): Map<K, V>
associateByTo
Заполняет и возвращает изменяемую карту назначения парами ключ-значение, где ключ предоставляется функцией keySelector, применённой к каждому элементу заданного массива, а значением является сам элемент.
fun <T, K, M : MutableMap<in K, in T>> any_array<T>.associateByTo( destination: M, keySelector: (T) -> K ): M
Заполняет и возвращает изменяемую карту назначения парами ключ-значение, где ключ предоставляется функцией keySelector, а значение предоставляется функцией valueTransform, применённой к элементам заданного массива.
fun <T, K, V, M : MutableMap<in K, in V>> any_array<T>.associateByTo( destination: M, keySelector: (T) -> K, valueTransform: (T) -> V ): M
Заполняет и возвращает изменяемую карту назначения парами ключ-значение, где ключ предоставляется функцией keySelector, применённой к каждому элементу заданного набора, а значением является сам элемент.
fun <T, K, M : MutableMap<in K, in T>> Iterable<T>.associateByTo( destination: M, keySelector: (T) -> K ): M
Заполняет и возвращает изменяемую карту назначения парами ключ-значение, где ключ предоставляется функцией keySelector, а значение предоставляется функцией valueTransform, применённой к элементам заданного набора.
fun <T, K, V, M : MutableMap<in K, in V>> Iterable<T>.associateByTo( destination: M, keySelector: (T) -> K, valueTransform: (T) -> V ): M
associateTo
Заполняет и возвращает изменяемую карту назначения парами ключ-значение, предоставленными функцией transform, применённой к каждому элементу заданного массива.
fun <T, K, V, M : MutableMap<in K, in V>> any_array<T>.associateTo( destination: M, transform: (T) -> Pair<K, V> ): M
Заполняет и возвращает изменяемую карту назначения парами ключ-значение, предоставленными функцией transform, применённой к каждому элементу заданного набора.
fun <T, K, V, M : MutableMap<in K, in V>> Iterable<T>.associateTo( destination: M, transform: (T) -> Pair<K, V> ): M
associateWith
Возвращает карту, где ключами являются элементы из заданного массива, а значениями — значения, полученные из функции valueSelector, применённой к каждому элементу.
fun <K, V> Array<out K>.associateWith( valueSelector: (K) -> V ): Map<K, V>
fun <V> ByteArray.associateWith( valueSelector: (Byte) -> V ): Map<Byte, V>
fun <V> ShortArray.associateWith( valueSelector: (Short) -> V ): Map<Short, V>
fun <V> IntArray.associateWith( valueSelector: (Int) -> V ): Map<Int, V>
fun <V> LongArray.associateWith( valueSelector: (Long) -> V ): Map<Long, 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> CharArray.associateWith( valueSelector: (Char) -> V ): Map<Char, V>
fun <V> UIntArray.associateWith( valueSelector: (UInt) -> V ): Map<UInt, 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>
Возвращает карту, где ключами являются элементы из заданного набора, а значениями — значения, полученные из функции valueSelector, применённой к каждому элементу.
fun <K, V> Iterable<K>.associateWith( valueSelector: (K) -> V ): Map<K, V>
associateWithTo
Заполняет и возвращает изменяемую карту destination парами ключ-значение для каждого элемента заданного массива, где ключ — сам элемент, а значение — результат применения функции valueSelector к этому ключу.
fun <K, V, M : MutableMap<in K, in V>> Array<out K>.associateWithTo( destination: M, valueSelector: (K) -> V ): M
fun <V, M : MutableMap<in Byte, in V>> ByteArray.associateWithTo( destination: M, valueSelector: (Byte) -> V ): M
fun <V, M : MutableMap<in Short, in V>> ShortArray.associateWithTo( destination: M, valueSelector: (Short) -> V ): M
fun <V, M : MutableMap<in Int, in V>> IntArray.associateWithTo( destination: M, valueSelector: (Int) -> V ): M
fun <V, M : MutableMap<in Long, in V>> LongArray.associateWithTo( destination: M, valueSelector: (Long) -> V ): M
fun <V, M : MutableMap<in Float, in V>> FloatArray.associateWithTo( destination: M, valueSelector: (Float) -> V ): M
fun <V, M : MutableMap<in Double, in V>> DoubleArray.associateWithTo( destination: M, valueSelector: (Double) -> V ): M
fun <V, M : MutableMap<in Boolean, in V>> BooleanArray.associateWithTo( destination: M, valueSelector: (Boolean) -> V ): M
fun <V, M : MutableMap<in Char, in V>> CharArray.associateWithTo( destination: M, valueSelector: (Char) -> V ): M
fun <V, M : MutableMap<in UInt, in V>> UIntArray.associateWithTo( destination: M, valueSelector: (UInt) -> V ): M
fun <V, M : MutableMap<in ULong, in V>> ULongArray.associateWithTo( destination: M, valueSelector: (ULong) -> V ): M
fun <V, M : MutableMap<in UByte, in V>> UByteArray.associateWithTo( destination: M, valueSelector: (UByte) -> V ): M
fun <V, M : MutableMap<in UShort, in V>> UShortArray.associateWithTo( destination: M, valueSelector: (UShort) -> V ): M
Заполняет и возвращает изменяемую карту destination парами ключ-значение для каждого элемента заданного набора, где ключ — сам элемент, а значение — результат применения функции valueSelector к этому ключу.
fun <K, V, M : MutableMap<in K, in V>> Iterable<K>.associateWithTo( destination: M, valueSelector: (K) -> V ): M
asUByteArray
Возвращает массив типа UByteArray, который является представлением этого массива, где каждый элемент — беззнаковое переинтерпретирование соответствующего элемента этого массива.
fun ByteArray.asUByteArray(): UByteArray
asUIntArray
Возвращает массив типа UIntArray, который является представлением этого массива, где каждый элемент — беззнаковое переинтерпретирование соответствующего элемента этого массива.
fun IntArray.asUIntArray(): UIntArray
asULongArray
Возвращает массив типа ULongArray, который является представлением этого массива, где каждый элемент — беззнаковое переинтерпретирование соответствующего элемента этого массива.
fun LongArray.asULongArray(): ULongArray
asUShortArray
Возвращает массив типа UShortArray, который является представлением этого массива, где каждый элемент — беззнаковое переинтерпретирование соответствующего элемента этого массива.
fun ShortArray.asUShortArray(): UShortArray
average
Возвращает среднее значение элементов в массиве.
fun Array<out Byte>.average(): Double
fun Array<out Short>.average(): Double
fun Array<out Int>.average(): Double
fun Array<out Long>.average(): Double
fun Array<out Float>.average(): Double
fun Array<out Double>.average(): Double
fun ByteArray.average(): Double
fun ShortArray.average(): Double
fun IntArray.average(): Double
fun LongArray.average(): Double
fun FloatArray.average(): Double
fun DoubleArray.average(): Double
Возвращает среднее значение элементов в коллекции.
fun Iterable<Byte>.average(): Double
fun Iterable<Short>.average(): Double
fun Iterable<Int>.average(): Double
fun Iterable<Long>.average(): Double
fun Iterable<Float>.average(): Double
fun Iterable<Double>.average(): Double
бинарный поиск
Ищет в этом списке или его диапазоне заданный элемент с помощью алгоритма бинарного поиска. Ожидается, что список отсортирован по возрастанию в соответствии с естественным порядком элементов Comparable, в противном случае результат не определён.
fun <T : Comparable<T>> List<T?>.binarySearch( element: T?, fromIndex: Int = 0, toIndex: Int = size ): Int
Ищет в этом списке или его диапазоне заданный элемент с помощью алгоритма бинарного поиска. Ожидается, что список отсортирован по возрастанию в соответствии с заданным компаратором, в противном случае результат не определён.
fun <T> List<T>.binarySearch( element: T, comparator: Comparator<in T>, fromIndex: Int = 0, toIndex: Int = size ): Int
Ищет в этом списке или его диапазоне элемент, для которого заданная функция сравнения возвращает ноль с помощью алгоритма бинарного поиска.
fun <T> List<T>.binarySearch( fromIndex: Int = 0, toIndex: Int = size, comparison: (T) -> Int ): Int
Ищет в массиве или в диапазоне массива заданный элемент с помощью алгоритма бинарного поиска. Ожидается, что массив отсортирован в соответствии с заданным компаратором, в противном случае результат не определён.
fun <T> Array<out T>.binarySearch( element: T, comparator: Comparator<in T>, fromIndex: Int = 0, toIndex: Int = size ): Int
Ищет в массиве или в диапазоне массива заданный элемент с помощью алгоритма бинарного поиска. Ожидается, что массив отсортирован, в противном случае результат не определён.
fun <T> Array<out T>.binarySearch( element: T, fromIndex: Int = 0, toIndex: Int = size ): Int
fun ByteArray.binarySearch( element: Byte, fromIndex: Int = 0, toIndex: Int = size ): Int
fun ShortArray.binarySearch( element: Short, fromIndex: Int = 0, toIndex: Int = size ): Int
fun IntArray.binarySearch( element: Int, fromIndex: Int = 0, toIndex: Int = size ): Int
fun LongArray.binarySearch( element: Long, fromIndex: Int = 0, toIndex: Int = size ): Int
fun FloatArray.binarySearch( element: Float, fromIndex: Int = 0, toIndex: Int = size ): Int
fun DoubleArray.binarySearch( element: Double, fromIndex: Int = 0, toIndex: Int = size ): Int
fun CharArray.binarySearch( element: Char, fromIndex: Int = 0, toIndex: Int = size ): Int
fun UIntArray.binarySearch( element: UInt, fromIndex: Int = 0, toIndex: Int = size ): Int
fun ULongArray.binarySearch( element: ULong, fromIndex: Int = 0, toIndex: Int = size ): Int
fun UByteArray.binarySearch( element: UByte, fromIndex: Int = 0, toIndex: Int = size ): Int
fun UShortArray.binarySearch( element: UShort, fromIndex: Int = 0, toIndex: Int = size ): Int
поиск по ключу
Ищет в этом списке или его диапазоне элемент, для которого значение ключа, возвращаемое заданной функцией выбора ключа, равно указанному значению ключа с использованием алгоритма бинарного поиска. Ожидается, что список отсортирован по возрастанию в соответствии с естественным порядком элементов Comparable, в противном случае результат не определён.
fun <T, K : Comparable<K>> List<T>.binarySearchBy( key: K?, fromIndex: Int = 0, toIndex: Int = size, selector: (T) -> K? ): Int
создание списка
Создаёт новый неизменяемый список, заполнив изменяемый список с помощью заданного действия и возвращает неизменяемый список с теми же элементами.
fun <E> buildList( builderAction: MutableList<E>.() -> Unit ): List<E>
fun <E> buildList( capacity: Int, builderAction: MutableList<E>.() -> Unit ): List<E>
создание карты
Создаёт новый неизменяемый словарь, заполнив изменяемый словарь с помощью заданного действия и возвращает неизменяемый словарь с теми же парами ключ-значение.
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>
создание набора
Создаёт новый неизменяемый набор, заполнив изменяемый набор с помощью заданного действия и возвращает неизменяемый набор с теми же элементами.
fun <E> buildSet( builderAction: MutableSet<E>.() -> Unit ): Set<E>
fun <E> buildSet( capacity: Int, builderAction: MutableSet<E>.() -> Unit ): Set<E>
разбиение на куски
Разбивает эту коллекцию на список подсписков, каждый из которых не превышает заданного размера.
fun <T> Iterable<T>.chunked(size: Int): List<List<T>>
Разбивает эту коллекцию на несколько списков, каждый из которых не превышает заданного размера, и применяет заданную функцию преобразования к каждому из них.
fun <T, R> Iterable<T>.chunked( size: Int, transform: (List<T>) -> R ): List<R>
component1
Возвращает 1-й элемент из массива.
operator fun <T> Array<out T>.component1(): T
operator fun ByteArray.component1(): Byte
operator fun ShortArray.component1(): Short
operator fun IntArray.component1(): Int
operator fun LongArray.component1(): Long
operator fun FloatArray.component1(): Float
operator fun DoubleArray.component1(): Double
operator fun BooleanArray.component1(): Boolean
operator fun CharArray.component1(): Char
operator fun UIntArray.component1(): UInt
operator fun ULongArray.component1(): ULong
operator fun UByteArray.component1(): UByte
operator fun UShortArray.component1(): UShort
Возвращает 1-й элемент из списка.
operator fun <T> List<T>.component1(): T
Возвращает ключевой компонент пары map.
operator fun <K, V> Entry<K, V>.component1(): K
component2
Возвращает 2-й элемент из массива.
operator fun <T> Array<out T>.component2(): T
operator fun ByteArray.component2(): Byte
operator fun ShortArray.component2(): Short
operator fun IntArray.component2(): Int
operator fun LongArray.component2(): Long
operator fun FloatArray.component2(): Float
operator fun DoubleArray.component2(): Double
operator fun BooleanArray.component2(): Boolean
operator fun CharArray.component2(): Char
operator fun UIntArray.component2(): UInt
operator fun ULongArray.component2(): ULong
operator fun UByteArray.component2(): UByte
operator fun UShortArray.component2(): UShort
Возвращает 2-й элемент из списка.
operator fun <T> List<T>.component2(): T
Возвращает компонент значения пары map.
operator fun <K, V> Entry<K, V>.component2(): V
component3
Возвращает 3-й элемент из массива.
operator fun <T> Array<out T>.component3(): T
operator fun ByteArray.component3(): Byte
operator fun ShortArray.component3(): Short
operator fun IntArray.component3(): Int
operator fun LongArray.component3(): Long
operator fun FloatArray.component3(): Float
operator fun DoubleArray.component3(): Double
operator fun BooleanArray.component3(): Boolean
operator fun CharArray.component3(): Char
operator fun UIntArray.component3(): UInt
operator fun ULongArray.component3(): ULong
operator fun UByteArray.component3(): UByte
operator fun UShortArray.component3(): UShort
Возвращает 3-й элемент из списка.
operator fun <T> List<T>.component3(): T
component4
Возвращает 4-й элемент из массива.
operator fun <T> Array<out T>.component4(): T
operator fun ByteArray.component4(): Byte
operator fun ShortArray.component4(): Short
operator fun IntArray.component4(): Int
operator fun LongArray.component4(): Long
operator fun FloatArray.component4(): Float
operator fun DoubleArray.component4(): Double
operator fun BooleanArray.component4(): Boolean
operator fun CharArray.component4(): Char
operator fun UIntArray.component4(): UInt
operator fun ULongArray.component4(): ULong
operator fun UByteArray.component4(): UByte
operator fun UShortArray.component4(): UShort
Возвращает 4-й элемент из списка.
operator fun <T> List<T>.component4(): T
component5
Возвращает 5-й элемент из массива.
operator fun <T> Array<out T>.component5(): T
operator fun ByteArray.component5(): Byte
operator fun ShortArray.component5(): Short
operator fun IntArray.component5(): Int
operator fun LongArray.component5(): Long
operator fun FloatArray.component5(): Float
operator fun DoubleArray.component5(): Double
operator fun BooleanArray.component5(): Boolean
operator fun CharArray.component5(): Char
operator fun UIntArray.component5(): UInt
operator fun ULongArray.component5(): ULong
operator fun UByteArray.component5(): UByte
operator fun UShortArray.component5(): UShort
Возвращает 5-й элемент из списка.
operator fun <T> List<T>.component5(): T
contains
Возвращает true если элемент найден в массиве.
operator fun <T> any_array<T>.contains(element: T): Boolean
Возвращает true если элемент найден в коллекции.
operator fun <T> Iterable<T>.contains(element: T): Boolean
Проверяет, содержит ли карта заданный ключ.
operator fun <K, V> Map<out K, V>.contains(key: K): Boolean
containsAll
Проверяет, содержатся ли все элементы в указанной коллекции в этой коллекции.
fun <T> Collection<T>.containsAll( elements: Collection<T> ): Boolean
containsKey
Возвращает true если карта содержит указанный ключ.
fun <K> Map<out K, *>.containsKey(key: K): Boolean
containsValue
Возвращает true если карта отображает один или несколько ключей на указанное значение.
fun <K, V> Map<K, V>.containsValue(value: V): Boolean
contentDeepEquals
Возвращает true если два указанных массива глубоко равны друг другу, т.е. содержат одинаковое количество одинаковых элементов в том же порядке.
infix fun <T> any_array<T>.contentDeepEquals( other: Array<out T> ): Boolean
contentDeepHashCode
Возвращает хэш-код, основанный на содержимом этого массива, как если бы он был списком. Вложенные массивы также обрабатываются как списки.
fun <T> any_array<T>.contentDeepHashCode(): Int
contentDeepToString
Возвращает строковое представление содержимого этого массива, как если бы он был списком List. Вложенные массивы также обрабатываются как списки.
fun <T> any_array<T>.contentDeepToString(): String
contentEquals
Возвращает true если два указанных массива структурно равны друг другу, т.е. содержат одинаковое количество одинаковых элементов в том же порядке.
infix fun UIntArray.contentEquals(other: UIntArray): Boolean
infix fun ULongArray.contentEquals( other: ULongArray ): Boolean
infix fun UByteArray.contentEquals( other: UByteArray ): Boolean
infix fun UShortArray.contentEquals( other: UShortArray ): Boolean
infix fun UIntArray?.contentEquals( other: UIntArray? ): Boolean
infix fun ULongArray?.contentEquals( other: ULongArray? ): Boolean
infix fun UByteArray?.contentEquals( other: UByteArray? ): Boolean
infix fun UShortArray?.contentEquals( other: UShortArray? ): Boolean
infix fun <T> Array<out T>.contentEquals( other: Array<out T> ): Boolean
infix fun ByteArray.contentEquals(other: ByteArray): Boolean
infix fun ShortArray.contentEquals( other: ShortArray ): Boolean
infix fun IntArray.contentEquals(other: IntArray): Boolean
infix fun LongArray.contentEquals(other: LongArray): Boolean
infix fun FloatArray.contentEquals( other: FloatArray ): Boolean
infix fun DoubleArray.contentEquals( other: DoubleArray ): Boolean
infix fun BooleanArray.contentEquals( other: BooleanArray ): Boolean
infix fun CharArray.contentEquals(other: CharArray): Boolean
infix fun <T> Array<out T>?.contentEquals( other: Array<out T>? ): Boolean
infix fun ByteArray?.contentEquals( other: ByteArray? ): Boolean
infix fun ShortArray?.contentEquals( other: ShortArray? ): Boolean
infix fun IntArray?.contentEquals(other: IntArray?): Boolean
infix fun LongArray?.contentEquals( other: LongArray? ): Boolean
infix fun FloatArray?.contentEquals( other: FloatArray? ): Boolean
infix fun DoubleArray?.contentEquals( other: DoubleArray? ): Boolean
infix fun BooleanArray?.contentEquals( other: BooleanArray? ): Boolean
infix fun CharArray?.contentEquals( other: CharArray? ): Boolean
contentHashCode
Возвращает хэш-код, основанный на содержимом этого массива, как если бы это был список.
fun UIntArray.contentHashCode(): Int
fun ULongArray.contentHashCode(): Int
fun UByteArray.contentHashCode(): Int
fun UShortArray.contentHashCode(): Int
fun UIntArray?.contentHashCode(): Int
fun ULongArray?.contentHashCode(): Int
fun UByteArray?.contentHashCode(): Int
fun UShortArray?.contentHashCode(): Int
fun <T> Array<out T>.contentHashCode(): Int
fun ByteArray.contentHashCode(): Int
fun ShortArray.contentHashCode(): Int
fun IntArray.contentHashCode(): Int
fun LongArray.contentHashCode(): Int
fun FloatArray.contentHashCode(): Int
fun DoubleArray.contentHashCode(): Int
fun BooleanArray.contentHashCode(): Int
fun CharArray.contentHashCode(): Int
fun <T> Array<out T>?.contentHashCode(): Int
fun ByteArray?.contentHashCode(): Int
fun ShortArray?.contentHashCode(): Int
fun IntArray?.contentHashCode(): Int
fun LongArray?.contentHashCode(): Int
fun FloatArray?.contentHashCode(): Int
fun DoubleArray?.contentHashCode(): Int
fun BooleanArray?.contentHashCode(): Int
fun CharArray?.contentHashCode(): Int
contentToString
Возвращает строковое представление содержимого указанного массива, как если бы это был список.
fun UIntArray.contentToString(): String
fun ULongArray.contentToString(): String
fun UByteArray.contentToString(): String
fun UShortArray.contentToString(): String
fun UIntArray?.contentToString(): String
fun ULongArray?.contentToString(): String
fun UByteArray?.contentToString(): String
fun UShortArray?.contentToString(): String
fun <T> Array<out T>.contentToString(): String
fun ByteArray.contentToString(): String
fun ShortArray.contentToString(): String
fun IntArray.contentToString(): String
fun LongArray.contentToString(): String
fun FloatArray.contentToString(): String
fun DoubleArray.contentToString(): String
fun BooleanArray.contentToString(): String
fun CharArray.contentToString(): String
fun <T> Array<out T>?.contentToString(): String
fun ByteArray?.contentToString(): String
fun ShortArray?.contentToString(): String
fun IntArray?.contentToString(): String
fun LongArray?.contentToString(): String
fun FloatArray?.contentToString(): String
fun DoubleArray?.contentToString(): String
fun BooleanArray?.contentToString(): String
fun CharArray?.contentToString(): String
copyInto
Копирует этот массив или его поддиапазон в массив назначения и возвращает этот массив.
fun UIntArray.copyInto( destination: UIntArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size ): UIntArray
fun ULongArray.copyInto( destination: ULongArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size ): ULongArray
fun UByteArray.copyInto( destination: UByteArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size ): UByteArray
fun UShortArray.copyInto( destination: UShortArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size ): UShortArray
fun <T> Array<out T>.copyInto( destination: Array<T>, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size ): Array<T>
fun ByteArray.copyInto( destination: ByteArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size ): ByteArray
fun ShortArray.copyInto( destination: ShortArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size ): ShortArray
fun IntArray.copyInto( destination: IntArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size ): IntArray
fun LongArray.copyInto( destination: LongArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size ): LongArray
fun FloatArray.copyInto( destination: FloatArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size ): FloatArray
fun DoubleArray.copyInto( destination: DoubleArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size ): DoubleArray
fun BooleanArray.copyInto( destination: BooleanArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size ): BooleanArray
fun CharArray.copyInto( destination: CharArray, destinationOffset: Int = 0, startIndex: Int = 0, endIndex: Int = size ): CharArray
копировать
Возвращает новый массив, являющийся копией исходного массива.
fun UIntArray.copyOf(): UIntArray
fun ULongArray.copyOf(): ULongArray
fun UByteArray.copyOf(): UByteArray
fun UShortArray.copyOf(): UShortArray
fun <T> Array<T>.copyOf(): Array<T>
fun <T> Array<out T>.copyOf(): Array<T>
fun ByteArray.copyOf(): ByteArray
fun ShortArray.copyOf(): ShortArray
fun IntArray.copyOf(): IntArray
fun LongArray.copyOf(): LongArray
fun FloatArray.copyOf(): FloatArray
fun DoubleArray.copyOf(): DoubleArray
fun BooleanArray.copyOf(): BooleanArray
fun CharArray.copyOf(): CharArray
Возвращает новый массив, являющийся копией исходного массива, с размером, изменённым на заданный newSize. Копия либо усекается, либо дополняется нулевыми значениями в конце, если это необходимо.
fun UIntArray.copyOf(newSize: Int): UIntArray
fun ULongArray.copyOf(newSize: Int): ULongArray
fun UByteArray.copyOf(newSize: Int): UByteArray
fun UShortArray.copyOf(newSize: Int): UShortArray
fun ByteArray.copyOf(newSize: Int): ByteArray
fun ShortArray.copyOf(newSize: Int): ShortArray
fun IntArray.copyOf(newSize: Int): IntArray
fun LongArray.copyOf(newSize: Int): LongArray
fun FloatArray.copyOf(newSize: Int): FloatArray
fun DoubleArray.copyOf(newSize: Int): DoubleArray
Возвращает новый массив, являющийся копией исходного массива, с размером, изменённым на заданный newSize. Копия либо усекается, либо дополняется false значениями в конце, если это необходимо.
fun BooleanArray.copyOf(newSize: Int): BooleanArray
Возвращает новый массив, являющийся копией исходного массива, с размером, изменённым на заданный newSize. Копия либо усекается, либо дополняется значениями null char (\u0000) в конце, если это необходимо.
fun CharArray.copyOf(newSize: Int): CharArray
Возвращает новый массив, являющийся копией исходного массива, с размером, изменённым на заданный newSize. Копия либо усекается, либо дополняется null значениями в конце, если это необходимо.
fun <T> any_array<T>.copyOf(newSize: Int): Array<T?>
копировать_диапазон
Возвращает новый массив, являющийся копией указанного диапазона исходного массива.
fun UIntArray.copyOfRange( fromIndex: Int, toIndex: Int ): UIntArray
fun ULongArray.copyOfRange( fromIndex: Int, toIndex: Int ): ULongArray
fun UByteArray.copyOfRange( fromIndex: Int, toIndex: Int ): UByteArray
fun UShortArray.copyOfRange( fromIndex: Int, toIndex: Int ): UShortArray
fun <T> Array<T>.copyOfRange( fromIndex: Int, toIndex: Int ): Array<T>
fun <T> Array<out T>.copyOfRange( fromIndex: Int, toIndex: Int ): Array<T>
fun ByteArray.copyOfRange( fromIndex: Int, toIndex: Int ): ByteArray
fun ShortArray.copyOfRange( fromIndex: Int, toIndex: Int ): ShortArray
fun IntArray.copyOfRange( fromIndex: Int, toIndex: Int ): IntArray
fun LongArray.copyOfRange( fromIndex: Int, toIndex: Int ): LongArray
fun FloatArray.copyOfRange( fromIndex: Int, toIndex: Int ): FloatArray
fun DoubleArray.copyOfRange( fromIndex: Int, toIndex: Int ): DoubleArray
fun BooleanArray.copyOfRange( fromIndex: Int, toIndex: Int ): BooleanArray
fun CharArray.copyOfRange( fromIndex: Int, toIndex: Int ): CharArray
количество
Возвращает количество элементов в этом массиве.
fun <T> any_array<T>.count(): Int
Возвращает количество элементов, соответствующих заданному предикату.
fun <T> Array<out T>.count(predicate: (T) -> Boolean): Int
fun ByteArray.count(predicate: (Byte) -> Boolean): Int
fun ShortArray.count(predicate: (Short) -> Boolean): Int
fun IntArray.count(predicate: (Int) -> Boolean): Int
fun LongArray.count(predicate: (Long) -> Boolean): Int
fun FloatArray.count(predicate: (Float) -> Boolean): Int
fun DoubleArray.count(predicate: (Double) -> Boolean): Int
fun BooleanArray.count(predicate: (Boolean) -> Boolean): Int
fun CharArray.count(predicate: (Char) -> Boolean): Int
fun <T> Iterable<T>.count(predicate: (T) -> Boolean): Int
fun UIntArray.count(predicate: (UInt) -> Boolean): Int
fun ULongArray.count(predicate: (ULong) -> Boolean): Int
fun UByteArray.count(predicate: (UByte) -> Boolean): Int
fun UShortArray.count(predicate: (UShort) -> Boolean): Int
Возвращает количество элементов в этом наборе.
fun <T> Iterable<T>.count(): Int
fun <T> Collection<T>.count(): Int
Возвращает количество записей в этой карте.
fun <K, V> Map<out K, V>.count(): Int
Возвращает количество записей, соответствующих заданному предикату.
fun <K, V> Map<out K, V>.count( predicate: (Entry<K, V>) -> Boolean ): Int
уникальные
Возвращает список, содержащий только уникальные элементы из заданного массива.
fun <T> any_array<T>.distinct(): List<T>
Возвращает список, содержащий только уникальные элементы из заданного набора.
fun <T> Iterable<T>.distinct(): List<T>
уникальныеПо
Возвращает список, содержащий только элементы из заданного массива с уникальными ключами, возвращаемыми заданной функцией выбора.
fun <T, K> any_array<T>.distinctBy( selector: (T) -> K ): List<T>
Возвращает список, содержащий только элементы из заданного набора с уникальными ключами, возвращаемыми заданной функцией выбора.
fun <T, K> Iterable<T>.distinctBy( selector: (T) -> K ): List<T>
удалитьПервые
Возвращает список, содержащий все элементы, кроме первых n элементов.
fun <T> Array<out T>.drop(n: Int): List<T>
fun ByteArray.drop(n: Int): List<Byte>
fun ShortArray.drop(n: Int): List<Short>
fun IntArray.drop(n: Int): List<Int>
fun LongArray.drop(n: Int): List<Long>
fun FloatArray.drop(n: Int): List<Float>
fun DoubleArray.drop(n: Int): List<Double>
fun BooleanArray.drop(n: Int): List<Boolean>
fun CharArray.drop(n: Int): List<Char>
fun <T> Iterable<T>.drop(n: Int): List<T>
fun UIntArray.drop(n: Int): List<UInt>
fun ULongArray.drop(n: Int): List<ULong>
fun UByteArray.drop(n: Int): List<UByte>
fun UShortArray.drop(n: Int): List<UShort>
удалитьПоследние
Возвращает список, содержащий все элементы, кроме последних n элементов.
fun <T> Array<out T>.dropLast(n: Int): List<T>
fun ByteArray.dropLast(n: Int): List<Byte>
fun ShortArray.dropLast(n: Int): List<Short>
fun IntArray.dropLast(n: Int): List<Int>
fun LongArray.dropLast(n: Int): List<Long>
fun FloatArray.dropLast(n: Int): List<Float>
fun DoubleArray.dropLast(n: Int): List<Double>
fun BooleanArray.dropLast(n: Int): List<Boolean>
fun CharArray.dropLast(n: Int): List<Char>
fun <T> List<T>.dropLast(n: Int): List<T>
fun UIntArray.dropLast(n: Int): List<UInt>
fun ULongArray.dropLast(n: Int): List<ULong>
fun UByteArray.dropLast(n: Int): List<UByte>
fun UShortArray.dropLast(n: Int): List<UShort>
dropLastWhile
Возвращает список, содержащий все элементы, кроме последних элементов, удовлетворяющих заданному
fun <T> Array<out T>.dropLastWhile(
predicate: (T) -> Boolean
): List<T>
fun ByteArray.dropLastWhile( predicate: (Byte) -> Boolean ): List<Byte>
fun ShortArray.dropLastWhile( predicate: (Short) -> Boolean ): List<Short>
fun IntArray.dropLastWhile( predicate: (Int) -> Boolean ): List<Int>
fun LongArray.dropLastWhile( predicate: (Long) -> Boolean ): List<Long>
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 CharArray.dropLastWhile( predicate: (Char) -> Boolean ): List<Char>
fun <T> List<T>.dropLastWhile( predicate: (T) -> Boolean ): List<T>
fun UIntArray.dropLastWhile( predicate: (UInt) -> Boolean ): List<UInt>
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
Возвращает список, содержащий все элементы, кроме первых элементов, удовлетворяющих заданному
fun <T> Array<out T>.dropWhile(
predicate: (T) -> Boolean
): List<T>
fun ByteArray.dropWhile( predicate: (Byte) -> Boolean ): List<Byte>
fun ShortArray.dropWhile( predicate: (Short) -> Boolean ): List<Short>
fun IntArray.dropWhile( predicate: (Int) -> Boolean ): List<Int>
fun LongArray.dropWhile( predicate: (Long) -> Boolean ): List<Long>
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 CharArray.dropWhile( predicate: (Char) -> Boolean ): List<Char>
fun <T> Iterable<T>.dropWhile( predicate: (T) -> Boolean ): List<T>
fun UIntArray.dropWhile( predicate: (UInt) -> Boolean ): List<UInt>
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
Группирует элементы из источника Grouping по ключу и подсчитывает элементы в каждой группе.
fun <T, K> Grouping<T, K>.eachCount(): Map<K, Int>
eachCountTo
Группирует элементы из источника Grouping по ключу и подсчитывает элементы в каждой группе в заданную
fun <T, K, M : MutableMap<in K, Int>> Grouping<T, K>.eachCountTo(
destination: M
): M
elementAt
Возвращает элемент по заданному исключение IndexOutOfBoundsException, если
fun <T> Iterable<T>.elementAt(index: Int): T
Возвращает элемент по заданному исключение IndexOutOfBoundsException, если
fun <T> List<T>.elementAt(index: Int): T
Возвращает элемент по заданному исключение IndexOutOfBoundsException, если
fun <T> Array<out T>.elementAt(index: Int): T
fun ByteArray.elementAt(index: Int): Byte
fun ShortArray.elementAt(index: Int): Short
fun IntArray.elementAt(index: Int): Int
fun LongArray.elementAt(index: Int): Long
fun FloatArray.elementAt(index: Int): Float
fun DoubleArray.elementAt(index: Int): Double
fun BooleanArray.elementAt(index: Int): Boolean
fun CharArray.elementAt(index: Int): Char
fun UIntArray.elementAt(index: Int): UInt
fun ULongArray.elementAt(index: Int): ULong
fun UByteArray.elementAt(index: Int): UByte
fun UShortArray.elementAt(index: Int): UShort
elementAtOrElse
Возвращает элемент по заданному индексу или результат вызова функции индекс выходит за пределы этого массива.
fun <T> Array<out T>.elementAtOrElse( index: Int, defaultValue: (Int) -> T ): T
fun ByteArray.elementAtOrElse( index: Int, defaultValue: (Int) -> Byte ): Byte
fun ShortArray.elementAtOrElse( index: Int, defaultValue: (Int) -> Short ): Short
fun IntArray.elementAtOrElse( index: Int, defaultValue: (Int) -> Int ): Int
fun LongArray.elementAtOrElse( index: Int, defaultValue: (Int) -> Long ): Long
fun FloatArray.elementAtOrElse( index: Int, defaultValue: (Int) -> Float ): Float
fun DoubleArray.elementAtOrElse( index: Int, defaultValue: (Int) -> Double ): Double
fun BooleanArray.elementAtOrElse( index: Int, defaultValue: (Int) -> Boolean ): Boolean
fun CharArray.elementAtOrElse( index: Int, defaultValue: (Int) -> Char ): Char
fun UIntArray.elementAtOrElse( index: Int, defaultValue: (Int) -> UInt ): UInt
fun ULongArray.elementAtOrElse( index: Int, defaultValue: (Int) -> ULong ): ULong
fun UByteArray.elementAtOrElse( index: Int, defaultValue: (Int) -> UByte ): UByte
fun UShortArray.elementAtOrElse( index: Int, defaultValue: (Int) -> UShort ): UShort
elementAtOrNull
Возвращает элемент по заданному индексу или null , если индекс выходит за пределы этого массива.
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 UIntArray.elementAtOrNull(index: Int): UInt?
fun ULongArray.elementAtOrNull(index: Int): ULong?
fun UByteArray.elementAtOrNull(index: Int): UByte?
fun UShortArray.elementAtOrNull(index: Int): UShort?
emptyList
Возвращает пустой список для чтения. Возвращаемый список сериализуем (JVM).
fun <T> emptyList(): List<T>
emptyMap
Возвращает пустую карту для чтения указанного типа.
fun <K, V> emptyMap(): Map<K, V>
emptySet
Возвращает пустое множество для чтения. Возвращаемое множество сериализуемо (JVM).
fun <T> emptySet(): Set<T>
Заполнить
Заполняет этот массив или его поддиапазон заданным значением элемента.
fun UIntArray.fill( element: UInt, fromIndex: Int = 0, toIndex: Int = size)
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)
Заполняет список предоставленным значением value.
fun <T> MutableList<T>.fill(value: T)
Фильтр
Возвращает список, содержащий только элементы, соответствующие заданному предикату.
fun <T> Array<out T>.filter( predicate: (T) -> Boolean ): List<T>
fun ByteArray.filter( predicate: (Byte) -> Boolean ): List<Byte>
fun ShortArray.filter( predicate: (Short) -> Boolean ): List<Short>
fun IntArray.filter(predicate: (Int) -> Boolean): List<Int>
fun LongArray.filter( predicate: (Long) -> Boolean ): List<Long>
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 CharArray.filter( predicate: (Char) -> Boolean ): List<Char>
fun <T> Iterable<T>.filter( predicate: (T) -> Boolean ): List<T>
fun UIntArray.filter( predicate: (UInt) -> Boolean ): List<UInt>
fun ULongArray.filter( predicate: (ULong) -> Boolean ): List<ULong>
fun UByteArray.filter( predicate: (UByte) -> Boolean ): List<UByte>
fun UShortArray.filter( predicate: (UShort) -> Boolean ): List<UShort>
Возвращает новую карту, содержащую все пары ключ-значение, соответствующие заданному предикату.
fun <K, V> Map<out K, V>.filter( predicate: (Entry<K, V>) -> Boolean ): Map<K, V>
Фильтр с индексом
Возвращает список, содержащий только элементы, соответствующие заданному предикату.
fun <T> Array<out T>.filterIndexed( predicate: (index: Int, T) -> Boolean ): List<T>
fun ByteArray.filterIndexed( predicate: (index: Int, Byte) -> Boolean ): List<Byte>
fun ShortArray.filterIndexed( predicate: (index: Int, Short) -> Boolean ): List<Short>
fun IntArray.filterIndexed( predicate: (index: Int, Int) -> Boolean ): List<Int>
fun LongArray.filterIndexed( predicate: (index: Int, Long) -> Boolean ): List<Long>
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 CharArray.filterIndexed( predicate: (index: Int, Char) -> Boolean ): List<Char>
fun <T> Iterable<T>.filterIndexed( predicate: (index: Int, T) -> Boolean ): List<T>
fun UIntArray.filterIndexed( predicate: (index: Int, UInt) -> Boolean ): List<UInt>
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>
Фильтр с индексом в
Добавляет все элементы, соответствующие заданному предикату, в заданное назначение.
fun <T, C : MutableCollection<in T>> Array<out T>.filterIndexedTo( destination: C, predicate: (index: Int, T) -> Boolean ): C
fun <C : MutableCollection<in Byte>> ByteArray.filterIndexedTo( destination: C, predicate: (index: Int, Byte) -> Boolean ): C
fun <C : MutableCollection<in Short>> ShortArray.filterIndexedTo( destination: C, predicate: (index: Int, Short) -> Boolean ): C
fun <C : MutableCollection<in Int>> IntArray.filterIndexedTo( destination: C, predicate: (index: Int, Int) -> Boolean ): C
fun <C : MutableCollection<in Long>> LongArray.filterIndexedTo( destination: C, predicate: (index: Int, Long) -> Boolean ): C
fun <C : MutableCollection<in Float>> FloatArray.filterIndexedTo( destination: C, predicate: (index: Int, Float) -> Boolean ): C
fun <C : MutableCollection<in Double>> DoubleArray.filterIndexedTo( destination: C, predicate: (index: Int, Double) -> Boolean ): C
fun <C : MutableCollection<in Boolean>> BooleanArray.filterIndexedTo( destination: C, predicate: (index: Int, Boolean) -> Boolean ): C
fun <C : MutableCollection<in Char>> CharArray.filterIndexedTo( destination: C, predicate: (index: Int, Char) -> Boolean ): C
fun <T, C : MutableCollection<in T>> Iterable<T>.filterIndexedTo( destination: C, predicate: (index: Int, T) -> Boolean ): C
fun <C : MutableCollection<in UInt>> UIntArray.filterIndexedTo( destination: C, predicate: (index: Int, UInt) -> Boolean ): C
fun <C : MutableCollection<in ULong>> ULongArray.filterIndexedTo( destination: C, predicate: (index: Int, ULong) -> Boolean ): C
fun <C : MutableCollection<in UByte>> UByteArray.filterIndexedTo( destination: C, predicate: (index: Int, UByte) -> Boolean ): C
fun <C : MutableCollection<in UShort>> UShortArray.filterIndexedTo( destination: C, predicate: (index: Int, UShort) -> Boolean ): C
Фильтр по типу
Возвращает список, содержащий все элементы, являющиеся экземплярами заданного типа параметра R.
fun <R> Array<*>.filterIsInstance(): List<R>
fun <R> Iterable<*>.filterIsInstance(): List<R>
Возвращает список, содержащий все элементы, являющиеся экземплярами указанного класса.
fun <R> Array<*>.filterIsInstance(klass: Class<R>): List<R>
fun <R> Iterable<*>.filterIsInstance( klass: Class<R> ): List<R>
filterIsInstanceTo
Добавляет все элементы, являющиеся экземплярами указанного параметра типа R, в заданное назначение.
fun <R, C : MutableCollection<in R>> Array<*>.filterIsInstanceTo( destination: C ): C
fun <R, C : MutableCollection<in R>> Iterable<*>.filterIsInstanceTo( destination: C ): C
Добавляет все элементы, являющиеся экземплярами указанного класса, в заданное назначение.
fun <C : MutableCollection<in R>, R> Array<*>.filterIsInstanceTo( destination: C, klass: Class<R> ): C
fun <C : MutableCollection<in R>, R> Iterable<*>.filterIsInstanceTo( destination: C, klass: Class<R> ): C
filterKeys
Возвращает карту, содержащую все пары ключ-значение с ключами, соответствующими заданному предикату.
fun <K, V> Map<out K, V>.filterKeys( predicate: (K) -> Boolean ): Map<K, V>
filterNot
Возвращает список, содержащий все элементы, не соответствующие заданному предикату.
fun <T> Array<out T>.filterNot( predicate: (T) -> Boolean ): List<T>
fun ByteArray.filterNot( predicate: (Byte) -> Boolean ): List<Byte>
fun ShortArray.filterNot( predicate: (Short) -> Boolean ): List<Short>
fun IntArray.filterNot( predicate: (Int) -> Boolean ): List<Int>
fun LongArray.filterNot( predicate: (Long) -> Boolean ): List<Long>
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 CharArray.filterNot( predicate: (Char) -> Boolean ): List<Char>
fun <T> Iterable<T>.filterNot( predicate: (T) -> Boolean ): List<T>
fun UIntArray.filterNot( predicate: (UInt) -> Boolean ): List<UInt>
fun ULongArray.filterNot( predicate: (ULong) -> Boolean ): List<ULong>
fun UByteArray.filterNot( predicate: (UByte) -> Boolean ): List<UByte>
fun UShortArray.filterNot( predicate: (UShort) -> Boolean ): List<UShort>
Возвращает новую карту, содержащую все пары ключ-значение, не соответствующие заданному предикату.
fun <K, V> Map<out K, V>.filterNot( predicate: (Entry<K, V>) -> Boolean ): Map<K, V>
filterNotNull
Возвращает список, содержащий все элементы, которые не null.
fun <T : Any> Array<out T?>.filterNotNull(): List<T>
fun <T : Any> Iterable<T?>.filterNotNull(): List<T>
filterNotNullTo
Добавляет все элементы, которые не null в заданное назначение.
fun <C : MutableCollection<in T>, T : Any> Array<out T?>.filterNotNullTo( destination: C ): C
fun <C : MutableCollection<in T>, T : Any> Iterable<T?>.filterNotNullTo( destination: C ): C
filterNotTo
Добавляет все элементы, не соответствующие заданному предикату в заданное назначение.
fun <T, C : MutableCollection<in T>> Array<out T>.filterNotTo( destination: C, predicate: (T) -> Boolean ): C
fun <C : MutableCollection<in Byte>> ByteArray.filterNotTo( destination: C, predicate: (Byte) -> Boolean ): C
fun <C : MutableCollection<in Short>> ShortArray.filterNotTo( destination: C, predicate: (Short) -> Boolean ): C
fun <C : MutableCollection<in Int>> IntArray.filterNotTo( destination: C, predicate: (Int) -> Boolean ): C
fun <C : MutableCollection<in Long>> LongArray.filterNotTo( destination: C, predicate: (Long) -> Boolean ): C
fun <C : MutableCollection<in Float>> FloatArray.filterNotTo( destination: C, predicate: (Float) -> Boolean ): C
fun <C : MutableCollection<in Double>> DoubleArray.filterNotTo( destination: C, predicate: (Double) -> Boolean ): C
fun <C : MutableCollection<in Boolean>> BooleanArray.filterNotTo( destination: C, predicate: (Boolean) -> Boolean ): C
fun <C : MutableCollection<in Char>> CharArray.filterNotTo( destination: C, predicate: (Char) -> Boolean ): C
fun <C : MutableCollection<in UInt>> UIntArray.filterNotTo( destination: C, predicate: (UInt) -> Boolean ): C
fun <C : MutableCollection<in ULong>> ULongArray.filterNotTo( destination: C, predicate: (ULong) -> Boolean ): C
fun <C : MutableCollection<in UByte>> UByteArray.filterNotTo( destination: C, predicate: (UByte) -> Boolean ): C
fun <C : MutableCollection<in UShort>> UShortArray.filterNotTo( destination: C, predicate: (UShort) -> Boolean ): C
Добавляет все записи, не соответствующие заданному предикату в заданное назначение.
fun <K, V, M : MutableMap<in K, in V>> Map<out K, V>.filterNotTo( destination: M, predicate: (Entry<K, V>) -> Boolean ): M
filterTo
Добавляет все элементы, соответствующие заданному .
fun <T, C : MutableCollection<in T>> Array<out T>.filterTo( destination: C, predicate: (T) -> Boolean ): C
fun <C : MutableCollection<in Byte>> ByteArray.filterTo( destination: C, predicate: (Byte) -> Boolean ): C
fun <C : MutableCollection<in Short>> ShortArray.filterTo( destination: C, predicate: (Short) -> Boolean ): C
fun <C : MutableCollection<in Int>> IntArray.filterTo( destination: C, predicate: (Int) -> Boolean ): C
fun <C : MutableCollection<in Long>> LongArray.filterTo( destination: C, predicate: (Long) -> Boolean ): C
fun <C : MutableCollection<in Float>> FloatArray.filterTo( destination: C, predicate: (Float) -> Boolean ): C
fun <C : MutableCollection<in Double>> DoubleArray.filterTo( destination: C, predicate: (Double) -> Boolean ): C
fun <C : MutableCollection<in Boolean>> BooleanArray.filterTo( destination: C, predicate: (Boolean) -> Boolean ): C
fun <C : MutableCollection<in Char>> CharArray.filterTo( destination: C, predicate: (Char) -> Boolean ): C
fun <T, C : MutableCollection<in T>> Iterable<T>.filterTo( destination: C, predicate: (T) -> Boolean ): C
fun <C : MutableCollection<in UInt>> UIntArray.filterTo( destination: C, predicate: (UInt) -> Boolean ): C
fun <C : MutableCollection<in ULong>> ULongArray.filterTo( destination: C, predicate: (ULong) -> Boolean ): C
fun <C : MutableCollection<in UByte>> UByteArray.filterTo( destination: C, predicate: (UByte) -> Boolean ): C
fun <C : MutableCollection<in UShort>> UShortArray.filterTo( destination: C, predicate: (UShort) -> Boolean ): C
Добавляет все пары ключ-значение, соответствующие заданному .
fun <K, V, M : MutableMap<in K, in V>> Map<out K, V>.filterTo( destination: M, predicate: (Entry<K, V>) -> Boolean ): M
filterValues
Возвращает карту, содержащую все пары ключ-значение, значения которых соответствуют заданному
fun <K, V> Map<out K, V>.filterValues(
predicate: (V) -> Boolean
): Map<K, V>
find
Возвращает первый элемент, соответствующий заданному
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 UIntArray.find(predicate: (UInt) -> Boolean): UInt?
fun ULongArray.find(predicate: (ULong) -> Boolean): ULong?
fun UByteArray.find(predicate: (UByte) -> Boolean): UByte?
fun UShortArray.find(predicate: (UShort) -> Boolean): UShort?
findLast
Возвращает последний элемент, соответствующий заданному
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 UIntArray.findLast(predicate: (UInt) -> Boolean): UInt?
fun ULongArray.findLast( predicate: (ULong) -> Boolean ): ULong?
fun UByteArray.findLast( predicate: (UByte) -> Boolean ): UByte?
fun UShortArray.findLast( predicate: (UShort) -> Boolean ): UShort?
первый
Возвращает первый элемент.
fun <T> Array<out T>.first(): T
fun ByteArray.first(): Byte
fun ShortArray.first(): Short
fun IntArray.first(): Int
fun LongArray.first(): Long
fun FloatArray.first(): Float
fun DoubleArray.first(): Double
fun BooleanArray.first(): Boolean
fun CharArray.first(): Char
fun <T> Iterable<T>.first(): T
fun <T> List<T>.first(): T
fun UIntArray.first(): UInt
fun ULongArray.first(): ULong
fun UByteArray.first(): UByte
fun UShortArray.first(): UShort
Возвращает первый элемент, соответствующий заданному
fun <T> Array<out T>.first(predicate: (T) -> Boolean): T
fun ByteArray.first(predicate: (Byte) -> Boolean): Byte
fun ShortArray.first(predicate: (Short) -> Boolean): Short
fun IntArray.first(predicate: (Int) -> Boolean): Int
fun LongArray.first(predicate: (Long) -> Boolean): Long
fun FloatArray.first(predicate: (Float) -> Boolean): Float
fun DoubleArray.first(predicate: (Double) -> Boolean): Double
fun BooleanArray.first( predicate: (Boolean) -> Boolean ): Boolean
fun CharArray.first(predicate: (Char) -> Boolean): Char
fun <T> Iterable<T>.first(predicate: (T) -> Boolean): T
fun UIntArray.first(predicate: (UInt) -> Boolean): UInt
fun ULongArray.first(predicate: (ULong) -> Boolean): ULong
fun UByteArray.first(predicate: (UByte) -> Boolean): UByte
fun UShortArray.first(predicate: (UShort) -> Boolean): UShort
firstNotNullOf
Возвращает первое не-null значение, полученное функцией исключение NoSuchElementException, если не было произведено ни одного не-null значения.
fun <T, R : Any> Array<out T>.firstNotNullOf( transform: (T) -> R? ): R
Возвращает первое не-null значение, полученное функцией исключение NoSuchElementException, если не было произведено ни одного не-null значения.
fun <T, R : Any> Iterable<T>.firstNotNullOf( transform: (T) -> R? ): R
Возвращает первое не-null значение, полученное функцией исключение NoSuchElementException, если не было произведено ни одного не-null значения.
fun <K, V, R : Any> Map<out K, V>.firstNotNullOf( transform: (Entry<K, V>) -> R? ): R
firstNotNullOfOrNull
Возвращает первое не-null значение, полученное функцией
fun <T, R : Any> Array<out T>.firstNotNullOfOrNull(
transform: (T) -> R?
): R?
Возвращает первое не-null значение, полученное функцией
fun <T, R : Any> Iterable<T>.firstNotNullOfOrNull(
transform: (T) -> R?
): R?
Возвращает первое не-null значение, полученное функцией
fun <K, V, R : Any> Map<out K, V>.firstNotNullOfOrNull(
transform: (Entry<K, V>) -> R?
): R?
firstOrNull
Возвращает первый элемент или null если массив пустой.
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 UIntArray.firstOrNull(): UInt?
fun ULongArray.firstOrNull(): ULong?
fun UByteArray.firstOrNull(): UByte?
fun UShortArray.firstOrNull(): UShort?
Возвращает первый элемент, соответствующий заданному предикату, или null если элемент не найден.
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 UIntArray.firstOrNull( predicate: (UInt) -> Boolean ): UInt?
fun ULongArray.firstOrNull( predicate: (ULong) -> Boolean ): ULong?
fun UByteArray.firstOrNull( predicate: (UByte) -> Boolean ): UByte?
fun UShortArray.firstOrNull( predicate: (UShort) -> Boolean ): UShort?
Возвращает первый элемент, или null если коллекция пустая.
fun <T> Iterable<T>.firstOrNull(): T?
Возвращает первый элемент, или null если список пустой.
fun <T> List<T>.firstOrNull(): T?
flatMap
Возвращает единый список всех элементов, полученных из результатов функции
fun <T, R> Array<out T>.flatMap(
transform: (T) -> Iterable<R>
): List<R>
fun <R> ByteArray.flatMap( transform: (Byte) -> Iterable<R> ): List<R>
fun <R> ShortArray.flatMap( transform: (Short) -> Iterable<R> ): List<R>
fun <R> IntArray.flatMap( transform: (Int) -> Iterable<R> ): List<R>
fun <R> LongArray.flatMap( transform: (Long) -> 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> CharArray.flatMap( transform: (Char) -> Iterable<R> ): List<R>
fun <T, R> Array<out T>.flatMap( transform: (T) -> Sequence<R> ): List<R>
fun <R> UIntArray.flatMap( transform: (UInt) -> 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>
Возвращает единый список всех элементов, полученных из результатов функции
fun <T, R> Iterable<T>.flatMap(
transform: (T) -> Iterable<R>
): List<R>
fun <T, R> Iterable<T>.flatMap( transform: (T) -> Sequence<R> ): List<R>
Возвращает единый список всех элементов, полученных из результатов функции
fun <K, V, R> Map<out K, V>.flatMap(
transform: (Entry<K, V>) -> Iterable<R>
): List<R>
fun <K, V, R> Map<out K, V>.flatMap( transform: (Entry<K, V>) -> Sequence<R> ): List<R>
flatMapIndexed
Возвращает один список всех элементов, полученных из результатов функции transform, вызываемой для каждого элемента и его индекса в исходном массиве.
fun <T, R> Array<out T>.flatMapIndexed( transform: (index: Int, T) -> Iterable<R> ): List<R>
fun <R> ByteArray.flatMapIndexed( transform: (index: Int, Byte) -> Iterable<R> ): List<R>
fun <R> ShortArray.flatMapIndexed( transform: (index: Int, Short) -> Iterable<R> ): List<R>
fun <R> IntArray.flatMapIndexed( transform: (index: Int, Int) -> Iterable<R> ): List<R>
fun <R> LongArray.flatMapIndexed( transform: (index: Int, Long) -> 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> CharArray.flatMapIndexed( transform: (index: Int, Char) -> Iterable<R> ): List<R>
fun <T, R> Array<out T>.flatMapIndexed( transform: (index: Int, T) -> Sequence<R> ): List<R>
fun <R> UIntArray.flatMapIndexed( transform: (index: Int, UInt) -> 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>
Возвращает один список всех элементов, полученных из результатов функции transform, вызываемой для каждого элемента и его индекса в исходной коллекции.
fun <T, R> Iterable<T>.flatMapIndexed( transform: (index: Int, T) -> Iterable<R> ): List<R>
fun <T, R> Iterable<T>.flatMapIndexed( transform: (index: Int, T) -> Sequence<R> ): List<R>
flatMapIndexedTo
Добавляет все элементы, полученные из результатов функции transform, вызываемой для каждого элемента и его индекса в исходном массиве, в заданное назначение.
fun <T, R, C : MutableCollection<in R>> Array<out T>.flatMapIndexedTo( destination: C, transform: (index: Int, T) -> Iterable<R> ): C
fun <R, C : MutableCollection<in R>> ByteArray.flatMapIndexedTo( destination: C, transform: (index: Int, Byte) -> Iterable<R> ): C
fun <R, C : MutableCollection<in R>> ShortArray.flatMapIndexedTo( destination: C, transform: (index: Int, Short) -> Iterable<R> ): C
fun <R, C : MutableCollection<in R>> IntArray.flatMapIndexedTo( destination: C, transform: (index: Int, Int) -> Iterable<R> ): C
fun <R, C : MutableCollection<in R>> LongArray.flatMapIndexedTo( destination: C, transform: (index: Int, Long) -> Iterable<R> ): C
fun <R, C : MutableCollection<in R>> FloatArray.flatMapIndexedTo( destination: C, transform: (index: Int, Float) -> Iterable<R> ): C
fun <R, C : MutableCollection<in R>> DoubleArray.flatMapIndexedTo( destination: C, transform: (index: Int, Double) -> Iterable<R> ): C
fun <R, C : MutableCollection<in R>> BooleanArray.flatMapIndexedTo( destination: C, transform: (index: Int, Boolean) -> Iterable<R> ): C
fun <R, C : MutableCollection<in R>> CharArray.flatMapIndexedTo( destination: C, transform: (index: Int, Char) -> Iterable<R> ): C
fun <T, R, C : MutableCollection<in R>> Array<out T>.flatMapIndexedTo( destination: C, transform: (index: Int, T) -> Sequence<R> ): C
fun <R, C : MutableCollection<in R>> UIntArray.flatMapIndexedTo( destination: C, transform: (index: Int, UInt) -> Iterable<R> ): C
fun <R, C : MutableCollection<in R>> ULongArray.flatMapIndexedTo( destination: C, transform: (index: Int, ULong) -> Iterable<R> ): C
fun <R, C : MutableCollection<in R>> UByteArray.flatMapIndexedTo( destination: C, transform: (index: Int, UByte) -> Iterable<R> ): C
fun <R, C : MutableCollection<in R>> UShortArray.flatMapIndexedTo( destination: C, transform: (index: Int, UShort) -> Iterable<R> ): C
Добавляет все элементы, полученные из результатов функции transform, вызываемой для каждого элемента и его индекса в исходной коллекции, в заданное назначение.
fun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapIndexedTo( destination: C, transform: (index: Int, T) -> Iterable<R> ): C
fun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapIndexedTo( destination: C, transform: (index: Int, T) -> Sequence<R> ): C
flatMapTo
Добавляет все элементы, полученные в результате вызова функции transform для каждого элемента исходного массива, в заданное назначение.
fun <T, R, C : MutableCollection<in R>> Array<out T>.flatMapTo( destination: C, transform: (T) -> Iterable<R> ): C
fun <R, C : MutableCollection<in R>> ByteArray.flatMapTo( destination: C, transform: (Byte) -> Iterable<R> ): C
fun <R, C : MutableCollection<in R>> ShortArray.flatMapTo( destination: C, transform: (Short) -> Iterable<R> ): C
fun <R, C : MutableCollection<in R>> IntArray.flatMapTo( destination: C, transform: (Int) -> Iterable<R> ): C
fun <R, C : MutableCollection<in R>> LongArray.flatMapTo( destination: C, transform: (Long) -> Iterable<R> ): C
fun <R, C : MutableCollection<in R>> FloatArray.flatMapTo( destination: C, transform: (Float) -> Iterable<R> ): C
fun <R, C : MutableCollection<in R>> DoubleArray.flatMapTo( destination: C, transform: (Double) -> Iterable<R> ): C
fun <R, C : MutableCollection<in R>> BooleanArray.flatMapTo( destination: C, transform: (Boolean) -> Iterable<R> ): C
fun <R, C : MutableCollection<in R>> CharArray.flatMapTo( destination: C, transform: (Char) -> Iterable<R> ): C
fun <T, R, C : MutableCollection<in R>> Array<out T>.flatMapTo( destination: C, transform: (T) -> Sequence<R> ): C
fun <R, C : MutableCollection<in R>> UIntArray.flatMapTo( destination: C, transform: (UInt) -> Iterable<R> ): C
fun <R, C : MutableCollection<in R>> ULongArray.flatMapTo( destination: C, transform: (ULong) -> Iterable<R> ): C
fun <R, C : MutableCollection<in R>> UByteArray.flatMapTo( destination: C, transform: (UByte) -> Iterable<R> ): C
fun <R, C : MutableCollection<in R>> UShortArray.flatMapTo( destination: C, transform: (UShort) -> Iterable<R> ): C
Добавляет все элементы, полученные в результате вызова функции transform для каждого элемента исходного набора, в заданное назначение.
fun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapTo( destination: C, transform: (T) -> Iterable<R> ): C
fun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapTo( destination: C, transform: (T) -> Sequence<R> ): C
Добавляет все элементы, полученные в результате вызова функции transform для каждой записи исходного отображения, в заданное назначение.
fun <K, V, R, C : MutableCollection<in R>> Map<out K, V>.flatMapTo( destination: C, transform: (Entry<K, V>) -> Iterable<R> ): C
fun <K, V, R, C : MutableCollection<in R>> Map<out K, V>.flatMapTo( destination: C, transform: (Entry<K, V>) -> Sequence<R> ): C
flatten
Возвращает один список всех элементов из всех массивов в заданном массиве.
fun <T> Array<out Array<out T>>.flatten(): List<T>
Возвращает один список всех элементов из всех наборов в заданном наборе.
fun <T> Iterable<Iterable<T>>.flatten(): List<T>
fold
Накапливает значение, начиная со значения initial, применяя operation слева направо к текущему значению аккумулятора и каждому элементу.
fun <T, R> Array<out T>.fold( initial: R, operation: (acc: R, T) -> R ): R
fun <R> ByteArray.fold( initial: R, operation: (acc: R, Byte) -> R ): R
fun <R> ShortArray.fold( initial: R, operation: (acc: R, Short) -> R ): R
fun <R> IntArray.fold( initial: R, operation: (acc: R, Int) -> R ): R
fun <R> LongArray.fold( initial: R, operation: (acc: R, Long) -> R ): R
fun <R> FloatArray.fold( initial: R, operation: (acc: R, Float) -> R ): R
fun <R> DoubleArray.fold( initial: R, operation: (acc: R, Double) -> R ): R
fun <R> BooleanArray.fold( initial: R, operation: (acc: R, Boolean) -> R ): R
fun <R> CharArray.fold( initial: R, operation: (acc: R, Char) -> R ): R
fun <T, R> Iterable<T>.fold( initial: R, operation: (acc: R, T) -> R ): R
fun <R> UIntArray.fold( initial: R, operation: (acc: R, UInt) -> R ): R
fun <R> ULongArray.fold( initial: R, operation: (acc: R, ULong) -> R ): R
fun <R> UByteArray.fold( initial: R, operation: (acc: R, UByte) -> R ): R
fun <R> UShortArray.fold( initial: R, operation: (acc: R, UShort) -> R ): R
Группирует элементы из источника Группировки по ключу и применяет operation к элементам каждой группы последовательно, передавая ранее накопленное значение и текущий элемент в качестве аргументов, и сохраняет результаты в новом отображении. Начальное значение аккумулятора предоставляется функцией initialValueSelector.
fun <T, K, R> Grouping<T, K>.fold( initialValueSelector: (key: K, element: T) -> R, operation: (key: K, accumulator: R, element: T) -> R ): Map<K, R>
Группирует элементы из источника Группировки по ключу и применяет operation к элементам каждой группы последовательно, передавая ранее накопленное значение и текущий элемент в качестве аргументов, и сохраняет результаты в новом отображении. Начальное значение аккумулятора одинаково для каждой группы, как в initialValue.
fun <T, K, R> Grouping<T, K>.fold( initialValue: R, operation: (accumulator: R, element: T) -> R ): Map<K, R>
foldIndexed
Накапливает значение, начиная со значения initial и применяя operation слева направо к текущему значению аккумулятора и каждому элементу с его индексом в исходном массиве.
fun <T, R> Array<out T>.foldIndexed( initial: R, operation: (index: Int, acc: R, T) -> R ): R
fun <R> ByteArray.foldIndexed( initial: R, operation: (index: Int, acc: R, Byte) -> R ): R
fun <R> ShortArray.foldIndexed( initial: R, operation: (index: Int, acc: R, Short) -> R ): R
fun <R> IntArray.foldIndexed( initial: R, operation: (index: Int, acc: R, Int) -> R ): R
fun <R> LongArray.foldIndexed( initial: R, operation: (index: Int, acc: R, Long) -> R ): R
fun <R> FloatArray.foldIndexed( initial: R, operation: (index: Int, acc: R, Float) -> R ): R
fun <R> DoubleArray.foldIndexed( initial: R, operation: (index: Int, acc: R, Double) -> R ): R
fun <R> BooleanArray.foldIndexed( initial: R, operation: (index: Int, acc: R, Boolean) -> R ): R
fun <R> CharArray.foldIndexed( initial: R, operation: (index: Int, acc: R, Char) -> R ): R
fun <R> UIntArray.foldIndexed( initial: R, operation: (index: Int, acc: R, UInt) -> R ): R
fun <R> ULongArray.foldIndexed( initial: R, operation: (index: Int, acc: R, ULong) -> R ): R
fun <R> UByteArray.foldIndexed( initial: R, operation: (index: Int, acc: R, UByte) -> R ): R
fun <R> UShortArray.foldIndexed( initial: R, operation: (index: Int, acc: R, UShort) -> R ): R
foldRight
Накапливает значение, начиная со значения initial и применяя operation справа налево к каждому элементу и текущему значению аккумулятора.
fun <T, R> Array<out T>.foldRight( initial: R, operation: (T, acc: R) -> R ): R
fun <R> ByteArray.foldRight( initial: R, operation: (Byte, acc: R) -> R ): R
fun <R> ShortArray.foldRight( initial: R, operation: (Short, acc: R) -> R ): R
fun <R> IntArray.foldRight( initial: R, operation: (Int, acc: R) -> R ): R
fun <R> LongArray.foldRight( initial: R, operation: (Long, acc: R) -> R ): R
fun <R> FloatArray.foldRight( initial: R, operation: (Float, acc: R) -> R ): R
fun <R> DoubleArray.foldRight( initial: R, operation: (Double, acc: R) -> R ): R
fun <R> BooleanArray.foldRight( initial: R, operation: (Boolean, acc: R) -> R ): R
fun <R> CharArray.foldRight( initial: R, operation: (Char, acc: R) -> R ): R
fun <T, R> List<T>.foldRight( initial: R, operation: (T, acc: R) -> R ): R
fun <R> UIntArray.foldRight( initial: R, operation: (UInt, acc: R) -> R ): R
fun <R> ULongArray.foldRight( initial: R, operation: (ULong, acc: R) -> R ): R
fun <R> UByteArray.foldRight( initial: R, operation: (UByte, acc: R) -> R ): R
fun <R> UShortArray.foldRight( initial: R, operation: (UShort, acc: R) -> R ): R
foldRightIndexed
Накапливает значение, начиная со значения initial и применяя operation справа налево к каждому элементу с его индексом в исходном массиве и текущему значению аккумулятора.
fun <T, R> Array<out T>.foldRightIndexed( initial: R, operation: (index: Int, T, acc: R) -> R ): R
fun <R> ByteArray.foldRightIndexed( initial: R, operation: (index: Int, Byte, acc: R) -> R ): R
fun <R> ShortArray.foldRightIndexed( initial: R, operation: (index: Int, Short, acc: R) -> R ): R
fun <R> IntArray.foldRightIndexed( initial: R, operation: (index: Int, Int, acc: R) -> R ): R
fun <R> LongArray.foldRightIndexed( initial: R, operation: (index: Int, Long, acc: R) -> R ): R
fun <R> FloatArray.foldRightIndexed( initial: R, operation: (index: Int, Float, acc: R) -> R ): R
fun <R> DoubleArray.foldRightIndexed( initial: R, operation: (index: Int, Double, acc: R) -> R ): R
fun <R> BooleanArray.foldRightIndexed( initial: R, operation: (index: Int, Boolean, acc: R) -> R ): R
fun <R> CharArray.foldRightIndexed( initial: R, operation: (index: Int, Char, acc: R) -> R ): R
fun <R> UIntArray.foldRightIndexed( initial: R, operation: (index: Int, UInt, acc: R) -> R ): R
fun <R> ULongArray.foldRightIndexed( initial: R, operation: (index: Int, ULong, acc: R) -> R ): R
fun <R> UByteArray.foldRightIndexed( initial: R, operation: (index: Int, UByte, acc: R) -> R ): R
fun <R> UShortArray.foldRightIndexed( initial: R, operation: (index: Int, UShort, acc: R) -> R ): R
foldTo
Группирует элементы из источника Grouping по ключу и применяет операцию к элементам каждой группы последовательно, передавая предыдущее накопленное значение и текущий элемент в качестве аргументов, и сохраняет результаты в заданном назначенном словаре. Начальное значение аккумулятора предоставляется функцией initialValueSelector.
fun <T, K, R, M : MutableMap<in K, R>> Grouping<T, K>.foldTo( destination: M, initialValueSelector: (key: K, element: T) -> R, operation: (key: K, accumulator: R, element: T) -> R ): M
Группирует элементы из источника Grouping по ключу и применяет операцию к элементам каждой группы последовательно, передавая предыдущее накопленное значение и текущий элемент в качестве аргументов, и сохраняет результаты в заданном назначенном словаре. Начальное значение аккумулятора — одинаковое начальное значение для каждой группы.
fun <T, K, R, M : MutableMap<in K, R>> Grouping<T, K>.foldTo( destination: M, initialValue: R, operation: (accumulator: R, element: T) -> R ): M
forEach
Выполняет заданное действие для каждого элемента.
fun <T> Array<out T>.forEach(action: (T) -> Unit)
fun ByteArray.forEach(action: (Byte) -> Unit)
fun ShortArray.forEach(action: (Short) -> Unit)
fun IntArray.forEach(action: (Int) -> Unit)
fun LongArray.forEach(action: (Long) -> Unit)
fun FloatArray.forEach(action: (Float) -> Unit)
fun DoubleArray.forEach(action: (Double) -> Unit)
fun BooleanArray.forEach(action: (Boolean) -> Unit)
fun CharArray.forEach(action: (Char) -> Unit)
fun <T> Iterable<T>.forEach(action: (T) -> Unit)
fun UIntArray.forEach(action: (UInt) -> Unit)
fun ULongArray.forEach(action: (ULong) -> Unit)
fun UByteArray.forEach(action: (UByte) -> Unit)
fun UShortArray.forEach(action: (UShort) -> Unit)
Выполняет заданное действие для каждой записи.
fun <K, V> Map<out K, V>.forEach( action: (Entry<K, V>) -> Unit)
forEachIndexed
Выполняет заданное действие для каждого элемента, предоставляя последовательный индекс с элементом.
fun <T> Array<out T>.forEachIndexed( action: (index: Int, T) -> Unit)
fun ByteArray.forEachIndexed( action: (index: Int, Byte) -> Unit)
fun ShortArray.forEachIndexed( action: (index: Int, Short) -> Unit)
fun IntArray.forEachIndexed( action: (index: Int, Int) -> Unit)
fun LongArray.forEachIndexed( action: (index: Int, Long) -> Unit)
fun FloatArray.forEachIndexed( action: (index: Int, Float) -> Unit)
fun DoubleArray.forEachIndexed( action: (index: Int, Double) -> Unit)
fun BooleanArray.forEachIndexed( action: (index: Int, Boolean) -> Unit)
fun CharArray.forEachIndexed( action: (index: Int, Char) -> Unit)
fun <T> Iterable<T>.forEachIndexed( action: (index: Int, T) -> Unit)
fun UIntArray.forEachIndexed( action: (index: Int, UInt) -> Unit)
fun ULongArray.forEachIndexed( action: (index: Int, ULong) -> Unit)
fun UByteArray.forEachIndexed( action: (index: Int, UByte) -> Unit)
fun UShortArray.forEachIndexed( action: (index: Int, UShort) -> Unit)
get
Возвращает значение, соответствующее заданному ключу, или null, если такого ключа нет в словаре.
operator fun <K, V> Map<out K, V>.get(key: K): V?
getOrDefault
Возвращает значение, которому соответствует указанный ключ, или defaultValue, если в этом словаре нет сопоставления для ключа.
fun <K, V> Map<out K, V>.getOrDefault( key: K, defaultValue: V ): V
getOrElse
Возвращает элемент по заданному , если индекс находится за пределами границ этого массива.
fun <T> Array<out T>.getOrElse( index: Int, defaultValue: (Int) -> T ): T
fun ByteArray.getOrElse( index: Int, defaultValue: (Int) -> Byte ): Byte
fun ShortArray.getOrElse( index: Int, defaultValue: (Int) -> Short ): Short
fun IntArray.getOrElse( index: Int, defaultValue: (Int) -> Int ): Int
fun LongArray.getOrElse( index: Int, defaultValue: (Int) -> Long ): Long
fun FloatArray.getOrElse( index: Int, defaultValue: (Int) -> Float ): Float
fun DoubleArray.getOrElse( index: Int, defaultValue: (Int) -> Double ): Double
fun BooleanArray.getOrElse( index: Int, defaultValue: (Int) -> Boolean ): Boolean
fun CharArray.getOrElse( index: Int, defaultValue: (Int) -> Char ): Char
fun UIntArray.getOrElse( index: Int, defaultValue: (Int) -> UInt ): UInt
fun ULongArray.getOrElse( index: Int, defaultValue: (Int) -> ULong ): ULong
fun UByteArray.getOrElse( index: Int, defaultValue: (Int) -> UByte ): UByte
fun UShortArray.getOrElse( index: Int, defaultValue: (Int) -> UShort ): UShort
Возвращает элемент по заданному , если индекс находится за пределами границ этого списка.
fun <T> List<T>.getOrElse( index: Int, defaultValue: (Int) -> T ): T
Возвращает значение для заданного .
fun <K, V> Map<K, V>.getOrElse( key: K, defaultValue: () -> V ): V
getOrNull
Возвращает элемент по заданному
fun <T> Array<out T>.getOrNull(index: Int): T?
fun ByteArray.getOrNull(index: Int): Byte?
fun ShortArray.getOrNull(index: Int): Short?
fun IntArray.getOrNull(index: Int): Int?
fun LongArray.getOrNull(index: Int): Long?
fun FloatArray.getOrNull(index: Int): Float?
fun DoubleArray.getOrNull(index: Int): Double?
fun BooleanArray.getOrNull(index: Int): Boolean?
fun CharArray.getOrNull(index: Int): Char?
fun UIntArray.getOrNull(index: Int): UInt?
fun ULongArray.getOrNull(index: Int): ULong?
fun UByteArray.getOrNull(index: Int): UByte?
fun UShortArray.getOrNull(index: Int): UShort?
Возвращает элемент по заданному
fun <T> List<T>.getOrNull(index: Int): T?
getOrPut
Возвращает значение для заданного , помещает её результат в карту по заданному ключу и возвращает результат вызова.
fun <K, V> MutableMap<K, V>.getOrPut( key: K, defaultValue: () -> V ): V
getValue
Возвращает значение свойства для данного объекта из этой карты только для чтения.
operator fun <V, V1 : V> Map<in String, V>.getValue( thisRef: Any?, property: KProperty<*> ): V1
Возвращает значение свойства для данного объекта из этой изменяемой карты.
operator fun <V, V1 : V> MutableMap<in String, out V>.getValue( thisRef: Any?, property: KProperty<*> ): V1
Возвращает значение для заданного
fun <K, V> Map<K, V>.getValue(key: K): V
groupBy
Группирует элементы исходного массива по ключу, возвращаемому заданной функцией keySelector, применённой к каждому элементу, и возвращает карту, где каждый ключ группы сопоставлен списку соответствующих элементов.
fun <T, K> Array<out T>.groupBy( keySelector: (T) -> K ): Map<K, List<T>>
fun <K> ByteArray.groupBy( keySelector: (Byte) -> K ): Map<K, List<Byte>>
fun <K> ShortArray.groupBy( keySelector: (Short) -> K ): Map<K, List<Short>>
fun <K> IntArray.groupBy( keySelector: (Int) -> K ): Map<K, List<Int>>
fun <K> LongArray.groupBy( keySelector: (Long) -> K ): Map<K, List<Long>>
fun <K> FloatArray.groupBy( keySelector: (Float) -> K ): Map<K, List<Float>>
fun <K> DoubleArray.groupBy( keySelector: (Double) -> K ): Map<K, List<Double>>
fun <K> BooleanArray.groupBy( keySelector: (Boolean) -> K ): Map<K, List<Boolean>>
fun <K> CharArray.groupBy( keySelector: (Char) -> K ): Map<K, List<Char>>
fun <K> UIntArray.groupBy( keySelector: (UInt) -> K ): Map<K, List<UInt>>
fun <K> ULongArray.groupBy( keySelector: (ULong) -> K ): Map<K, List<ULong>>
fun <K> UByteArray.groupBy( keySelector: (UByte) -> K ): Map<K, List<UByte>>
fun <K> UShortArray.groupBy( keySelector: (UShort) -> K ): Map<K, List<UShort>>
Группирует значения, возвращаемые функцией valueTransform, применённой к каждому элементу исходного массива, по ключу, возвращаемому заданной функцией keySelector, применённой к элементу, и возвращает карту, где каждый ключ группы сопоставлен списку соответствующих значений.
fun <T, K, V> Array<out T>.groupBy( keySelector: (T) -> K, valueTransform: (T) -> V ): Map<K, List<V>>
fun <K, V> ByteArray.groupBy( keySelector: (Byte) -> K, valueTransform: (Byte) -> V ): Map<K, List<V>>
fun <K, V> ShortArray.groupBy( keySelector: (Short) -> K, valueTransform: (Short) -> V ): Map<K, List<V>>
fun <K, V> IntArray.groupBy( keySelector: (Int) -> K, valueTransform: (Int) -> V ): Map<K, List<V>>
fun <K, V> LongArray.groupBy( keySelector: (Long) -> K, valueTransform: (Long) -> V ): Map<K, List<V>>
fun <K, V> FloatArray.groupBy( keySelector: (Float) -> K, valueTransform: (Float) -> V ): Map<K, List<V>>
fun <K, V> DoubleArray.groupBy( keySelector: (Double) -> K, valueTransform: (Double) -> V ): Map<K, List<V>>
fun <K, V> BooleanArray.groupBy( keySelector: (Boolean) -> K, valueTransform: (Boolean) -> V ): Map<K, List<V>>
fun <K, V> CharArray.groupBy( keySelector: (Char) -> K, valueTransform: (Char) -> V ): Map<K, List<V>>
fun <K, V> UIntArray.groupBy( keySelector: (UInt) -> K, valueTransform: (UInt) -> V ): Map<K, List<V>>
fun <K, V> ULongArray.groupBy( keySelector: (ULong) -> K, valueTransform: (ULong) -> V ): Map<K, List<V>>
fun <K, V> UByteArray.groupBy( keySelector: (UByte) -> K, valueTransform: (UByte) -> V ): Map<K, List<V>>
fun <K, V> UShortArray.groupBy( keySelector: (UShort) -> K, valueTransform: (UShort) -> V ): Map<K, List<V>>
Группирует элементы исходной коллекции по ключу, возвращаемому заданной функцией keySelector, применённой к каждому элементу, и возвращает карту, где каждый ключ группы сопоставлен списку соответствующих элементов.
fun <T, K> Iterable<T>.groupBy( keySelector: (T) -> K ): Map<K, List<T>>
Группирует значения, возвращаемые функцией valueTransform, применённой к каждому элементу исходной коллекции, по ключу, возвращаемому заданной функцией keySelector, применённой к элементу, и возвращает карту, где каждый ключ группы сопоставлен списку соответствующих значений.
fun <T, K, V> Iterable<T>.groupBy( keySelector: (T) -> K, valueTransform: (T) -> V ): Map<K, List<V>>
groupByTo
Группирует элементы исходного массива по ключу, возвращаемому заданной функцией keySelector, применённой к каждому элементу, и помещает в карту destination каждый ключ группы, связанный со списком соответствующих элементов.
fun <T, K, M : MutableMap<in K, MutableList<T>>> Array<out T>.groupByTo( destination: M, keySelector: (T) -> K ): M
fun <K, M : MutableMap<in K, MutableList<Byte>>> ByteArray.groupByTo( destination: M, keySelector: (Byte) -> K ): M
fun <K, M : MutableMap<in K, MutableList<Short>>> ShortArray.groupByTo( destination: M, keySelector: (Short) -> K ): M
fun <K, M : MutableMap<in K, MutableList<Int>>> IntArray.groupByTo( destination: M, keySelector: (Int) -> K ): M
fun <K, M : MutableMap<in K, MutableList<Long>>> LongArray.groupByTo( destination: M, keySelector: (Long) -> K ): M
fun <K, M : MutableMap<in K, MutableList<Float>>> FloatArray.groupByTo( destination: M, keySelector: (Float) -> K ): M
fun <K, M : MutableMap<in K, MutableList<Double>>> DoubleArray.groupByTo( destination: M, keySelector: (Double) -> K ): M
fun <K, M : MutableMap<in K, MutableList<Boolean>>> BooleanArray.groupByTo( destination: M, keySelector: (Boolean) -> K ): M
fun <K, M : MutableMap<in K, MutableList<Char>>> CharArray.groupByTo( destination: M, keySelector: (Char) -> K ): M
fun <K, M : MutableMap<in K, MutableList<UInt>>> UIntArray.groupByTo( destination: M, keySelector: (UInt) -> K ): M
fun <K, M : MutableMap<in K, MutableList<ULong>>> ULongArray.groupByTo( destination: M, keySelector: (ULong) -> K ): M
fun <K, M : MutableMap<in K, MutableList<UByte>>> UByteArray.groupByTo( destination: M, keySelector: (UByte) -> K ): M
fun <K, M : MutableMap<in K, MutableList<UShort>>> UShortArray.groupByTo( destination: M, keySelector: (UShort) -> K ): M
Группирует значения, возвращаемые функцией valueTransform, применённой к каждому элементу исходного массива, по ключу, возвращаемому заданной функцией keySelector, применённой к элементу, и помещает в карту destination каждый ключ группы, связанный со списком соответствующих значений.
fun <T, K, V, M : MutableMap<in K, MutableList<V>>> Array<out T>.groupByTo( destination: M, keySelector: (T) -> K, valueTransform: (T) -> V ): M
fun <K, V, M : MutableMap<in K, MutableList<V>>> ByteArray.groupByTo( destination: M, keySelector: (Byte) -> K, valueTransform: (Byte) -> V ): M
fun <K, V, M : MutableMap<in K, MutableList<V>>> ShortArray.groupByTo( destination: M, keySelector: (Short) -> K, valueTransform: (Short) -> V ): M
fun <K, V, M : MutableMap<in K, MutableList<V>>> IntArray.groupByTo( destination: M, keySelector: (Int) -> K, valueTransform: (Int) -> V ): M
fun <K, V, M : MutableMap<in K, MutableList<V>>> LongArray.groupByTo( destination: M, keySelector: (Long) -> K, valueTransform: (Long) -> V ): M
fun <K, V, M : MutableMap<in K, MutableList<V>>> FloatArray.groupByTo( destination: M, keySelector: (Float) -> K, valueTransform: (Float) -> V ): M
fun <K, V, M : MutableMap<in K, MutableList<V>>> DoubleArray.groupByTo( destination: M, keySelector: (Double) -> K, valueTransform: (Double) -> V ): M
fun <K, V, M : MutableMap<in K, MutableList<V>>> BooleanArray.groupByTo( destination: M, keySelector: (Boolean) -> K, valueTransform: (Boolean) -> V ): M
fun <K, V, M : MutableMap<in K, MutableList<V>>> CharArray.groupByTo( destination: M, keySelector: (Char) -> K, valueTransform: (Char) -> V ): M
fun <K, V, M : MutableMap<in K, MutableList<V>>> UIntArray.groupByTo( destination: M, keySelector: (UInt) -> K, valueTransform: (UInt) -> V ): M
fun <K, V, M : MutableMap<in K, MutableList<V>>> ULongArray.groupByTo( destination: M, keySelector: (ULong) -> K, valueTransform: (ULong) -> V ): M
fun <K, V, M : MutableMap<in K, MutableList<V>>> UByteArray.groupByTo( destination: M, keySelector: (UByte) -> K, valueTransform: (UByte) -> V ): M
fun <K, V, M : MutableMap<in K, MutableList<V>>> UShortArray.groupByTo( destination: M, keySelector: (UShort) -> K, valueTransform: (UShort) -> V ): M
Группирует элементы исходной коллекции по ключу, возвращаемому заданной функцией keySelector, применённой к каждому элементу, и помещает в карту destination каждый ключ группы, связанный со списком соответствующих элементов.
fun <T, K, M : MutableMap<in K, MutableList<T>>> Iterable<T>.groupByTo( destination: M, keySelector: (T) -> K ): M
Группирует значения, возвращаемые функцией valueTransform, применённой к каждому элементу исходной коллекции, по ключу, возвращаемому заданной функцией keySelector, применённой к элементу, и помещает в карту destination каждый ключ группы, связанный со списком соответствующих значений.
fun <T, K, V, M : MutableMap<in K, MutableList<V>>> Iterable<T>.groupByTo( destination: M, keySelector: (T) -> K, valueTransform: (T) -> V ): M
groupingBy
Создаёт источник группировки Grouping из массива для последующего использования с одной из операций группировки и сворачивания, используя заданную функцию keySelector для извлечения ключа из каждого элемента.
fun <T, K> Array<out T>.groupingBy( keySelector: (T) -> K ): Grouping<T, K>
Создаёт источник группировки Grouping из коллекции для последующего использования с одной из операций группировки и сворачивания, используя заданную функцию keySelector для извлечения ключа из каждого элемента.
fun <T, K> Iterable<T>.groupingBy( keySelector: (T) -> K ): Grouping<T, K>
hashMapOf
Возвращает новую пустую карту HashMap.
fun <K, V> hashMapOf(): HashMap<K, V>
Возвращает новую карту HashMap с указанным содержимым, заданным в виде списка пар, где первый компонент — ключ, а второй — значение.
fun <K, V> hashMapOf(vararg pairs: Pair<K, V>): HashMap<K, V>
ifEmpty
Возвращает этот массив, если он не пустой, или результат вызова функции defaultValue, если массив пустой.
fun <C, R> C.ifEmpty( defaultValue: () -> R ): R where C : Array<*>, C : R
Возвращает эту карту, если она не пустая, или результат вызова функции defaultValue, если карта пустая.
fun <M, R> M.ifEmpty( defaultValue: () -> R ): R where M : Map<*, *>, M : R
indexOf
Возвращает первый индекс элемента, или -1, если массив не содержит элемент.
fun <T> Array<out T>.indexOf(element: T): Int
fun ByteArray.indexOf(element: Byte): Int
fun ShortArray.indexOf(element: Short): Int
fun IntArray.indexOf(element: Int): Int
fun LongArray.indexOf(element: Long): Int
fun FloatArray.indexOf(element: Float): Int
fun DoubleArray.indexOf(element: Double): Int
fun BooleanArray.indexOf(element: Boolean): Int
fun CharArray.indexOf(element: Char): Int
fun UIntArray.indexOf(element: UInt): Int
fun ULongArray.indexOf(element: ULong): Int
fun UByteArray.indexOf(element: UByte): Int
fun UShortArray.indexOf(element: UShort): Int
Возвращает первый индекс элемента, или -1, если коллекция не содержит элемент.
fun <T> Iterable<T>.indexOf(element: T): Int
Возвращает первый индекс элемента, или -1, если список не содержит элемент.
fun <T> List<T>.indexOf(element: T): Int
indexOfFirst
Возвращает индекс первого элемента, соответствующего заданному предикату, или -1, если массив не содержит такой элемент.
fun <T> Array<out T>.indexOfFirst( predicate: (T) -> Boolean ): Int
fun ByteArray.indexOfFirst(predicate: (Byte) -> Boolean): Int
fun ShortArray.indexOfFirst( predicate: (Short) -> Boolean ): Int
fun IntArray.indexOfFirst(predicate: (Int) -> Boolean): Int
fun LongArray.indexOfFirst(predicate: (Long) -> Boolean): Int
fun FloatArray.indexOfFirst( predicate: (Float) -> Boolean ): Int
fun DoubleArray.indexOfFirst( predicate: (Double) -> Boolean ): Int
fun BooleanArray.indexOfFirst( predicate: (Boolean) -> Boolean ): Int
fun CharArray.indexOfFirst(predicate: (Char) -> Boolean): Int
fun UIntArray.indexOfFirst(predicate: (UInt) -> Boolean): Int
fun ULongArray.indexOfFirst( predicate: (ULong) -> Boolean ): Int
fun UByteArray.indexOfFirst( predicate: (UByte) -> Boolean ): Int
fun UShortArray.indexOfFirst( predicate: (UShort) -> Boolean ): Int
Возвращает индекс первого элемента, соответствующего заданному предикату, или -1, если коллекция не содержит такой элемент.
fun <T> Iterable<T>.indexOfFirst( predicate: (T) -> Boolean ): Int
Возвращает индекс первого элемента, соответствующего заданному предикату, или -1, если список не содержит такой элемент.
fun <T> List<T>.indexOfFirst(predicate: (T) -> Boolean): Int
indexOfLast
Возвращает индекс последнего элемента, соответствующего заданному предикату, или -1, если массив не содержит такой элемент.
fun <T> Array<out T>.indexOfLast( predicate: (T) -> Boolean ): Int
fun ByteArray.indexOfLast(predicate: (Byte) -> Boolean): Int
fun ShortArray.indexOfLast( predicate: (Short) -> Boolean ): Int
fun IntArray.indexOfLast(predicate: (Int) -> Boolean): Int
fun LongArray.indexOfLast(predicate: (Long) -> Boolean): Int
fun FloatArray.indexOfLast( predicate: (Float) -> Boolean ): Int
fun DoubleArray.indexOfLast( predicate: (Double) -> Boolean ): Int
fun BooleanArray.indexOfLast( predicate: (Boolean) -> Boolean ): Int
fun UIntArray.indexOfLast(predicate: (UInt) -> Boolean): Int
fun ULongArray.indexOfLast( predicate: (ULong) -> Boolean ): Int
fun UByteArray.indexOfLast( predicate: (UByte) -> Boolean ): Int
fun UShortArray.indexOfLast( predicate: (UShort) -> Boolean ): Int
Возвращает индекс последнего элемента, соответствующего заданному предикату, или -1, если коллекция не содержит такой элемент.
fun <T> Iterable<T>.indexOfLast( predicate: (T) -> Boolean ): Int
Возвращает индекс последнего элемента, соответствующего заданному предикату, или -1, если список не содержит такой элемент.
fun <T> List<T>.indexOfLast(predicate: (T) -> Boolean): Int
intersect
Возвращает множество, содержащее все элементы, которые содержатся как в этом массиве, так и в указанной коллекции.
infix fun <T> any_array<T>.intersect( other: Iterable<T> ): Set<T>
Возвращает множество, содержащее все элементы, которые содержатся как в этой коллекции, так и в указанной коллекции.
infix fun <T> Iterable<T>.intersect( other: Iterable<T> ): Set<T>
isEmpty
Возвращает true если массив пустой.
fun <T> any_array<T>.isEmpty(): Boolean
isNotEmpty
Возвращает true если массив не пустой.
fun <T> any_array<T>.isNotEmpty(): Boolean
Возвращает true если коллекция не пуста.
fun <T> Collection<T>.isNotEmpty(): Boolean
Возвращает true если эта карта не пуста.
fun <K, V> Map<out K, V>.isNotEmpty(): Boolean
isNullOrEmpty
Возвращает true если этот массив с возможностью null либо null, либо пустой.
fun Array<*>?.isNullOrEmpty(): Boolean
Возвращает true если эта коллекция с возможностью null либо null, либо пуста.
fun <T> Collection<T>?.isNullOrEmpty(): Boolean
Возвращает true если эта карта с возможностью null либо null, либо пуста.
fun <K, V> Map<out K, V>?.isNullOrEmpty(): Boolean
Iterable
iterator
Возвращает предоставленный итератор. Это позволяет использовать экземпляр итератора в цикле for.
operator fun <T> Iterator<T>.iterator(): Iterator<T>
Возвращает Iterator по записям в Map.
operator fun <K, V> Map<out K, V>.iterator(): Iterator<Entry<K, V>>
Возвращает MutableIterator по изменяемым записям в MutableMap.
operator fun <K, V> MutableMap<K, V>.iterator(): MutableIterator<MutableEntry<K, V>>
joinTo
Добавляет строку из всех элементов, разделенных с помощью separator, используя заданные prefix и postfix, если они предоставлены.
fun <T, A : Appendable> Array<out T>.joinTo( buffer: A, separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: ((T) -> CharSequence)? = null ): A
fun <A : Appendable> ByteArray.joinTo( buffer: A, separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: ((Byte) -> CharSequence)? = null ): A
fun <A : Appendable> ShortArray.joinTo( buffer: A, separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: ((Short) -> CharSequence)? = null ): A
fun <A : Appendable> IntArray.joinTo( buffer: A, separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: ((Int) -> CharSequence)? = null ): A
fun <A : Appendable> LongArray.joinTo( buffer: A, separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: ((Long) -> CharSequence)? = null ): A
fun <A : Appendable> FloatArray.joinTo( buffer: A, separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: ((Float) -> CharSequence)? = null ): A
fun <A : Appendable> DoubleArray.joinTo( buffer: A, separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: ((Double) -> CharSequence)? = null ): A
fun <A : Appendable> BooleanArray.joinTo( buffer: A, separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: ((Boolean) -> CharSequence)? = null ): A
fun <A : Appendable> CharArray.joinTo( buffer: A, separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: ((Char) -> CharSequence)? = null ): A
fun <T, A : Appendable> Iterable<T>.joinTo( buffer: A, separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: ((T) -> CharSequence)? = null ): A
joinToString
Создает строку из всех элементов, разделенных с помощью separator и используя заданные prefix и postfix, если они предоставлены.
fun <T> Array<out T>.joinToString( separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: ((T) -> CharSequence)? = null ): String
fun ByteArray.joinToString( separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: ((Byte) -> CharSequence)? = null ): String
fun ShortArray.joinToString( separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: ((Short) -> CharSequence)? = null ): String
fun IntArray.joinToString( separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: ((Int) -> CharSequence)? = null ): String
fun LongArray.joinToString( separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: ((Long) -> CharSequence)? = null ): String
fun FloatArray.joinToString( separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: ((Float) -> CharSequence)? = null ): String
fun DoubleArray.joinToString( separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: ((Double) -> CharSequence)? = null ): String
fun BooleanArray.joinToString( separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: ((Boolean) -> CharSequence)? = null ): String
fun CharArray.joinToString( separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: ((Char) -> CharSequence)? = null ): String
fun <T> Iterable<T>.joinToString( separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "", limit: Int = -1, truncated: CharSequence = "...", transform: ((T) -> CharSequence)? = null ): String
последний
Возвращает последний элемент.
fun <T> Array<out T>.last(): T
fun ByteArray.last(): Byte
fun ShortArray.last(): Short
fun IntArray.last(): Int
fun LongArray.last(): Long
fun FloatArray.last(): Float
fun DoubleArray.last(): Double
fun BooleanArray.last(): Boolean
fun CharArray.last(): Char
fun <T> Iterable<T>.last(): T
fun <T> List<T>.last(): T
fun UIntArray.last(): UInt
fun ULongArray.last(): ULong
fun UByteArray.last(): UByte
fun UShortArray.last(): UShort
Возвращает последний элемент, соответствующий заданному предикату.
fun <T> Array<out T>.last(predicate: (T) -> Boolean): T
fun ByteArray.last(predicate: (Byte) -> Boolean): Byte
fun ShortArray.last(predicate: (Short) -> Boolean): Short
fun IntArray.last(predicate: (Int) -> Boolean): Int
fun LongArray.last(predicate: (Long) -> Boolean): Long
fun FloatArray.last(predicate: (Float) -> Boolean): Float
fun DoubleArray.last(predicate: (Double) -> Boolean): Double
fun BooleanArray.last( predicate: (Boolean) -> Boolean ): Boolean
fun CharArray.last(predicate: (Char) -> Boolean): Char
fun <T> Iterable<T>.last(predicate: (T) -> Boolean): T
fun <T> List<T>.last(predicate: (T) -> Boolean): T
fun UIntArray.last(predicate: (UInt) -> Boolean): UInt
fun ULongArray.last(predicate: (ULong) -> Boolean): ULong
fun UByteArray.last(predicate: (UByte) -> Boolean): UByte
fun UShortArray.last(predicate: (UShort) -> Boolean): UShort
lastIndexOf
Возвращает последний индекс элемента, или -1, если массив не содержит элемент.
fun <T> Array<out T>.lastIndexOf(element: T): Int
fun ByteArray.lastIndexOf(element: Byte): Int
fun ShortArray.lastIndexOf(element: Short): Int
fun IntArray.lastIndexOf(element: Int): Int
fun LongArray.lastIndexOf(element: Long): Int
fun FloatArray.lastIndexOf(element: Float): Int
fun DoubleArray.lastIndexOf(element: Double): Int
fun BooleanArray.lastIndexOf(element: Boolean): Int
fun CharArray.lastIndexOf(element: Char): Int
fun UIntArray.lastIndexOf(element: UInt): Int
fun ULongArray.lastIndexOf(element: ULong): Int
fun UByteArray.lastIndexOf(element: UByte): Int
fun UShortArray.lastIndexOf(element: UShort): Int
Возвращает последний индекс элемента, или -1, если коллекция не содержит элемент.
fun <T> Iterable<T>.lastIndexOf(element: T): Int
Возвращает последний индекс элемента, или -1, если список не содержит элемент.
fun <T> List<T>.lastIndexOf(element: T): Int
lastOrNull
Возвращает последний элемент или null если массив пустой.
fun <T> Array<out T>.lastOrNull(): T?
fun ByteArray.lastOrNull(): Byte?
fun ShortArray.lastOrNull(): Short?
fun IntArray.lastOrNull(): Int?
fun LongArray.lastOrNull(): Long?
fun FloatArray.lastOrNull(): Float?
fun DoubleArray.lastOrNull(): Double?
fun BooleanArray.lastOrNull(): Boolean?
fun CharArray.lastOrNull(): Char?
fun UIntArray.lastOrNull(): UInt?
fun ULongArray.lastOrNull(): ULong?
fun UByteArray.lastOrNull(): UByte?
fun UShortArray.lastOrNull(): UShort?
Возвращает последний элемент, соответствующий заданному предикату, или null если такой элемент не найден.
fun <T> Array<out T>.lastOrNull( predicate: (T) -> Boolean ): T?
fun ByteArray.lastOrNull(predicate: (Byte) -> Boolean): Byte?
fun ShortArray.lastOrNull( predicate: (Short) -> Boolean ): Short?
fun IntArray.lastOrNull(predicate: (Int) -> Boolean): Int?
fun LongArray.lastOrNull(predicate: (Long) -> Boolean): Long?
fun FloatArray.lastOrNull( predicate: (Float) -> Boolean ): Float?
fun DoubleArray.lastOrNull( predicate: (Double) -> Boolean ): Double?
fun BooleanArray.lastOrNull( predicate: (Boolean) -> Boolean ): Boolean?
fun CharArray.lastOrNull(predicate: (Char) -> Boolean): Char?
fun <T> Iterable<T>.lastOrNull(predicate: (T) -> Boolean): T?
fun <T> List<T>.lastOrNull(predicate: (T) -> Boolean): T?
fun UIntArray.lastOrNull(predicate: (UInt) -> Boolean): UInt?
fun ULongArray.lastOrNull( predicate: (ULong) -> Boolean ): ULong?
fun UByteArray.lastOrNull( predicate: (UByte) -> Boolean ): UByte?
fun UShortArray.lastOrNull( predicate: (UShort) -> Boolean ): UShort?
Возвращает последний элемент, или null если коллекция пуста.
fun <T> Iterable<T>.lastOrNull(): T?
Возвращает последний элемент, или null если список пустой.
fun <T> List<T>.lastOrNull(): T?
linkedMapOf
Возвращает пустой новый LinkedHashMap.
fun <K, V> linkedMapOf(): LinkedHashMap<K, V>
Возвращает новый LinkedHashMap с указанным содержимым, представленным в виде списка пар, где первый компонент — ключ, а второй — значение.
fun <K, V> linkedMapOf( vararg pairs: Pair<K, V> ): LinkedHashMap<K, V>
linkedSetOf
Возвращает пустой новый LinkedHashSet.
fun <T> linkedSetOf(): LinkedHashSet<T>
Возвращает новый LinkedHashSet с заданными элементами. Элементы множества итерируются в порядке их указания.
fun <T> linkedSetOf(vararg elements: T): LinkedHashSet<T>
linkedStringMapOf
Создаёт специализированную реализацию LinkedHashMap со строковыми ключами, которая хранит ключи как свойства объекта JS без их хэширования.
fun <V> linkedStringMapOf( vararg pairs: Pair<String, V> ): LinkedHashMap<String, V>
linkedStringSetOf
Создаёт новый экземпляр специализированной реализации LinkedHashSet со строковыми элементами, ключи которых хранятся как свойства объекта JS без их хэширования.
fun linkedStringSetOf( vararg elements: String ): LinkedHashSet<String>
List
Создаёт новый список для чтения с указанным размером, где каждый элемент вычисляется с помощью указанной функции инициализации.
fun <T> List(size: Int, init: (index: Int) -> T): List<T>
listOf
Возвращает новый неизменяемый список заданных элементов. Возвращаемый список сериализуем (JVM).
fun <T> listOf(vararg elements: T): List<T>
Возвращает пустой неизменяемый список. Возвращаемый список сериализуем (JVM).
fun <T> listOf(): List<T>
Возвращает неизменяемый список, содержащий только указанный объект element. Возвращаемый список сериализуем.
fun <T> listOf(element: T): List<T>
listOfNotNull
Возвращает новый список для чтения, либо содержащий единственный заданный элемент, если он не null, либо пустой список, если элемент null. Возвращаемый список сериализуем (JVM).
fun <T : Any> listOfNotNull(element: T?): List<T>
Возвращает новый список для чтения, содержащий только те элементы, которые не null. Возвращаемый список сериализуем (JVM).
fun <T : Any> listOfNotNull(vararg elements: T?): List<T>
map
Возвращает список, содержащий результаты применения заданной функции transform к каждому элементу в исходном массиве.
fun <T, R> Array<out T>.map(transform: (T) -> R): List<R>
fun <R> ByteArray.map(transform: (Byte) -> R): List<R>
fun <R> ShortArray.map(transform: (Short) -> R): List<R>
fun <R> IntArray.map(transform: (Int) -> R): List<R>
fun <R> LongArray.map(transform: (Long) -> R): List<R>
fun <R> FloatArray.map(transform: (Float) -> R): List<R>
fun <R> DoubleArray.map(transform: (Double) -> R): List<R>
fun <R> BooleanArray.map(transform: (Boolean) -> R): List<R>
fun <R> CharArray.map(transform: (Char) -> R): List<R>
fun <R> UIntArray.map(transform: (UInt) -> R): List<R>
fun <R> ULongArray.map(transform: (ULong) -> R): List<R>
fun <R> UByteArray.map(transform: (UByte) -> R): List<R>
fun <R> UShortArray.map(transform: (UShort) -> R): List<R>
Возвращает список, содержащий результаты применения заданной функции transform к каждому элементу в исходном наборе.
fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R>
Возвращает список, содержащий результаты применения заданной функции transform к каждой записи в исходном словаре.
fun <K, V, R> Map<out K, V>.map( transform: (Entry<K, V>) -> R ): List<R>
mapIndexed
Возвращает список, содержащий результаты применения заданной функции transform к каждому элементу и его индексу в исходном массиве.
fun <T, R> Array<out T>.mapIndexed( transform: (index: Int, T) -> R ): List<R>
fun <R> ByteArray.mapIndexed( transform: (index: Int, Byte) -> R ): List<R>
fun <R> ShortArray.mapIndexed( transform: (index: Int, Short) -> R ): List<R>
fun <R> IntArray.mapIndexed( transform: (index: Int, Int) -> R ): List<R>
fun <R> LongArray.mapIndexed( transform: (index: Int, Long) -> R ): List<R>
fun <R> FloatArray.mapIndexed( transform: (index: Int, Float) -> R ): List<R>
fun <R> DoubleArray.mapIndexed( transform: (index: Int, Double) -> R ): List<R>
fun <R> BooleanArray.mapIndexed( transform: (index: Int, Boolean) -> R ): List<R>
fun <R> CharArray.mapIndexed( transform: (index: Int, Char) -> R ): List<R>
fun <R> UIntArray.mapIndexed( transform: (index: Int, UInt) -> R ): List<R>
fun <R> ULongArray.mapIndexed( transform: (index: Int, ULong) -> R ): List<R>
fun <R> UByteArray.mapIndexed( transform: (index: Int, UByte) -> R ): List<R>
fun <R> UShortArray.mapIndexed( transform: (index: Int, UShort) -> R ): List<R>
Возвращает список, содержащий результаты применения заданной функции transform к каждому элементу и его индексу в исходном наборе.
fun <T, R> Iterable<T>.mapIndexed( transform: (index: Int, T) -> R ): List<R>
mapIndexedNotNull
Возвращает список, содержащий только результаты применения заданной функции transform к каждому элементу и его индексу в исходном массиве.
fun <T, R : Any> Array<out T>.mapIndexedNotNull( transform: (index: Int, T) -> R? ): List<R>
Возвращает список, содержащий только результаты применения заданной функции transform к каждому элементу и его индексу в исходном наборе.
fun <T, R : Any> Iterable<T>.mapIndexedNotNull( transform: (index: Int, T) -> R? ): List<R>
mapIndexedNotNullTo
Применяет заданную функцию transform к каждому элементу и его индексу в исходном массиве и добавляет только результаты, отличные от null, в заданное значение .
fun <T, R : Any, C : MutableCollection<in R>> Array<out T>.mapIndexedNotNullTo( destination: C, transform: (index: Int, T) -> R? ): C
Применяет заданную функцию transform к каждому элементу и его индексу в исходном наборе и добавляет только результаты, отличные от null, в заданное значение .
fun <T, R : Any, C : MutableCollection<in R>> Iterable<T>.mapIndexedNotNullTo( destination: C, transform: (index: Int, T) -> R? ): C
mapIndexedTo
Применяет заданную функцию transform к каждому элементу и его индексу в исходном массиве и добавляет результаты в заданный destination.
fun <T, R, C : MutableCollection<in R>> Array<out T>.mapIndexedTo( destination: C, transform: (index: Int, T) -> R ): C
fun <R, C : MutableCollection<in R>> ByteArray.mapIndexedTo( destination: C, transform: (index: Int, Byte) -> R ): C
fun <R, C : MutableCollection<in R>> ShortArray.mapIndexedTo( destination: C, transform: (index: Int, Short) -> R ): C
fun <R, C : MutableCollection<in R>> IntArray.mapIndexedTo( destination: C, transform: (index: Int, Int) -> R ): C
fun <R, C : MutableCollection<in R>> LongArray.mapIndexedTo( destination: C, transform: (index: Int, Long) -> R ): C
fun <R, C : MutableCollection<in R>> FloatArray.mapIndexedTo( destination: C, transform: (index: Int, Float) -> R ): C
fun <R, C : MutableCollection<in R>> DoubleArray.mapIndexedTo( destination: C, transform: (index: Int, Double) -> R ): C
fun <R, C : MutableCollection<in R>> BooleanArray.mapIndexedTo( destination: C, transform: (index: Int, Boolean) -> R ): C
fun <R, C : MutableCollection<in R>> CharArray.mapIndexedTo( destination: C, transform: (index: Int, Char) -> R ): C
fun <R, C : MutableCollection<in R>> UIntArray.mapIndexedTo( destination: C, transform: (index: Int, UInt) -> R ): C
fun <R, C : MutableCollection<in R>> ULongArray.mapIndexedTo( destination: C, transform: (index: Int, ULong) -> R ): C
fun <R, C : MutableCollection<in R>> UByteArray.mapIndexedTo( destination: C, transform: (index: Int, UByte) -> R ): C
fun <R, C : MutableCollection<in R>> UShortArray.mapIndexedTo( destination: C, transform: (index: Int, UShort) -> R ): C
Применяет заданную функцию transform к каждому элементу и его индексу в исходном наборе и добавляет результаты в заданный destination.
fun <T, R, C : MutableCollection<in R>> Iterable<T>.mapIndexedTo( destination: C, transform: (index: Int, T) -> R ): C
mapKeys
mapKeysTo
Заполняет заданный destination map записями, имеющими ключи, полученные путем применения функции transform к каждой записи в этом Map и значениями этого map.
fun <K, V, R, M : MutableMap<in R, in V>> Map<out K, V>.mapKeysTo( destination: M, transform: (Entry<K, V>) -> R ): M
mapNotNull
Возвращает список, содержащий только результаты, отличные от null, применения заданной функции transform к каждому элементу в исходном массиве.
fun <T, R : Any> Array<out T>.mapNotNull( transform: (T) -> R? ): List<R>
Возвращает список, содержащий только результаты, отличные от null, применения заданной функции transform к каждому элементу в исходном наборе.
fun <T, R : Any> Iterable<T>.mapNotNull( transform: (T) -> R? ): List<R>
Возвращает список, содержащий только результаты, отличные от null, применения заданной функции transform к каждой записи в исходном map.
fun <K, V, R : Any> Map<out K, V>.mapNotNull( transform: (Entry<K, V>) -> R? ): List<R>
mapNotNullTo
Применяет заданную функцию transform к каждому элементу в исходном массиве и добавляет только результаты, отличные от null, в заданный destination.
fun <T, R : Any, C : MutableCollection<in R>> Array<out T>.mapNotNullTo( destination: C, transform: (T) -> R? ): C
Применяет заданную функцию transform к каждому элементу в исходном наборе и добавляет только результаты, отличные от null, в заданный destination.
fun <T, R : Any, C : MutableCollection<in R>> Iterable<T>.mapNotNullTo( destination: C, transform: (T) -> R? ): C
Применяет заданную функцию transform к каждой записи в исходном map и добавляет только результаты, отличные от null, в заданный destination.
fun <K, V, R : Any, C : MutableCollection<in R>> Map<out K, V>.mapNotNullTo( destination: C, transform: (Entry<K, V>) -> R? ): C
mapOf
Возвращает новое неизменяемое отображение со указанным содержимым, заданным в виде списка пар, где первое значение — ключ, а второе — значение.
fun <K, V> mapOf(vararg pairs: Pair<K, V>): Map<K, V>
Возвращает пустое неизменяемое отображение.
fun <K, V> mapOf(): Map<K, V>
Возвращает неизменяемое отображение, сопоставляющее только указанный ключ со значением.
fun <K, V> mapOf(pair: Pair<K, V>): Map<K, V>
mapTo
Применяет заданную функцию transform к каждому элементу исходного массива и добавляет результаты в заданное назначение.
fun <T, R, C : MutableCollection<in R>> Array<out T>.mapTo( destination: C, transform: (T) -> R ): C
fun <R, C : MutableCollection<in R>> ByteArray.mapTo( destination: C, transform: (Byte) -> R ): C
fun <R, C : MutableCollection<in R>> ShortArray.mapTo( destination: C, transform: (Short) -> R ): C
fun <R, C : MutableCollection<in R>> IntArray.mapTo( destination: C, transform: (Int) -> R ): C
fun <R, C : MutableCollection<in R>> LongArray.mapTo( destination: C, transform: (Long) -> R ): C
fun <R, C : MutableCollection<in R>> FloatArray.mapTo( destination: C, transform: (Float) -> R ): C
fun <R, C : MutableCollection<in R>> DoubleArray.mapTo( destination: C, transform: (Double) -> R ): C
fun <R, C : MutableCollection<in R>> BooleanArray.mapTo( destination: C, transform: (Boolean) -> R ): C
fun <R, C : MutableCollection<in R>> CharArray.mapTo( destination: C, transform: (Char) -> R ): C
fun <R, C : MutableCollection<in R>> UIntArray.mapTo( destination: C, transform: (UInt) -> R ): C
fun <R, C : MutableCollection<in R>> ULongArray.mapTo( destination: C, transform: (ULong) -> R ): C
fun <R, C : MutableCollection<in R>> UByteArray.mapTo( destination: C, transform: (UByte) -> R ): C
fun <R, C : MutableCollection<in R>> UShortArray.mapTo( destination: C, transform: (UShort) -> R ): C
Применяет заданную функцию transform к каждому элементу исходного набора и добавляет результаты в заданное назначение.
fun <T, R, C : MutableCollection<in R>> Iterable<T>.mapTo( destination: C, transform: (T) -> R ): C
Применяет заданную функцию transform к каждой записи исходного отображения и добавляет результаты в заданное назначение.
fun <K, V, R, C : MutableCollection<in R>> Map<out K, V>.mapTo( destination: C, transform: (Entry<K, V>) -> R ): C
mapValues
Возвращает новое отображение со записями, имеющими ключи этого отображения и значениями, полученными путём применения функции transform к каждой записи в этом отображении.
fun <K, V, R> Map<out K, V>.mapValues( transform: (Entry<K, V>) -> R ): Map<K, R>
mapValuesTo
Заполняет заданное назначение отображение записями, имеющими ключи этого отображения и значениями, полученными путём применения функции transform к каждой записи в этом отображении.
fun <K, V, R, M : MutableMap<in K, in R>> Map<out K, V>.mapValuesTo( destination: M, transform: (Entry<K, V>) -> R ): M
max
Возвращает наибольший элемент.
fun Array<out Double>.max(): Double
fun Array<out Double>.max(): Double?
fun Array<out Float>.max(): Float
fun Array<out Float>.max(): Float?
fun <T : Comparable<T>> Array<out T>.max(): T
fun <T : Comparable<T>> Array<out T>.max(): T?
fun ByteArray.max(): Byte
fun ByteArray.max(): Byte?
fun ShortArray.max(): Short
fun ShortArray.max(): Short?
fun IntArray.max(): Int
fun IntArray.max(): Int?
fun LongArray.max(): Long
fun LongArray.max(): Long?
fun FloatArray.max(): Float
fun FloatArray.max(): Float?
fun DoubleArray.max(): Double
fun DoubleArray.max(): Double?
fun CharArray.max(): Char
fun Iterable<Double>.max(): Double?
fun Iterable<Float>.max(): Float
fun Iterable<Float>.max(): Float?
fun <T : Comparable<T>> Iterable<T>.max(): T
fun <T : Comparable<T>> Iterable<T>.max(): T?
fun UIntArray.max(): UInt
fun UIntArray.max(): UInt?
fun ULongArray.max(): ULong
fun ULongArray.max(): ULong?
fun UByteArray.max(): UByte
fun UByteArray.max(): UByte?
fun UShortArray.max(): UShort
fun UShortArray.max(): UShort?
maxBy
Возвращает первый элемент, дающий наибольшее значение заданной функции.
fun <T, R : Comparable<R>> Array<out T>.maxBy( selector: (T) -> R ): T
fun <T, R : Comparable<R>> Array<out T>.maxBy( selector: (T) -> R ): T?
fun <R : Comparable<R>> ByteArray.maxBy( selector: (Byte) -> R ): Byte
fun <R : Comparable<R>> ByteArray.maxBy( selector: (Byte) -> R ): Byte?
fun <R : Comparable<R>> ShortArray.maxBy( selector: (Short) -> R ): Short
fun <R : Comparable<R>> ShortArray.maxBy( selector: (Short) -> R ): Short?
fun <R : Comparable<R>> IntArray.maxBy( selector: (Int) -> R ): Int
fun <R : Comparable<R>> IntArray.maxBy( selector: (Int) -> R ): Int?
fun <R : Comparable<R>> LongArray.maxBy( selector: (Long) -> R ): Long
fun <R : Comparable<R>> LongArray.maxBy( selector: (Long) -> R ): Long?
fun <R : Comparable<R>> FloatArray.maxBy( selector: (Float) -> R ): Float
fun <R : Comparable<R>> FloatArray.maxBy( selector: (Float) -> R ): Float?
fun <R : Comparable<R>> DoubleArray.maxBy( selector: (Double) -> R ): Double
fun <R : Comparable<R>> DoubleArray.maxBy( selector: (Double) -> R ): Double?
fun <R : Comparable<R>> BooleanArray.maxBy( selector: (Boolean) -> R ): Boolean
fun <R : Comparable<R>> BooleanArray.maxBy( selector: (Boolean) -> R ): Boolean?
fun <R : Comparable<R>> CharArray.maxBy( selector: (Char) -> R ): Char
fun <R : Comparable<R>> CharArray.maxBy( selector: (Char) -> R ): Char?
fun <T, R : Comparable<R>> Iterable<T>.maxBy( selector: (T) -> R ): T
fun <T, R : Comparable<R>> Iterable<T>.maxBy( selector: (T) -> R ): T?
fun <R : Comparable<R>> UIntArray.maxBy( selector: (UInt) -> R ): UInt
fun <R : Comparable<R>> UIntArray.maxBy( selector: (UInt) -> R ): UInt?
fun <R : Comparable<R>> ULongArray.maxBy( selector: (ULong) -> R ): ULong
fun <R : Comparable<R>> ULongArray.maxBy( selector: (ULong) -> R ): ULong?
fun <R : Comparable<R>> UByteArray.maxBy( selector: (UByte) -> R ): UByte
fun <R : Comparable<R>> UByteArray.maxBy( selector: (UByte) -> R ): UByte?
fun <R : Comparable<R>> UShortArray.maxBy( selector: (UShort) -> R ): UShort
fun <R : Comparable<R>> UShortArray.maxBy( selector: (UShort) -> R ): UShort?
Возвращает первую запись, дающую наибольшее значение заданной функции.
fun <K, V, R : Comparable<R>> Map<out K, V>.maxBy( selector: (Entry<K, V>) -> R ): Entry<K, V>
fun <K, V, R : Comparable<R>> Map<out K, V>.maxBy( selector: (Entry<K, V>) -> R ): Entry<K, V>?
maxByOrNull
Возвращает первый элемент, дающий наибольшее значение заданной функции, или null , если элементов нет.
fun <T, R : Comparable<R>> Array<out T>.maxByOrNull( selector: (T) -> R ): T?
fun <R : Comparable<R>> ByteArray.maxByOrNull( selector: (Byte) -> R ): Byte?
fun <R : Comparable<R>> ShortArray.maxByOrNull( selector: (Short) -> R ): Short?
fun <R : Comparable<R>> IntArray.maxByOrNull( selector: (Int) -> R ): Int?
fun <R : Comparable<R>> LongArray.maxByOrNull( selector: (Long) -> R ): Long?
fun <R : Comparable<R>> FloatArray.maxByOrNull( selector: (Float) -> R ): Float?
fun <R : Comparable<R>> DoubleArray.maxByOrNull( selector: (Double) -> R ): Double?
fun <R : Comparable<R>> BooleanArray.maxByOrNull( selector: (Boolean) -> R ): Boolean?
fun <R : Comparable<R>> CharArray.maxByOrNull( selector: (Char) -> R ): Char?
fun <T, R : Comparable<R>> Iterable<T>.maxByOrNull( selector: (T) -> R ): T?
fun <R : Comparable<R>> UIntArray.maxByOrNull( selector: (UInt) -> R ): UInt?
fun <R : Comparable<R>> ULongArray.maxByOrNull( selector: (ULong) -> R ): ULong?
fun <R : Comparable<R>> UByteArray.maxByOrNull( selector: (UByte) -> R ): UByte?
fun <R : Comparable<R>> UShortArray.maxByOrNull( selector: (UShort) -> R ): UShort?
Возвращает первую пару, дающую наибольшее значение заданной функции, или null , если пар нет.
fun <K, V, R : Comparable<R>> Map<out K, V>.maxByOrNull( selector: (Entry<K, V>) -> R ): Entry<K, V>?
maxOf
Возвращает наибольшее значение среди всех значений, полученных при применении функции selector к каждому элементу в массиве.
fun <T> Array<out T>.maxOf(selector: (T) -> Double): Double
fun ByteArray.maxOf(selector: (Byte) -> Double): Double
fun ShortArray.maxOf(selector: (Short) -> Double): Double
fun IntArray.maxOf(selector: (Int) -> Double): Double
fun LongArray.maxOf(selector: (Long) -> Double): Double
fun FloatArray.maxOf(selector: (Float) -> Double): Double
fun DoubleArray.maxOf(selector: (Double) -> Double): Double
fun BooleanArray.maxOf(selector: (Boolean) -> Double): Double
fun CharArray.maxOf(selector: (Char) -> Double): Double
fun <T> Array<out T>.maxOf(selector: (T) -> Float): Float
fun ByteArray.maxOf(selector: (Byte) -> Float): Float
fun ShortArray.maxOf(selector: (Short) -> Float): Float
fun IntArray.maxOf(selector: (Int) -> Float): Float
fun LongArray.maxOf(selector: (Long) -> Float): Float
fun FloatArray.maxOf(selector: (Float) -> Float): Float
fun DoubleArray.maxOf(selector: (Double) -> Float): Float
fun BooleanArray.maxOf(selector: (Boolean) -> Float): Float
fun CharArray.maxOf(selector: (Char) -> Float): Float
fun <T, R : Comparable<R>> Array<out T>.maxOf( selector: (T) -> R ): R
fun <R : Comparable<R>> ByteArray.maxOf( selector: (Byte) -> R ): R
fun <R : Comparable<R>> ShortArray.maxOf( selector: (Short) -> R ): R
fun <R : Comparable<R>> IntArray.maxOf( selector: (Int) -> R ): R
fun <R : Comparable<R>> LongArray.maxOf( selector: (Long) -> R ): R
fun <R : Comparable<R>> FloatArray.maxOf( selector: (Float) -> R ): R
fun <R : Comparable<R>> DoubleArray.maxOf( selector: (Double) -> R ): R
fun <R : Comparable<R>> BooleanArray.maxOf( selector: (Boolean) -> R ): R
fun <R : Comparable<R>> CharArray.maxOf( selector: (Char) -> R ): R
fun UIntArray.maxOf(selector: (UInt) -> Double): Double
fun ULongArray.maxOf(selector: (ULong) -> Double): Double
fun UByteArray.maxOf(selector: (UByte) -> Double): Double
fun UShortArray.maxOf(selector: (UShort) -> Double): Double
fun UIntArray.maxOf(selector: (UInt) -> Float): Float
fun ULongArray.maxOf(selector: (ULong) -> Float): Float
fun UByteArray.maxOf(selector: (UByte) -> Float): Float
fun UShortArray.maxOf(selector: (UShort) -> Float): Float
fun <R : Comparable<R>> UIntArray.maxOf( selector: (UInt) -> R ): R
fun <R : Comparable<R>> ULongArray.maxOf( selector: (ULong) -> R ): R
fun <R : Comparable<R>> UByteArray.maxOf( selector: (UByte) -> R ): R
fun <R : Comparable<R>> UShortArray.maxOf( selector: (UShort) -> R ): R
Возвращает наибольшее значение среди всех значений, полученных при применении функции selector к каждому элементу в коллекции.
fun <T> Iterable<T>.maxOf(selector: (T) -> Double): Double
fun <T> Iterable<T>.maxOf(selector: (T) -> Float): Float
fun <T, R : Comparable<R>> Iterable<T>.maxOf( selector: (T) -> R ): R
Возвращает наибольшее значение среди всех значений, полученных при применении функции selector к каждой паре в карте.
fun <K, V> Map<out K, V>.maxOf( selector: (Entry<K, V>) -> Double ): Double
fun <K, V> Map<out K, V>.maxOf( selector: (Entry<K, V>) -> Float ): Float
fun <K, V, R : Comparable<R>> Map<out K, V>.maxOf( selector: (Entry<K, V>) -> R ): R
maxOfOrNull
Возвращает наибольшее значение среди всех значений, полученных функцией selector, применённой к каждому элементу в массиве, или null если элементов нет.
fun <T> Array<out T>.maxOfOrNull( selector: (T) -> Double ): Double?
fun ByteArray.maxOfOrNull( selector: (Byte) -> Double ): Double?
fun ShortArray.maxOfOrNull( selector: (Short) -> Double ): Double?
fun IntArray.maxOfOrNull(selector: (Int) -> Double): Double?
fun LongArray.maxOfOrNull( selector: (Long) -> Double ): Double?
fun FloatArray.maxOfOrNull( selector: (Float) -> Double ): Double?
fun DoubleArray.maxOfOrNull( selector: (Double) -> Double ): Double?
fun BooleanArray.maxOfOrNull( selector: (Boolean) -> Double ): Double?
fun CharArray.maxOfOrNull( selector: (Char) -> Double ): Double?
fun <T> Array<out T>.maxOfOrNull( selector: (T) -> Float ): Float?
fun ByteArray.maxOfOrNull(selector: (Byte) -> Float): Float?
fun ShortArray.maxOfOrNull( selector: (Short) -> Float ): Float?
fun IntArray.maxOfOrNull(selector: (Int) -> Float): Float?
fun LongArray.maxOfOrNull(selector: (Long) -> Float): Float?
fun FloatArray.maxOfOrNull( selector: (Float) -> Float ): Float?
fun DoubleArray.maxOfOrNull( selector: (Double) -> Float ): Float?
fun BooleanArray.maxOfOrNull( selector: (Boolean) -> Float ): Float?
fun CharArray.maxOfOrNull(selector: (Char) -> Float): Float?
fun <T, R : Comparable<R>> Array<out T>.maxOfOrNull( selector: (T) -> R ): R?
fun <R : Comparable<R>> ByteArray.maxOfOrNull( selector: (Byte) -> R ): R?
fun <R : Comparable<R>> ShortArray.maxOfOrNull( selector: (Short) -> R ): R?
fun <R : Comparable<R>> IntArray.maxOfOrNull( selector: (Int) -> R ): R?
fun <R : Comparable<R>> LongArray.maxOfOrNull( selector: (Long) -> R ): R?
fun <R : Comparable<R>> FloatArray.maxOfOrNull( selector: (Float) -> R ): R?
fun <R : Comparable<R>> DoubleArray.maxOfOrNull( selector: (Double) -> R ): R?
fun <R : Comparable<R>> BooleanArray.maxOfOrNull( selector: (Boolean) -> R ): R?
fun <R : Comparable<R>> CharArray.maxOfOrNull( selector: (Char) -> R ): R?
fun UIntArray.maxOfOrNull( selector: (UInt) -> Double ): Double?
fun ULongArray.maxOfOrNull( selector: (ULong) -> Double ): Double?
fun UByteArray.maxOfOrNull( selector: (UByte) -> Double ): Double?
fun UShortArray.maxOfOrNull( selector: (UShort) -> Double ): Double?
fun UIntArray.maxOfOrNull(selector: (UInt) -> Float): Float?
fun ULongArray.maxOfOrNull( selector: (ULong) -> Float ): Float?
fun UByteArray.maxOfOrNull( selector: (UByte) -> Float ): Float?
fun UShortArray.maxOfOrNull( selector: (UShort) -> Float ): Float?
fun <R : Comparable<R>> UIntArray.maxOfOrNull( selector: (UInt) -> R ): R?
fun <R : Comparable<R>> ULongArray.maxOfOrNull( selector: (ULong) -> R ): R?
fun <R : Comparable<R>> UByteArray.maxOfOrNull( selector: (UByte) -> R ): R?
fun <R : Comparable<R>> UShortArray.maxOfOrNull( selector: (UShort) -> R ): R?
Возвращает наибольшее значение среди всех значений, полученных функцией selector, применённой к каждому элементу в коллекции, или null если элементов нет.
fun <T> Iterable<T>.maxOfOrNull( selector: (T) -> Double ): Double?
fun <T> Iterable<T>.maxOfOrNull( selector: (T) -> Float ): Float?
fun <T, R : Comparable<R>> Iterable<T>.maxOfOrNull( selector: (T) -> R ): R?
Возвращает наибольшее значение среди всех значений, полученных функцией selector, применённой к каждой паре в map, или null если пар нет.
fun <K, V> Map<out K, V>.maxOfOrNull( selector: (Entry<K, V>) -> Double ): Double?
fun <K, V> Map<out K, V>.maxOfOrNull( selector: (Entry<K, V>) -> Float ): Float?
fun <K, V, R : Comparable<R>> Map<out K, V>.maxOfOrNull( selector: (Entry<K, V>) -> R ): R?
maxOfWith
Возвращает наибольшее значение по предоставленному компаратору среди всех значений, полученных функцией выбора, применённой к каждому элементу в массиве.
fun <T, R> Array<out T>.maxOfWith( comparator: Comparator<in R>, selector: (T) -> R ): R
fun <R> ByteArray.maxOfWith( comparator: Comparator<in R>, selector: (Byte) -> R ): R
fun <R> ShortArray.maxOfWith( comparator: Comparator<in R>, selector: (Short) -> R ): R
fun <R> IntArray.maxOfWith( comparator: Comparator<in R>, selector: (Int) -> R ): R
fun <R> LongArray.maxOfWith( comparator: Comparator<in R>, selector: (Long) -> R ): R
fun <R> FloatArray.maxOfWith( comparator: Comparator<in R>, selector: (Float) -> R ): R
fun <R> DoubleArray.maxOfWith( comparator: Comparator<in R>, selector: (Double) -> R ): R
fun <R> BooleanArray.maxOfWith( comparator: Comparator<in R>, selector: (Boolean) -> R ): R
fun <R> CharArray.maxOfWith( comparator: Comparator<in R>, selector: (Char) -> R ): R
fun <R> UIntArray.maxOfWith( comparator: Comparator<in R>, selector: (UInt) -> R ): R
fun <R> ULongArray.maxOfWith( comparator: Comparator<in R>, selector: (ULong) -> R ): R
fun <R> UByteArray.maxOfWith( comparator: Comparator<in R>, selector: (UByte) -> R ): R
fun <R> UShortArray.maxOfWith( comparator: Comparator<in R>, selector: (UShort) -> R ): R
Возвращает наибольшее значение по предоставленному компаратору среди всех значений, полученных функцией выбора, применённой к каждому элементу в коллекции.
fun <T, R> Iterable<T>.maxOfWith( comparator: Comparator<in R>, selector: (T) -> R ): R
Возвращает наибольшее значение по предоставленному компаратору среди всех значений, полученных функцией выбора, применённой к каждой записи в карте.
fun <K, V, R> Map<out K, V>.maxOfWith( comparator: Comparator<in R>, selector: (Entry<K, V>) -> R ): R
maxOfWithOrNull
Возвращает наибольшее значение по предоставленному компаратору среди всех значений, полученных функцией выбора, применённой к каждому элементу в массиве или null если элементов нет.
fun <T, R> Array<out T>.maxOfWithOrNull( comparator: Comparator<in R>, selector: (T) -> R ): R?
fun <R> ByteArray.maxOfWithOrNull( comparator: Comparator<in R>, selector: (Byte) -> R ): R?
fun <R> ShortArray.maxOfWithOrNull( comparator: Comparator<in R>, selector: (Short) -> R ): R?
fun <R> IntArray.maxOfWithOrNull( comparator: Comparator<in R>, selector: (Int) -> R ): R?
fun <R> LongArray.maxOfWithOrNull( comparator: Comparator<in R>, selector: (Long) -> R ): R?
fun <R> FloatArray.maxOfWithOrNull( comparator: Comparator<in R>, selector: (Float) -> R ): R?
fun <R> DoubleArray.maxOfWithOrNull( comparator: Comparator<in R>, selector: (Double) -> R ): R?
fun <R> BooleanArray.maxOfWithOrNull( comparator: Comparator<in R>, selector: (Boolean) -> R ): R?
fun <R> CharArray.maxOfWithOrNull( comparator: Comparator<in R>, selector: (Char) -> R ): R?
fun <R> UIntArray.maxOfWithOrNull( comparator: Comparator<in R>, selector: (UInt) -> R ): R?
fun <R> ULongArray.maxOfWithOrNull( comparator: Comparator<in R>, selector: (ULong) -> R ): R?
fun <R> UByteArray.maxOfWithOrNull( comparator: Comparator<in R>, selector: (UByte) -> R ): R?
fun <R> UShortArray.maxOfWithOrNull( comparator: Comparator<in R>, selector: (UShort) -> R ): R?
Возвращает наибольшее значение по предоставленному компаратору среди всех значений, полученных функцией выбора, применённой к каждому элементу в коллекции или null если элементов нет.
fun <T, R> Iterable<T>.maxOfWithOrNull( comparator: Comparator<in R>, selector: (T) -> R ): R?
Возвращает наибольшее значение по предоставленному компаратору среди всех значений, полученных функцией выбора, применённой к каждой записи в карте или null если записей нет.
fun <K, V, R> Map<out K, V>.maxOfWithOrNull( comparator: Comparator<in R>, selector: (Entry<K, V>) -> R ): R?
maxOrNull
Возвращает наибольший элемент или null если элементов нет.
fun Array<out Double>.maxOrNull(): Double?
fun Array<out Float>.maxOrNull(): Float?
fun <T : Comparable<T>> Array<out T>.maxOrNull(): T?
fun ByteArray.maxOrNull(): Byte?
fun ShortArray.maxOrNull(): Short?
fun IntArray.maxOrNull(): Int?
fun LongArray.maxOrNull(): Long?
fun FloatArray.maxOrNull(): Float?
fun DoubleArray.maxOrNull(): Double?
fun CharArray.maxOrNull(): Char?
fun Iterable<Double>.maxOrNull(): Double?
fun Iterable<Float>.maxOrNull(): Float?
fun <T : Comparable<T>> Iterable<T>.maxOrNull(): T?
fun UIntArray.maxOrNull(): UInt?
fun ULongArray.maxOrNull(): ULong?
fun UByteArray.maxOrNull(): UByte?
fun UShortArray.maxOrNull(): UShort?
maxWith
Возвращает первый элемент с наибольшим значением согласно предоставленному компаратору.
fun <T> Array<out T>.maxWith(comparator: Comparator<in T>): T
fun ByteArray.maxWith(comparator: Comparator<in Byte>): Byte
fun ShortArray.maxWith( comparator: Comparator<in Short> ): Short
fun IntArray.maxWith(comparator: Comparator<in Int>): Int
fun LongArray.maxWith(comparator: Comparator<in Long>): Long
fun FloatArray.maxWith( comparator: Comparator<in Float> ): Float
fun DoubleArray.maxWith( comparator: Comparator<in Double> ): Double
fun BooleanArray.maxWith( comparator: Comparator<in Boolean> ): Boolean
fun CharArray.maxWith(comparator: Comparator<in Char>): Char
fun <T> Iterable<T>.maxWith(comparator: Comparator<in T>): T
fun UIntArray.maxWith(comparator: Comparator<in UInt>): UInt
fun ULongArray.maxWith( comparator: Comparator<in ULong> ): ULong
fun UByteArray.maxWith( comparator: Comparator<in UByte> ): UByte
fun UShortArray.maxWith( comparator: Comparator<in UShort> ): UShort
Возвращает первую запись с наибольшим значением согласно предоставленному компаратору.
fun <K, V> Map<out K, V>.maxWith( comparator: Comparator<in Entry<K, V>> ): Entry<K, V>
fun <T> Array<out T>.maxWith( comparator: Comparator<in T> ): T?
fun ByteArray.maxWith(comparator: Comparator<in Byte>): Byte?
fun ShortArray.maxWith( comparator: Comparator<in Short> ): Short?
fun IntArray.maxWith(comparator: Comparator<in Int>): Int?
fun LongArray.maxWith(comparator: Comparator<in Long>): Long?
fun FloatArray.maxWith( comparator: Comparator<in Float> ): Float?
fun DoubleArray.maxWith( comparator: Comparator<in Double> ): Double?
fun BooleanArray.maxWith( comparator: Comparator<in Boolean> ): Boolean?
fun CharArray.maxWith(comparator: Comparator<in Char>): Char?
fun <T> Iterable<T>.maxWith(comparator: Comparator<in T>): T?
fun <K, V> Map<out K, V>.maxWith( comparator: Comparator<in Entry<K, V>> ): Entry<K, V>?
fun UIntArray.maxWith(comparator: Comparator<in UInt>): UInt?
fun ULongArray.maxWith( comparator: Comparator<in ULong> ): ULong?
fun UByteArray.maxWith( comparator: Comparator<in UByte> ): UByte?
fun UShortArray.maxWith( comparator: Comparator<in UShort> ): UShort?
maxWithOrNull
Возвращает первый элемент с наибольшим значением согласно предоставленному компаратору или null если элементов нет.
fun <T> Array<out T>.maxWithOrNull( comparator: Comparator<in T> ): T?
fun ByteArray.maxWithOrNull( comparator: Comparator<in Byte> ): Byte?
fun ShortArray.maxWithOrNull( comparator: Comparator<in Short> ): Short?
fun IntArray.maxWithOrNull( comparator: Comparator<in Int> ): Int?
fun LongArray.maxWithOrNull( comparator: Comparator<in Long> ): Long?
fun FloatArray.maxWithOrNull( comparator: Comparator<in Float> ): Float?
fun DoubleArray.maxWithOrNull( comparator: Comparator<in Double> ): Double?
fun BooleanArray.maxWithOrNull( comparator: Comparator<in Boolean> ): Boolean?
fun CharArray.maxWithOrNull( comparator: Comparator<in Char> ): Char?
fun <T> Iterable<T>.maxWithOrNull( comparator: Comparator<in T> ): T?
fun UIntArray.maxWithOrNull( comparator: Comparator<in UInt> ): UInt?
fun ULongArray.maxWithOrNull( comparator: Comparator<in ULong> ): ULong?
fun UByteArray.maxWithOrNull( comparator: Comparator<in UByte> ): UByte?
fun UShortArray.maxWithOrNull( comparator: Comparator<in UShort> ): UShort?
Возвращает первую запись с наибольшим значением согласно предоставленному компаратору или null если записей нет.
fun <K, V> Map<out K, V>.maxWithOrNull( comparator: Comparator<in Entry<K, V>> ): Entry<K, V>?
min
Возвращает наименьший элемент.
fun Array<out Double>.min(): Double
fun Array<out Double>.min(): Double?
fun Array<out Float>.min(): Float
fun Array<out Float>.min(): Float?
fun <T : Comparable<T>> Array<out T>.min(): T
fun <T : Comparable<T>> Array<out T>.min(): T?
fun ByteArray.min(): Byte
fun ByteArray.min(): Byte?
fun ShortArray.min(): Short
fun ShortArray.min(): Short?
fun IntArray.min(): Int
fun IntArray.min(): Int?
fun LongArray.min(): Long
fun LongArray.min(): Long?
fun FloatArray.min(): Float
fun FloatArray.min(): Float?
fun DoubleArray.min(): Double
fun DoubleArray.min(): Double?
fun CharArray.min(): Char
fun CharArray.min(): Char?
fun Iterable<Double>.min(): Double
fun Iterable<Double>.min(): Double?
fun Iterable<Float>.min(): Float
fun Iterable<Float>.min(): Float?
fun <T : Comparable<T>> Iterable<T>.min(): T
fun <T : Comparable<T>> Iterable<T>.min(): T?
fun UIntArray.min(): UInt
fun UIntArray.min(): UInt?
fun ULongArray.min(): ULong
fun ULongArray.min(): ULong?
fun UByteArray.min(): UByte
fun UByteArray.min(): UByte?
fun UShortArray.min(): UShort
fun UShortArray.min(): UShort?
minBy
Возвращает первый элемент, дающий наименьшее значение заданной функции.
fun <T, R : Comparable<R>> Array<out T>.minBy( selector: (T) -> R ): T
fun <T, R : Comparable<R>> Array<out T>.minBy( selector: (T) -> R ): T?
fun <R : Comparable<R>> ByteArray.minBy( selector: (Byte) -> R ): Byte
fun <R : Comparable<R>> ByteArray.minBy( selector: (Byte) -> R ): Byte?
fun <R : Comparable<R>> ShortArray.minBy( selector: (Short) -> R ): Short
fun <R : Comparable<R>> ShortArray.minBy( selector: (Short) -> R ): Short?
fun <R : Comparable<R>> IntArray.minBy( selector: (Int) -> R ): Int
fun <R : Comparable<R>> IntArray.minBy( selector: (Int) -> R ): Int?
fun <R : Comparable<R>> LongArray.minBy( selector: (Long) -> R ): Long
fun <R : Comparable<R>> LongArray.minBy( selector: (Long) -> R ): Long?
fun <R : Comparable<R>> FloatArray.minBy( selector: (Float) -> R ): Float
fun <R : Comparable<R>> FloatArray.minBy( selector: (Float) -> R ): Float?
fun <R : Comparable<R>> DoubleArray.minBy( selector: (Double) -> R ): Double
fun <R : Comparable<R>> DoubleArray.minBy( selector: (Double) -> R ): Double?
fun <R : Comparable<R>> BooleanArray.minBy( selector: (Boolean) -> R ): Boolean
fun <R : Comparable<R>> BooleanArray.minBy( selector: (Boolean) -> R ): Boolean?
fun <R : Comparable<R>> CharArray.minBy( selector: (Char) -> R ): Char
fun <R : Comparable<R>> CharArray.minBy( selector: (Char) -> R ): Char?
fun <T, R : Comparable<R>> Iterable<T>.minBy( selector: (T) -> R ): T
fun <T, R : Comparable<R>> Iterable<T>.minBy( selector: (T) -> R ): T?
fun <R : Comparable<R>> UIntArray.minBy( selector: (UInt) -> R ): UInt
fun <R : Comparable<R>> UIntArray.minBy( selector: (UInt) -> R ): UInt?
fun <R : Comparable<R>> ULongArray.minBy( selector: (ULong) -> R ): ULong
fun <R : Comparable<R>> ULongArray.minBy( selector: (ULong) -> R ): ULong?
fun <R : Comparable<R>> UByteArray.minBy( selector: (UByte) -> R ): UByte
fun <R : Comparable<R>> UByteArray.minBy( selector: (UByte) -> R ): UByte?
fun <R : Comparable<R>> UShortArray.minBy( selector: (UShort) -> R ): UShort
fun <R : Comparable<R>> UShortArray.minBy( selector: (UShort) -> R ): UShort?
Возвращает первую запись, дающую наименьшее значение заданной функции.
fun <K, V, R : Comparable<R>> Map<out K, V>.minBy( selector: (Entry<K, V>) -> R ): Entry<K, V>
fun <K, V, R : Comparable<R>> Map<out K, V>.minBy( selector: (Entry<K, V>) -> R ): Entry<K, V>?
minByOrNull
Возвращает первый элемент, для которого заданная функция возвращает наименьшее значение, или null если элементов нет.
fun <T, R : Comparable<R>> Array<out T>.minByOrNull( selector: (T) -> R ): T?
fun <R : Comparable<R>> ByteArray.minByOrNull( selector: (Byte) -> R ): Byte?
fun <R : Comparable<R>> ShortArray.minByOrNull( selector: (Short) -> R ): Short?
fun <R : Comparable<R>> IntArray.minByOrNull( selector: (Int) -> R ): Int?
fun <R : Comparable<R>> LongArray.minByOrNull( selector: (Long) -> R ): Long?
fun <R : Comparable<R>> FloatArray.minByOrNull( selector: (Float) -> R ): Float?
fun <R : Comparable<R>> DoubleArray.minByOrNull( selector: (Double) -> R ): Double?
fun <R : Comparable<R>> BooleanArray.minByOrNull( selector: (Boolean) -> R ): Boolean?
fun <R : Comparable<R>> CharArray.minByOrNull( selector: (Char) -> R ): Char?
fun <T, R : Comparable<R>> Iterable<T>.minByOrNull( selector: (T) -> R ): T?
fun <R : Comparable<R>> UIntArray.minByOrNull( selector: (UInt) -> R ): UInt?
fun <R : Comparable<R>> ULongArray.minByOrNull( selector: (ULong) -> R ): ULong?
fun <R : Comparable<R>> UByteArray.minByOrNull( selector: (UByte) -> R ): UByte?
fun <R : Comparable<R>> UShortArray.minByOrNull( selector: (UShort) -> R ): UShort?
Возвращает первую пару, для которой заданная функция возвращает наименьшее значение, или null если пар нет.
fun <K, V, R : Comparable<R>> Map<out K, V>.minByOrNull( selector: (Entry<K, V>) -> R ): Entry<K, V>?
minOf
Возвращает наименьшее значение среди всех значений, полученных при применении функции selector к каждому элементу в массиве.
fun <T> Array<out T>.minOf(selector: (T) -> Double): Double
fun ByteArray.minOf(selector: (Byte) -> Double): Double
fun ShortArray.minOf(selector: (Short) -> Double): Double
fun IntArray.minOf(selector: (Int) -> Double): Double
fun LongArray.minOf(selector: (Long) -> Double): Double
fun FloatArray.minOf(selector: (Float) -> Double): Double
fun DoubleArray.minOf(selector: (Double) -> Double): Double
fun BooleanArray.minOf(selector: (Boolean) -> Double): Double
fun CharArray.minOf(selector: (Char) -> Double): Double
fun <T> Array<out T>.minOf(selector: (T) -> Float): Float
fun ByteArray.minOf(selector: (Byte) -> Float): Float
fun ShortArray.minOf(selector: (Short) -> Float): Float
fun IntArray.minOf(selector: (Int) -> Float): Float
fun LongArray.minOf(selector: (Long) -> Float): Float
fun FloatArray.minOf(selector: (Float) -> Float): Float
fun DoubleArray.minOf(selector: (Double) -> Float): Float
fun BooleanArray.minOf(selector: (Boolean) -> Float): Float
fun CharArray.minOf(selector: (Char) -> Float): Float
fun <T, R : Comparable<R>> Array<out T>.minOf( selector: (T) -> R ): R
fun <R : Comparable<R>> ByteArray.minOf( selector: (Byte) -> R ): R
fun <R : Comparable<R>> ShortArray.minOf( selector: (Short) -> R ): R
fun <R : Comparable<R>> IntArray.minOf( selector: (Int) -> R ): R
fun <R : Comparable<R>> LongArray.minOf( selector: (Long) -> R ): R
fun <R : Comparable<R>> FloatArray.minOf( selector: (Float) -> R ): R
fun <R : Comparable<R>> DoubleArray.minOf( selector: (Double) -> R ): R
fun <R : Comparable<R>> BooleanArray.minOf( selector: (Boolean) -> R ): R
fun <R : Comparable<R>> CharArray.minOf( selector: (Char) -> R ): R
fun UIntArray.minOf(selector: (UInt) -> Double): Double
fun ULongArray.minOf(selector: (ULong) -> Double): Double
fun UByteArray.minOf(selector: (UByte) -> Double): Double
fun UShortArray.minOf(selector: (UShort) -> Double): Double
fun UIntArray.minOf(selector: (UInt) -> Float): Float
fun ULongArray.minOf(selector: (ULong) -> Float): Float
fun UByteArray.minOf(selector: (UByte) -> Float): Float
fun UShortArray.minOf(selector: (UShort) -> Float): Float
fun <R : Comparable<R>> UIntArray.minOf( selector: (UInt) -> R ): R
fun <R : Comparable<R>> ULongArray.minOf( selector: (ULong) -> R ): R
fun <R : Comparable<R>> UByteArray.minOf( selector: (UByte) -> R ): R
fun <R : Comparable<R>> UShortArray.minOf( selector: (UShort) -> R ): R
Возвращает наименьшее значение среди всех значений, полученных при применении функции selector к каждому элементу в коллекции.
fun <T> Iterable<T>.minOf(selector: (T) -> Double): Double
fun <T> Iterable<T>.minOf(selector: (T) -> Float): Float
fun <T, R : Comparable<R>> Iterable<T>.minOf( selector: (T) -> R ): R
Возвращает наименьшее значение среди всех значений, полученных при применении функции selector к каждой паре в карте.
fun <K, V> Map<out K, V>.minOf( selector: (Entry<K, V>) -> Double ): Double
fun <K, V> Map<out K, V>.minOf( selector: (Entry<K, V>) -> Float ): Float
fun <K, V, R : Comparable<R>> Map<out K, V>.minOf( selector: (Entry<K, V>) -> R ): R
minOfOrNull
Возвращает наименьшее значение среди всех значений, полученных функцией selector, применённой к каждому элементу в массиве, или null , если элементов нет.
fun <T> Array<out T>.minOfOrNull( selector: (T) -> Double ): Double?
fun ByteArray.minOfOrNull( selector: (Byte) -> Double ): Double?
fun ShortArray.minOfOrNull( selector: (Short) -> Double ): Double?
fun IntArray.minOfOrNull(selector: (Int) -> Double): Double?
fun LongArray.minOfOrNull( selector: (Long) -> Double ): Double?
fun FloatArray.minOfOrNull( selector: (Float) -> Double ): Double?
fun DoubleArray.minOfOrNull( selector: (Double) -> Double ): Double?
fun BooleanArray.minOfOrNull( selector: (Boolean) -> Double ): Double?
fun CharArray.minOfOrNull( selector: (Char) -> Double ): Double?
fun <T> Array<out T>.minOfOrNull( selector: (T) -> Float ): Float?
fun ByteArray.minOfOrNull(selector: (Byte) -> Float): Float?
fun ShortArray.minOfOrNull( selector: (Short) -> Float ): Float?
fun IntArray.minOfOrNull(selector: (Int) -> Float): Float?
fun LongArray.minOfOrNull(selector: (Long) -> Float): Float?
fun FloatArray.minOfOrNull( selector: (Float) -> Float ): Float?
fun DoubleArray.minOfOrNull( selector: (Double) -> Float ): Float?
fun BooleanArray.minOfOrNull( selector: (Boolean) -> Float ): Float?
fun CharArray.minOfOrNull(selector: (Char) -> Float): Float?
fun <T, R : Comparable<R>> Array<out T>.minOfOrNull( selector: (T) -> R ): R?
fun <R : Comparable<R>> ByteArray.minOfOrNull( selector: (Byte) -> R ): R?
fun <R : Comparable<R>> ShortArray.minOfOrNull( selector: (Short) -> R ): R?
fun <R : Comparable<R>> IntArray.minOfOrNull( selector: (Int) -> R ): R?
fun <R : Comparable<R>> LongArray.minOfOrNull( selector: (Long) -> R ): R?
fun <R : Comparable<R>> FloatArray.minOfOrNull( selector: (Float) -> R ): R?
fun <R : Comparable<R>> DoubleArray.minOfOrNull( selector: (Double) -> R ): R?
fun <R : Comparable<R>> BooleanArray.minOfOrNull( selector: (Boolean) -> R ): R?
fun <R : Comparable<R>> CharArray.minOfOrNull( selector: (Char) -> R ): R?
fun UIntArray.minOfOrNull( selector: (UInt) -> Double ): Double?
fun ULongArray.minOfOrNull( selector: (ULong) -> Double ): Double?
fun UByteArray.minOfOrNull( selector: (UByte) -> Double ): Double?
fun UShortArray.minOfOrNull( selector: (UShort) -> Double ): Double?
fun UIntArray.minOfOrNull(selector: (UInt) -> Float): Float?
fun ULongArray.minOfOrNull( selector: (ULong) -> Float ): Float?
fun UByteArray.minOfOrNull( selector: (UByte) -> Float ): Float?
fun UShortArray.minOfOrNull( selector: (UShort) -> Float ): Float?
fun <R : Comparable<R>> UIntArray.minOfOrNull( selector: (UInt) -> R ): R?
fun <R : Comparable<R>> ULongArray.minOfOrNull( selector: (ULong) -> R ): R?
fun <R : Comparable<R>> UByteArray.minOfOrNull( selector: (UByte) -> R ): R?
fun <R : Comparable<R>> UShortArray.minOfOrNull( selector: (UShort) -> R ): R?
Возвращает наименьшее значение среди всех значений, полученных функцией selector, применённой к каждому элементу в коллекции, или null , если элементов нет.
fun <T> Iterable<T>.minOfOrNull( selector: (T) -> Double ): Double?
fun <T> Iterable<T>.minOfOrNull( selector: (T) -> Float ): Float?
fun <T, R : Comparable<R>> Iterable<T>.minOfOrNull( selector: (T) -> R ): R?
Возвращает наименьшее значение среди всех значений, полученных функцией selector, применённой к каждой записи в карте, или null , если записей нет.
fun <K, V> Map<out K, V>.minOfOrNull( selector: (Entry<K, V>) -> Double ): Double?
fun <K, V> Map<out K, V>.minOfOrNull( selector: (Entry<K, V>) -> Float ): Float?
fun <K, V, R : Comparable<R>> Map<out K, V>.minOfOrNull( selector: (Entry<K, V>) -> R ): R?
minOfWith
Возвращает наименьшее значение по предоставленному компаратору среди всех значений, полученных функцией selector, применённой к каждому элементу в массиве.
fun <T, R> Array<out T>.minOfWith( comparator: Comparator<in R>, selector: (T) -> R ): R
fun <R> ByteArray.minOfWith( comparator: Comparator<in R>, selector: (Byte) -> R ): R
fun <R> ShortArray.minOfWith( comparator: Comparator<in R>, selector: (Short) -> R ): R
fun <R> IntArray.minOfWith( comparator: Comparator<in R>, selector: (Int) -> R ): R
fun <R> LongArray.minOfWith( comparator: Comparator<in R>, selector: (Long) -> R ): R
fun <R> FloatArray.minOfWith( comparator: Comparator<in R>, selector: (Float) -> R ): R
fun <R> DoubleArray.minOfWith( comparator: Comparator<in R>, selector: (Double) -> R ): R
fun <R> BooleanArray.minOfWith( comparator: Comparator<in R>, selector: (Boolean) -> R ): R
fun <R> CharArray.minOfWith( comparator: Comparator<in R>, selector: (Char) -> R ): R
fun <R> UIntArray.minOfWith( comparator: Comparator<in R>, selector: (UInt) -> R ): R
fun <R> ULongArray.minOfWith( comparator: Comparator<in R>, selector: (ULong) -> R ): R
fun <R> UByteArray.minOfWith( comparator: Comparator<in R>, selector: (UByte) -> R ): R
fun <R> UShortArray.minOfWith( comparator: Comparator<in R>, selector: (UShort) -> R ): R
Возвращает наименьшее значение по предоставленному компаратору среди всех значений, полученных функцией selector, применённой к каждому элементу в коллекции.
fun <T, R> Iterable<T>.minOfWith( comparator: Comparator<in R>, selector: (T) -> R ): R
Возвращает наименьшее значение по предоставленному компаратору среди всех значений, полученных функцией selector, применённой к каждой записи в map.
fun <K, V, R> Map<out K, V>.minOfWith( comparator: Comparator<in R>, selector: (Entry<K, V>) -> R ): R
minOfWithOrNull
Возвращает наименьшее значение по предоставленному компаратору среди всех значений, полученных функцией selector, применённой к каждому элементу в массиве, или null если элементов нет.
fun <T, R> Array<out T>.minOfWithOrNull( comparator: Comparator<in R>, selector: (T) -> R ): R?
fun <R> ByteArray.minOfWithOrNull( comparator: Comparator<in R>, selector: (Byte) -> R ): R?
fun <R> ShortArray.minOfWithOrNull( comparator: Comparator<in R>, selector: (Short) -> R ): R?
fun <R> IntArray.minOfWithOrNull( comparator: Comparator<in R>, selector: (Int) -> R ): R?
fun <R> LongArray.minOfWithOrNull( comparator: Comparator<in R>, selector: (Long) -> R ): R?
fun <R> FloatArray.minOfWithOrNull( comparator: Comparator<in R>, selector: (Float) -> R ): R?
fun <R> DoubleArray.minOfWithOrNull( comparator: Comparator<in R>, selector: (Double) -> R ): R?
fun <R> BooleanArray.minOfWithOrNull( comparator: Comparator<in R>, selector: (Boolean) -> R ): R?
fun <R> CharArray.minOfWithOrNull( comparator: Comparator<in R>, selector: (Char) -> R ): R?
fun <R> UIntArray.minOfWithOrNull( comparator: Comparator<in R>, selector: (UInt) -> R ): R?
fun <R> ULongArray.minOfWithOrNull( comparator: Comparator<in R>, selector: (ULong) -> R ): R?
fun <R> UByteArray.minOfWithOrNull( comparator: Comparator<in R>, selector: (UByte) -> R ): R?
fun <R> UShortArray.minOfWithOrNull( comparator: Comparator<in R>, selector: (UShort) -> R ): R?
Возвращает наименьшее значение по предоставленному компаратору среди всех значений, полученных функцией selector, применённой к каждому элементу в коллекции, или null если элементов нет.
fun <T, R> Iterable<T>.minOfWithOrNull( comparator: Comparator<in R>, selector: (T) -> R ): R?
Возвращает наименьшее значение по предоставленному компаратору среди всех значений, полученных функцией selector, применённой к каждой записи в map, или null если записей нет.
fun <K, V, R> Map<out K, V>.minOfWithOrNull( comparator: Comparator<in R>, selector: (Entry<K, V>) -> R ): R?
minOrNull
Возвращает наименьший элемент или null если элементов нет.
fun Array<out Double>.minOrNull(): Double?
fun Array<out Float>.minOrNull(): Float?
fun <T : Comparable<T>> Array<out T>.minOrNull(): T?
fun ByteArray.minOrNull(): Byte?
fun ShortArray.minOrNull(): Short?
fun IntArray.minOrNull(): Int?
fun LongArray.minOrNull(): Long?
fun FloatArray.minOrNull(): Float?
fun DoubleArray.minOrNull(): Double?
fun CharArray.minOrNull(): Char?
fun Iterable<Double>.minOrNull(): Double?
fun Iterable<Float>.minOrNull(): Float?
fun <T : Comparable<T>> Iterable<T>.minOrNull(): T?
fun UIntArray.minOrNull(): UInt?
fun ULongArray.minOrNull(): ULong?
fun UByteArray.minOrNull(): UByte?
fun UShortArray.minOrNull(): UShort?
minus
Возвращает список, содержащий все элементы исходного набора без первого вхождения заданного элемента.
operator fun <T> Iterable<T>.minus(element: T): List<T>
Возвращает список, содержащий все элементы исходного набора, за исключением элементов, содержащихся в заданном массиве элементов.
operator fun <T> Iterable<T>.minus( elements: Array<out T> ): List<T>
Возвращает список, содержащий все элементы исходного набора, за исключением элементов, содержащихся в заданной коллекции элементов.
operator fun <T> Iterable<T>.minus( elements: Iterable<T> ): List<T>
Возвращает список, содержащий все элементы исходного набора, за исключением элементов, содержащихся в заданной последовательности элементов.
operator fun <T> Iterable<T>.minus( elements: Sequence<T> ): List<T>
Возвращает множество, содержащее все элементы исходного множества, за исключением данного элемента.
operator fun <T> Set<T>.minus(element: T): Set<T>
Возвращает множество, содержащее все элементы исходного множества, за исключением элементов, содержащихся в заданном массиве элементов.
operator fun <T> Set<T>.minus(elements: Array<out T>): Set<T>
Возвращает множество, содержащее все элементы исходного множества, за исключением элементов, содержащихся в заданной коллекции элементов.
operator fun <T> Set<T>.minus(elements: Iterable<T>): Set<T>
Возвращает множество, содержащее все элементы исходного множества, за исключением элементов, содержащихся в заданной последовательности элементов.
operator fun <T> Set<T>.minus(elements: Sequence<T>): Set<T>
Возвращает карту, содержащую все пары исходной карты, за исключением пары с заданным ключом.
operator fun <K, V> Map<out K, V>.minus(key: K): Map<K, V>
Возвращает карту, содержащую все пары исходной карты, за исключением пар, ключи которых содержатся в заданной коллекции ключей.
operator fun <K, V> Map<out K, V>.minus( keys: Iterable<K> ): Map<K, V>
Возвращает карту, содержащую все пары исходной карты, за исключением пар, ключи которых содержатся в заданном массиве ключей.
operator fun <K, V> Map<out K, V>.minus( keys: Array<out K> ): Map<K, V>
Возвращает карту, содержащую все пары исходной карты, за исключением пар, ключи которых содержатся в заданной последовательности ключей.
operator fun <K, V> Map<out K, V>.minus( keys: Sequence<K> ): Map<K, V>
minusAssign
Удаляет запись с заданным ключом из этой изменяемой карты.
operator fun <K, V> MutableMap<K, V>.minusAssign(key: K)
Удаляет все записи, ключи которых содержатся в заданном наборе ключей из этой изменяемой карты.
operator fun <K, V> MutableMap<K, V>.minusAssign( keys: Iterable<K>)
Удаляет все записи, ключи которых содержатся в заданном массиве ключей из этой изменяемой карты.
operator fun <K, V> MutableMap<K, V>.minusAssign( keys: Array<out K>)
Удаляет все записи, ключи которых содержатся в заданной последовательности ключей из этой изменяемой карты.
operator fun <K, V> MutableMap<K, V>.minusAssign( keys: Sequence<K>)
Удаляет единственный экземпляр указанного элемента из этой изменяемой коллекции.
operator fun <T> MutableCollection<in T>.minusAssign( element: T)
Удаляет все элементы, содержащиеся в заданной коллекции элементов из этой изменяемой коллекции.
operator fun <T> MutableCollection<in T>.minusAssign( elements: Iterable<T>)
Удаляет все элементы, содержащиеся в заданном массиве элементов из этой изменяемой коллекции.
operator fun <T> MutableCollection<in T>.minusAssign( elements: Array<T>)
Удаляет все элементы, содержащиеся в заданной последовательности элементов из этой изменяемой коллекции.
operator fun <T> MutableCollection<in T>.minusAssign( elements: Sequence<T>)
minusElement
Возвращает список, содержащий все элементы исходной коллекции без первого вхождения заданного элемента.
fun <T> Iterable<T>.minusElement(element: T): List<T>
Возвращает множество, содержащее все элементы исходного множества, за исключением данного элемента.
fun <T> Set<T>.minusElement(element: T): Set<T>
minWith
Возвращает первый элемент с наименьшим значением в соответствии с предоставленным компаратором.
fun <T> Array<out T>.minWith(comparator: Comparator<in T>): T
fun ByteArray.minWith(comparator: Comparator<in Byte>): Byte
fun ShortArray.minWith( comparator: Comparator<in Short> ): Short
fun IntArray.minWith(comparator: Comparator<in Int>): Int
fun LongArray.minWith(comparator: Comparator<in Long>): Long
fun FloatArray.minWith( comparator: Comparator<in Float> ): Float
fun DoubleArray.minWith( comparator: Comparator<in Double> ): Double
fun BooleanArray.minWith( comparator: Comparator<in Boolean> ): Boolean
fun CharArray.minWith(comparator: Comparator<in Char>): Char
fun <T> Iterable<T>.minWith(comparator: Comparator<in T>): T
fun UIntArray.minWith(comparator: Comparator<in UInt>): UInt
fun ULongArray.minWith( comparator: Comparator<in ULong> ): ULong
fun UByteArray.minWith( comparator: Comparator<in UByte> ): UByte
fun UShortArray.minWith( comparator: Comparator<in UShort> ): UShort
Возвращает первую запись с наименьшим значением в соответствии с предоставленным компаратором.
fun <K, V> Map<out K, V>.minWith( comparator: Comparator<in Entry<K, V>> ): Entry<K, V>
fun <T> Array<out T>.minWith( comparator: Comparator<in T> ): T?
fun ByteArray.minWith(comparator: Comparator<in Byte>): Byte?
fun ShortArray.minWith( comparator: Comparator<in Short> ): Short?
fun IntArray.minWith(comparator: Comparator<in Int>): Int?
fun LongArray.minWith(comparator: Comparator<in Long>): Long?
fun FloatArray.minWith( comparator: Comparator<in Float> ): Float?
fun DoubleArray.minWith( comparator: Comparator<in Double> ): Double?
fun BooleanArray.minWith( comparator: Comparator<in Boolean> ): Boolean?
fun CharArray.minWith(comparator: Comparator<in Char>): Char?
fun <T> Iterable<T>.minWith(comparator: Comparator<in T>): T?
fun <K, V> Map<out K, V>.minWith( comparator: Comparator<in Entry<K, V>> ): Entry<K, V>?
fun UIntArray.minWith(comparator: Comparator<in UInt>): UInt?
fun ULongArray.minWith( comparator: Comparator<in ULong> ): ULong?
fun UByteArray.minWith( comparator: Comparator<in UByte> ): UByte?
fun UShortArray.minWith( comparator: Comparator<in UShort> ): UShort?
minWithOrNull
Возвращает первый элемент с наименьшим значением в соответствии с предоставленным компаратором или null если элементов нет.
fun <T> Array<out T>.minWithOrNull( comparator: Comparator<in T> ): T?
fun ByteArray.minWithOrNull( comparator: Comparator<in Byte> ): Byte?
fun ShortArray.minWithOrNull( comparator: Comparator<in Short> ): Short?
fun IntArray.minWithOrNull( comparator: Comparator<in Int> ): Int?
fun LongArray.minWithOrNull( comparator: Comparator<in Long> ): Long?
fun FloatArray.minWithOrNull( comparator: Comparator<in Float> ): Float?
fun DoubleArray.minWithOrNull( comparator: Comparator<in Double> ): Double?
fun BooleanArray.minWithOrNull( comparator: Comparator<in Boolean> ): Boolean?
fun CharArray.minWithOrNull( comparator: Comparator<in Char> ): Char?
fun <T> Iterable<T>.minWithOrNull( comparator: Comparator<in T> ): T?
fun UIntArray.minWithOrNull( comparator: Comparator<in UInt> ): UInt?
fun ULongArray.minWithOrNull( comparator: Comparator<in ULong> ): ULong?
fun UByteArray.minWithOrNull( comparator: Comparator<in UByte> ): UByte?
fun UShortArray.minWithOrNull( comparator: Comparator<in UShort> ): UShort?
Возвращает первую запись с наименьшим значением в соответствии с предоставленным компаратором или null если записей нет.
fun <K, V> Map<out K, V>.minWithOrNull( comparator: Comparator<in Entry<K, V>> ): Entry<K, V>?
MutableList
mutableListOf
Возвращает пустой новый MutableList.
fun <T> mutableListOf(): MutableList<T>
Возвращает новый MutableList с заданными элементами.
fun <T> mutableListOf(vararg elements: T): MutableList<T>
mutableMapOf
Возвращает пустой новый MutableMap.
fun <K, V> mutableMapOf(): MutableMap<K, V>
Возвращает новый MutableMap с указанным содержимым, представленным списком пар, где первый компонент — ключ, а второй — значение.
fun <K, V> mutableMapOf( vararg pairs: Pair<K, V> ): MutableMap<K, V>
mutableSetOf
Возвращает пустой новый MutableSet.
fun <T> mutableSetOf(): MutableSet<T>
Возвращает новый MutableSet с заданными элементами. Элементы множества итерируются в порядке их указания.
fun <T> mutableSetOf(vararg elements: T): MutableSet<T>
none
Возвращает true если массив не содержит элементов.
fun <T> Array<out T>.none(): Boolean
fun ByteArray.none(): Boolean
fun ShortArray.none(): Boolean
fun IntArray.none(): Boolean
fun LongArray.none(): Boolean
fun FloatArray.none(): Boolean
fun DoubleArray.none(): Boolean
fun BooleanArray.none(): Boolean
fun CharArray.none(): Boolean
fun UIntArray.none(): Boolean
fun ULongArray.none(): Boolean
fun UByteArray.none(): Boolean
fun UShortArray.none(): Boolean
Возвращает true если ни один элемент не соответствует заданному предикату.
fun <T> Array<out T>.none(predicate: (T) -> Boolean): Boolean
fun ByteArray.none(predicate: (Byte) -> Boolean): Boolean
fun ShortArray.none(predicate: (Short) -> Boolean): Boolean
fun IntArray.none(predicate: (Int) -> Boolean): Boolean
fun LongArray.none(predicate: (Long) -> Boolean): Boolean
fun FloatArray.none(predicate: (Float) -> Boolean): Boolean
fun DoubleArray.none(predicate: (Double) -> Boolean): Boolean
fun BooleanArray.none( predicate: (Boolean) -> Boolean ): Boolean
fun CharArray.none(predicate: (Char) -> Boolean): Boolean
fun <T> Iterable<T>.none(predicate: (T) -> Boolean): Boolean
fun UIntArray.none(predicate: (UInt) -> Boolean): Boolean
fun ULongArray.none(predicate: (ULong) -> Boolean): Boolean
fun UByteArray.none(predicate: (UByte) -> Boolean): Boolean
fun UShortArray.none(predicate: (UShort) -> Boolean): Boolean
Возвращает true если коллекция не содержит элементов.
fun <T> Iterable<T>.none(): Boolean
Возвращает true если карта не содержит записей.
fun <K, V> Map<out K, V>.none(): Boolean
Возвращает true если ни одна запись не соответствует заданному предикату.
fun <K, V> Map<out K, V>.none( predicate: (Entry<K, V>) -> Boolean ): Boolean
onEach
Выполняет заданное действие над каждым элементом и возвращает сам массив после выполнения.
fun <T> Array<out T>.onEach( action: (T) -> Unit ): Array<out T>
fun ByteArray.onEach(action: (Byte) -> Unit): ByteArray
fun ShortArray.onEach(action: (Short) -> Unit): ShortArray
fun IntArray.onEach(action: (Int) -> Unit): IntArray
fun LongArray.onEach(action: (Long) -> Unit): LongArray
fun FloatArray.onEach(action: (Float) -> Unit): FloatArray
fun DoubleArray.onEach(action: (Double) -> Unit): DoubleArray
fun BooleanArray.onEach( action: (Boolean) -> Unit ): BooleanArray
fun CharArray.onEach(action: (Char) -> Unit): CharArray
fun UIntArray.onEach(action: (UInt) -> Unit): UIntArray
fun ULongArray.onEach(action: (ULong) -> Unit): ULongArray
fun UByteArray.onEach(action: (UByte) -> Unit): UByteArray
fun UShortArray.onEach(action: (UShort) -> Unit): UShortArray
Выполняет заданное действие над каждым элементом и возвращает саму коллекцию после выполнения.
fun <T, C : Iterable<T>> C.onEach(action: (T) -> Unit): C
Выполняет заданное действие над каждой записью и возвращает саму карту после выполнения.
fun <K, V, M : Map<out K, V>> M.onEach( action: (Entry<K, V>) -> Unit ): M
onEachIndexed
Применяет заданное действие к каждому элементу, предоставляя последовательный индекс с элементом, и возвращает массив после этого.
fun <T> Array<out T>.onEachIndexed( action: (index: Int, T) -> Unit ): Array<out T>
fun ByteArray.onEachIndexed( action: (index: Int, Byte) -> Unit ): ByteArray
fun ShortArray.onEachIndexed( action: (index: Int, Short) -> Unit ): ShortArray
fun IntArray.onEachIndexed( action: (index: Int, Int) -> Unit ): IntArray
fun LongArray.onEachIndexed( action: (index: Int, Long) -> Unit ): LongArray
fun FloatArray.onEachIndexed( action: (index: Int, Float) -> Unit ): FloatArray
fun DoubleArray.onEachIndexed( action: (index: Int, Double) -> Unit ): DoubleArray
fun BooleanArray.onEachIndexed( action: (index: Int, Boolean) -> Unit ): BooleanArray
fun CharArray.onEachIndexed( action: (index: Int, Char) -> Unit ): CharArray
fun UIntArray.onEachIndexed( action: (index: Int, UInt) -> Unit ): UIntArray
fun ULongArray.onEachIndexed( action: (index: Int, ULong) -> Unit ): ULongArray
fun UByteArray.onEachIndexed( action: (index: Int, UByte) -> Unit ): UByteArray
fun UShortArray.onEachIndexed( action: (index: Int, UShort) -> Unit ): UShortArray
Применяет заданное действие к каждому элементу, предоставляя последовательный индекс с элементом, и возвращает коллекцию после этого.
fun <T, C : Iterable<T>> C.onEachIndexed( action: (index: Int, T) -> Unit ): C
Применяет заданное действие к каждой записи, предоставляя последовательный индекс с записью, и возвращает карту после этого.
fun <K, V, M : Map<out K, V>> M.onEachIndexed( action: (index: Int, Entry<K, V>) -> Unit ): M
orEmpty
Возвращает эту коллекцию, если она не null, и пустой список в противном случае.
fun <T> Collection<T>?.orEmpty(): Collection<T>
Возвращает этот список, если он не null, и пустой список в противном случае.
fun <T> List<T>?.orEmpty(): List<T>
Возвращает карту, если она не null, или пустую карту в противном случае.
fun <K, V> Map<K, V>?.orEmpty(): Map<K, V>
Возвращает это множество, если оно не null, и пустое множество в противном случае.
fun <T> Set<T>?.orEmpty(): Set<T>
Возвращает массив, если он не null, или пустой массив в противном случае.
fun <T> any_array<T>.orEmpty(): Array<out T>
partition
плюс
Возвращает список, содержащий все элементы исходной коллекции, а затем заданный элемент.
operator fun <T> Iterable<T>.plus(element: T): List<T>
operator fun <T> Collection<T>.plus(element: T): List<T>
Возвращает список, содержащий все элементы исходной коллекции, а затем все элементы заданного массива элементов.
operator fun <T> Iterable<T>.plus( elements: Array<out T> ): List<T>
operator fun <T> Collection<T>.plus( elements: Array<out T> ): List<T>
Возвращает список, содержащий все элементы исходной коллекции, а затем все элементы заданной коллекции элементов.
operator fun <T> Iterable<T>.plus( elements: Iterable<T> ): List<T>
operator fun <T> Collection<T>.plus( elements: Iterable<T> ): List<T>
Возвращает список, содержащий все элементы исходной коллекции, а затем все элементы заданной последовательности элементов.
operator fun <T> Iterable<T>.plus( elements: Sequence<T> ): List<T>
operator fun <T> Collection<T>.plus( elements: Sequence<T> ): List<T>
Возвращает множество, содержащее все элементы исходного множества, а затем заданный элемент, если он еще не содержится в этом множестве.
operator fun <T> Set<T>.plus(element: T): Set<T>
Возвращает множество, содержащее все элементы исходного множества и заданный массив элементов, которые еще не содержатся в этом множестве.
operator fun <T> Set<T>.plus(elements: Array<out T>): Set<T>
Возвращает множество, содержащее все элементы исходного множества и заданную коллекцию элементов, которые еще не содержатся в этом множестве. Возвращаемое множество сохраняет порядок итерации элементов исходного множества.
operator fun <T> Set<T>.plus(elements: Iterable<T>): Set<T>
Возвращает множество, содержащее все элементы исходного множества и заданную последовательность элементов, которые еще не содержатся в этом множестве.
operator fun <T> Set<T>.plus(elements: Sequence<T>): Set<T>
Возвращает массив, содержащий все элементы исходного массива, а затем заданный элемент.
operator fun UIntArray.plus(element: UInt): UIntArray
operator fun ULongArray.plus(element: ULong): ULongArray
operator fun UByteArray.plus(element: UByte): UByteArray
operator fun UShortArray.plus(element: UShort): UShortArray
operator fun <T> Array<T>.plus(element: T): Array<T>
operator fun <T> Array<out T>.plus(element: T): Array<T>
operator fun ByteArray.plus(element: Byte): ByteArray
operator fun ShortArray.plus(element: Short): ShortArray
operator fun IntArray.plus(element: Int): IntArray
operator fun LongArray.plus(element: Long): LongArray
operator fun FloatArray.plus(element: Float): FloatArray
operator fun DoubleArray.plus(element: Double): DoubleArray
operator fun BooleanArray.plus( element: Boolean ): BooleanArray
operator fun CharArray.plus(element: Char): CharArray
Возвращает массив, содержащий все элементы исходного массива, а затем все элементы заданной коллекции элементов.
operator fun UIntArray.plus( elements: Collection<UInt> ): UIntArray
operator fun ULongArray.plus( elements: Collection<ULong> ): ULongArray
operator fun UByteArray.plus( elements: Collection<UByte> ): UByteArray
operator fun UShortArray.plus( elements: Collection<UShort> ): UShortArray
operator fun <T> Array<T>.plus( elements: Collection<T> ): Array<T>
operator fun <T> Array<out T>.plus( elements: Collection<T> ): Array<T>
operator fun ByteArray.plus( elements: Collection<Byte> ): ByteArray
operator fun ShortArray.plus( elements: Collection<Short> ): ShortArray
operator fun IntArray.plus( elements: Collection<Int> ): IntArray
operator fun LongArray.plus( elements: Collection<Long> ): LongArray
operator fun FloatArray.plus( elements: Collection<Float> ): FloatArray
operator fun DoubleArray.plus( elements: Collection<Double> ): DoubleArray
operator fun BooleanArray.plus( elements: Collection<Boolean> ): BooleanArray
operator fun CharArray.plus( elements: Collection<Char> ): CharArray
Возвращает массив, содержащий все элементы исходного массива, а затем все элементы массива elements.
operator fun UIntArray.plus(elements: UIntArray): UIntArray
operator fun ULongArray.plus( elements: ULongArray ): ULongArray
operator fun UByteArray.plus( elements: UByteArray ): UByteArray
operator fun UShortArray.plus( elements: UShortArray ): UShortArray
operator fun <T> Array<T>.plus( elements: Array<out T> ): Array<T>
operator fun <T> Array<out T>.plus( elements: Array<out T> ): Array<T>
operator fun ByteArray.plus(elements: ByteArray): ByteArray
operator fun ShortArray.plus( elements: ShortArray ): ShortArray
operator fun IntArray.plus(elements: IntArray): IntArray
operator fun LongArray.plus(elements: LongArray): LongArray
operator fun FloatArray.plus( elements: FloatArray ): FloatArray
operator fun DoubleArray.plus( elements: DoubleArray ): DoubleArray
operator fun BooleanArray.plus( elements: BooleanArray ): BooleanArray
operator fun CharArray.plus(elements: CharArray): CharArray
Создает новую неизменяемую карту, заменяя или добавляя запись в эту карту из заданной пары ключ-значение pair.
operator fun <K, V> Map<out K, V>.plus( pair: Pair<K, V> ): Map<K, V>
Создает новую неизменяемую карту, заменяя или добавляя записи в эту карту из заданного набора пар ключ-значение pairs.
operator fun <K, V> Map<out K, V>.plus( pairs: Iterable<Pair<K, V>> ): Map<K, V>
Создает новую неизменяемую карту, заменяя или добавляя записи в эту карту из заданного массива пар ключ-значение pairs.
operator fun <K, V> Map<out K, V>.plus( pairs: Array<out Pair<K, V>> ): Map<K, V>
Создает новую неизменяемую карту, заменяя или добавляя записи в эту карту из заданной последовательности пар ключ-значение pairs.
operator fun <K, V> Map<out K, V>.plus( pairs: Sequence<Pair<K, V>> ): Map<K, V>
Создает новую неизменяемую карту, заменяя или добавляя записи в эту карту из другой карты.
operator fun <K, V> Map<out K, V>.plus( map: Map<out K, V> ): Map<K, V>
plusAssign
Добавляет или заменяет заданную пару pair в этой изменяемой карте.
operator fun <K, V> MutableMap<in K, in V>.plusAssign( pair: Pair<K, V>)
Добавляет или заменяет все пары из заданного набора pairs в этой изменяемой карте.
operator fun <K, V> MutableMap<in K, in V>.plusAssign( pairs: Iterable<Pair<K, V>>)
Добавляет или заменяет все пары из заданного массива pairs в этой изменяемой карте.
operator fun <K, V> MutableMap<in K, in V>.plusAssign( pairs: Array<out Pair<K, V>>)
Добавляет или заменяет все пары из заданной последовательности pairs в этой изменяемой карте.
operator fun <K, V> MutableMap<in K, in V>.plusAssign( pairs: Sequence<Pair<K, V>>)
Добавляет указанный элемент в это изменяемое множество.
operator fun <T> MutableCollection<in T>.plusAssign( element: T)
Добавляет все элементы заданного набора elements в это изменяемое множество.
operator fun <T> MutableCollection<in T>.plusAssign( elements: Iterable<T>)
Добавляет все элементы заданного массива elements в это изменяемое множество.
operator fun <T> MutableCollection<in T>.plusAssign( elements: Array<T>)
Добавляет все элементы заданной последовательности elements в это изменяемое множество.
operator fun <T> MutableCollection<in T>.plusAssign( elements: Sequence<T>)
plusElement
Возвращает список, содержащий все элементы исходного набора, а затем заданный элемент.
fun <T> Iterable<T>.plusElement(element: T): List<T>
fun <T> Collection<T>.plusElement(element: T): List<T>
Возвращает множество, содержащее все элементы исходного множества, а затем заданный элемент, если он ещё не содержится в этом множестве.
fun <T> Set<T>.plusElement(element: T): Set<T>
Возвращает массив, содержащий все элементы исходного массива, а затем заданный элемент.
fun <T> any_array<T>.plusElement(element: T): Array<T>
putAll
Добавляет все заданные пар в эту MutableMap, где первый компонент пары — ключ, а второй — значение.
fun <K, V> MutableMap<in K, in V>.putAll( pairs: Array<out Pair<K, V>>)
Добавляет все элементы заданного набора в эту MutableMap, где первый компонент пары — ключ, а второй — значение.
fun <K, V> MutableMap<in K, in V>.putAll( pairs: Iterable<Pair<K, V>>)
Добавляет все элементы заданной последовательности в эту MutableMap, где первый компонент пары — ключ, а второй — значение.
fun <K, V> MutableMap<in K, in V>.putAll( pairs: Sequence<Pair<K, V>>)
random
Возвращает случайный элемент из этого массива.
fun <T> Array<out T>.random(): T
fun ByteArray.random(): Byte
fun ShortArray.random(): Short
fun IntArray.random(): Int
fun LongArray.random(): Long
fun FloatArray.random(): Float
fun DoubleArray.random(): Double
fun BooleanArray.random(): Boolean
fun CharArray.random(): Char
fun UIntArray.random(): UInt
fun ULongArray.random(): ULong
fun UByteArray.random(): UByte
fun UShortArray.random(): UShort
Возвращает случайный элемент из этого массива с использованием указанного источника случайности.
fun <T> Array<out T>.random(random: Random): T
fun ByteArray.random(random: Random): Byte
fun ShortArray.random(random: Random): Short
fun IntArray.random(random: Random): Int
fun LongArray.random(random: Random): Long
fun FloatArray.random(random: Random): Float
fun DoubleArray.random(random: Random): Double
fun BooleanArray.random(random: Random): Boolean
fun CharArray.random(random: Random): Char
fun UIntArray.random(random: Random): UInt
Возвращает случайный элемент из этого набора.
fun ULongArray.random(random: Random): ULong
Возвращает случайный элемент из этого набора с использованием указанного источника случайности.
fun UByteArray.random(random: Random): UByte
Возвращает случайный элемент из этого набора с использованием указанного источника случайности.
fun UShortArray.random(random: Random): UShort
Возвращает случайный элемент из этой коллекции.
fun <T> Collection<T>.random(): T
Возвращает случайный элемент из этой коллекции с использованием указанного источника случайности.
fun <T> Collection<T>.random(random: Random): T
randomOrNull
Возвращает случайный элемент из этого массива или null, если этот массив пустой.
fun <T> Array<out T>.randomOrNull(): T?
fun ByteArray.randomOrNull(): Byte?
fun ShortArray.randomOrNull(): Short?
fun IntArray.randomOrNull(): Int?
fun LongArray.randomOrNull(): Long?
fun FloatArray.randomOrNull(): Float?
fun DoubleArray.randomOrNull(): Double?
fun BooleanArray.randomOrNull(): Boolean?
fun CharArray.randomOrNull(): Char?
fun UIntArray.randomOrNull(): UInt?
fun ULongArray.randomOrNull(): ULong?
fun UByteArray.randomOrNull(): UByte?
fun UShortArray.randomOrNull(): UShort?
Возвращает случайный элемент из этого массива, используя указанный источник случайности, или null, если этот массив пустой.
fun <T> Array<out T>.randomOrNull(random: Random): T?
fun ByteArray.randomOrNull(random: Random): Byte?
fun ShortArray.randomOrNull(random: Random): Short?
fun IntArray.randomOrNull(random: Random): Int?
fun LongArray.randomOrNull(random: Random): Long?
fun FloatArray.randomOrNull(random: Random): Float?
fun DoubleArray.randomOrNull(random: Random): Double?
fun BooleanArray.randomOrNull(random: Random): Boolean?
fun CharArray.randomOrNull(random: Random): Char?
fun UIntArray.randomOrNull(random: Random): UInt?
fun ULongArray.randomOrNull(random: Random): ULong?
fun UByteArray.randomOrNull(random: Random): UByte?
fun UShortArray.randomOrNull(random: Random): UShort?
Возвращает случайный элемент из этого набора, или null если этот набор пустой.
fun <T> Collection<T>.randomOrNull(): T?
Возвращает случайный элемент из этого набора, используя указанный источник случайности, или null если этот набор пустой.
fun <T> Collection<T>.randomOrNull(random: Random): T?
reduce
Накапливает значение, начиная с первого элемента и применяя operation слева направо к текущему значению аккумулятора и каждому элементу.
fun <S, T : S> Array<out T>.reduce( operation: (acc: S, T) -> S ): S
fun ByteArray.reduce( operation: (acc: Byte, Byte) -> Byte ): Byte
fun ShortArray.reduce( operation: (acc: Short, Short) -> Short ): Short
fun IntArray.reduce(operation: (acc: Int, Int) -> Int): Int
fun LongArray.reduce( operation: (acc: Long, Long) -> Long ): Long
fun FloatArray.reduce( operation: (acc: Float, Float) -> Float ): Float
fun DoubleArray.reduce( operation: (acc: Double, Double) -> Double ): Double
fun BooleanArray.reduce( operation: (acc: Boolean, Boolean) -> Boolean ): Boolean
fun CharArray.reduce( operation: (acc: Char, Char) -> Char ): Char
fun <S, T : S> Iterable<T>.reduce( operation: (acc: S, T) -> S ): S
fun UIntArray.reduce( operation: (acc: UInt, UInt) -> UInt ): UInt
fun ULongArray.reduce( operation: (acc: ULong, ULong) -> ULong ): ULong
fun UByteArray.reduce( operation: (acc: UByte, UByte) -> UByte ): UByte
fun UShortArray.reduce( operation: (acc: UShort, UShort) -> UShort ): UShort
Группирует элементы из источника Grouping по ключу и применяет редуцирующую operation к элементам каждой группы последовательно, начиная со второго элемента группы, передавая ранее накопленное значение и текущий элемент в качестве аргументов, и сохраняет результаты в новой карте. Начальное значение аккумулятора - это первый элемент группы.
fun <S, T : S, K> Grouping<T, K>.reduce( operation: (key: K, accumulator: S, element: T) -> S ): Map<K, S>
reduceIndexed
Накапливает значение, начиная с первого элемента и применяя operation слева направо к текущему значению аккумулятора и каждому элементу с его индексом в исходном массиве.
fun <S, T : S> Array<out T>.reduceIndexed( operation: (index: Int, acc: S, T) -> S ): S
fun ByteArray.reduceIndexed( operation: (index: Int, acc: Byte, Byte) -> Byte ): Byte
fun ShortArray.reduceIndexed( operation: (index: Int, acc: Short, Short) -> Short ): Short
fun IntArray.reduceIndexed( operation: (index: Int, acc: Int, Int) -> Int ): Int
fun LongArray.reduceIndexed( operation: (index: Int, acc: Long, Long) -> Long ): Long
fun FloatArray.reduceIndexed( operation: (index: Int, acc: Float, Float) -> Float ): Float
fun DoubleArray.reduceIndexed( operation: (index: Int, acc: Double, Double) -> Double ): Double
fun BooleanArray.reduceIndexed( operation: (index: Int, acc: Boolean, Boolean) -> Boolean ): Boolean
fun CharArray.reduceIndexed( operation: (index: Int, acc: Char, Char) -> Char ): Char
fun UIntArray.reduceIndexed( operation: (index: Int, acc: UInt, UInt) -> UInt ): UInt
fun ULongArray.reduceIndexed( operation: (index: Int, acc: ULong, ULong) -> ULong ): ULong
fun UByteArray.reduceIndexed( operation: (index: Int, acc: UByte, UByte) -> UByte ): UByte
fun UShortArray.reduceIndexed( operation: (index: Int, acc: UShort, UShort) -> UShort ): UShort
Накапливает значение, начиная с первого элемента и применяя operation слева направо к текущему значению аккумулятора и каждому элементу с его индексом в исходной коллекции.
fun <S, T : S> Iterable<T>.reduceIndexed( operation: (index: Int, acc: S, T) -> S ): S
reduceIndexedOrNull
Накапливает значение, начиная с первого элемента и применяя операцию слева направо к текущему накопленному значению и каждому элементу с его индексом в исходном массиве.
fun <S, T : S> Array<out T>.reduceIndexedOrNull( operation: (index: Int, acc: S, T) -> S ): S?
fun ByteArray.reduceIndexedOrNull( operation: (index: Int, acc: Byte, Byte) -> Byte ): Byte?
fun ShortArray.reduceIndexedOrNull( operation: (index: Int, acc: Short, Short) -> Short ): Short?
fun IntArray.reduceIndexedOrNull( operation: (index: Int, acc: Int, Int) -> Int ): Int?
fun LongArray.reduceIndexedOrNull( operation: (index: Int, acc: Long, Long) -> Long ): Long?
fun FloatArray.reduceIndexedOrNull( operation: (index: Int, acc: Float, Float) -> Float ): Float?
fun DoubleArray.reduceIndexedOrNull( operation: (index: Int, acc: Double, Double) -> Double ): Double?
fun BooleanArray.reduceIndexedOrNull( operation: (index: Int, acc: Boolean, Boolean) -> Boolean ): Boolean?
fun CharArray.reduceIndexedOrNull( operation: (index: Int, acc: Char, Char) -> Char ): Char?
fun UIntArray.reduceIndexedOrNull( operation: (index: Int, acc: UInt, UInt) -> UInt ): UInt?
fun ULongArray.reduceIndexedOrNull( operation: (index: Int, acc: ULong, ULong) -> ULong ): ULong?
fun UByteArray.reduceIndexedOrNull( operation: (index: Int, acc: UByte, UByte) -> UByte ): UByte?
fun UShortArray.reduceIndexedOrNull( operation: (index: Int, acc: UShort, UShort) -> UShort ): UShort?
Накапливает значение, начиная с первого элемента и применяя операцию слева направо к текущему накопленному значению и каждому элементу с его индексом в исходной коллекции.
fun <S, T : S> Iterable<T>.reduceIndexedOrNull( operation: (index: Int, acc: S, T) -> S ): S?
reduceOrNull
Накапливает значение, начиная с первого элемента и применяя операцию слева направо к текущему накопленному значению и каждому элементу.
fun <S, T : S> Array<out T>.reduceOrNull( operation: (acc: S, T) -> S ): S?
fun ByteArray.reduceOrNull( operation: (acc: Byte, Byte) -> Byte ): Byte?
fun ShortArray.reduceOrNull( operation: (acc: Short, Short) -> Short ): Short?
fun IntArray.reduceOrNull( operation: (acc: Int, Int) -> Int ): Int?
fun LongArray.reduceOrNull( operation: (acc: Long, Long) -> Long ): Long?
fun FloatArray.reduceOrNull( operation: (acc: Float, Float) -> Float ): Float?
fun DoubleArray.reduceOrNull( operation: (acc: Double, Double) -> Double ): Double?
fun BooleanArray.reduceOrNull( operation: (acc: Boolean, Boolean) -> Boolean ): Boolean?
fun CharArray.reduceOrNull( operation: (acc: Char, Char) -> Char ): Char?
fun <S, T : S> Iterable<T>.reduceOrNull( operation: (acc: S, T) -> S ): S?
fun UIntArray.reduceOrNull( operation: (acc: UInt, UInt) -> UInt ): UInt?
fun ULongArray.reduceOrNull( operation: (acc: ULong, ULong) -> ULong ): ULong?
fun UByteArray.reduceOrNull( operation: (acc: UByte, UByte) -> UByte ): UByte?
fun UShortArray.reduceOrNull( operation: (acc: UShort, UShort) -> UShort ): UShort?
reduceRight
Накапливает значение, начиная с последнего элемента и применяя операцию справа налево к каждому элементу и текущему накопленному значению.
fun <S, T : S> Array<out T>.reduceRight( operation: (T, acc: S) -> S ): S
fun ByteArray.reduceRight( operation: (Byte, acc: Byte) -> Byte ): Byte
fun ShortArray.reduceRight( operation: (Short, acc: Short) -> Short ): Short
fun IntArray.reduceRight( operation: (Int, acc: Int) -> Int ): Int
fun LongArray.reduceRight( operation: (Long, acc: Long) -> Long ): Long
fun FloatArray.reduceRight( operation: (Float, acc: Float) -> Float ): Float
fun DoubleArray.reduceRight( operation: (Double, acc: Double) -> Double ): Double
fun BooleanArray.reduceRight( operation: (Boolean, acc: Boolean) -> Boolean ): Boolean
fun CharArray.reduceRight( operation: (Char, acc: Char) -> Char ): Char
fun UIntArray.reduceRight( operation: (UInt, acc: UInt) -> UInt ): UInt
fun ULongArray.reduceRight( operation: (ULong, acc: ULong) -> ULong ): ULong
fun UByteArray.reduceRight( operation: (UByte, acc: UByte) -> UByte ): UByte
fun UShortArray.reduceRight( operation: (UShort, acc: UShort) -> UShort ): UShort
reduceRightIndexed
Накапливает значение, начиная с последнего элемента и применяя операцию справа налево к каждому элементу с его индексом в исходном массиве и текущему накопленному значению.
fun <S, T : S> Array<out T>.reduceRightIndexed( operation: (index: Int, T, acc: S) -> S ): S
fun ByteArray.reduceRightIndexed( operation: (index: Int, Byte, acc: Byte) -> Byte ): Byte
fun ShortArray.reduceRightIndexed( operation: (index: Int, Short, acc: Short) -> Short ): Short
fun IntArray.reduceRightIndexed( operation: (index: Int, Int, acc: Int) -> Int ): Int
fun LongArray.reduceRightIndexed( operation: (index: Int, Long, acc: Long) -> Long ): Long
fun FloatArray.reduceRightIndexed( operation: (index: Int, Float, acc: Float) -> Float ): Float
fun DoubleArray.reduceRightIndexed( operation: (index: Int, Double, acc: Double) -> Double ): Double
fun BooleanArray.reduceRightIndexed( operation: (index: Int, Boolean, acc: Boolean) -> Boolean ): Boolean
fun UIntArray.reduceRightIndexed( operation: (index: Int, UInt, acc: UInt) -> UInt ): UInt
fun ULongArray.reduceRightIndexed( operation: (index: Int, ULong, acc: ULong) -> ULong ): ULong
fun UByteArray.reduceRightIndexed( operation: (index: Int, UByte, acc: UByte) -> UByte ): UByte
fun UShortArray.reduceRightIndexed( operation: (index: Int, UShort, acc: UShort) -> UShort ): UShort
Накапливает значение, начиная с последнего элемента и применяя операцию справа налево к каждому элементу с его индексом в исходном списке и текущему накопленному значению.
fun <S, T : S> List<T>.reduceRightIndexed( operation: (index: Int, T, acc: S) -> S ): S
reduceRightIndexedOrNull
Накапливает значение, начиная с последнего элемента, и применяет operation справа налево к каждому элементу с его индексом в исходном массиве и текущим значением аккумулятора.
fun <S, T : S> Array<out T>.reduceRightIndexedOrNull( operation: (index: Int, T, acc: S) -> S ): S?
fun ByteArray.reduceRightIndexedOrNull( operation: (index: Int, Byte, acc: Byte) -> Byte ): Byte?
fun ShortArray.reduceRightIndexedOrNull( operation: (index: Int, Short, acc: Short) -> Short ): Short?
fun IntArray.reduceRightIndexedOrNull( operation: (index: Int, Int, acc: Int) -> Int ): Int?
fun LongArray.reduceRightIndexedOrNull( operation: (index: Int, Long, acc: Long) -> Long ): Long?
fun FloatArray.reduceRightIndexedOrNull( operation: (index: Int, Float, acc: Float) -> Float ): Float?
fun DoubleArray.reduceRightIndexedOrNull( operation: (index: Int, Double, acc: Double) -> Double ): Double?
fun BooleanArray.reduceRightIndexedOrNull( operation: (index: Int, Boolean, acc: Boolean) -> Boolean ): Boolean?
fun CharArray.reduceRightIndexedOrNull( operation: (index: Int, Char, acc: Char) -> Char ): Char?
fun UIntArray.reduceRightIndexedOrNull( operation: (index: Int, UInt, acc: UInt) -> UInt ): UInt?
fun ULongArray.reduceRightIndexedOrNull( operation: (index: Int, ULong, acc: ULong) -> ULong ): ULong?
fun UByteArray.reduceRightIndexedOrNull( operation: (index: Int, UByte, acc: UByte) -> UByte ): UByte?
fun UShortArray.reduceRightIndexedOrNull( operation: (index: Int, UShort, acc: UShort) -> UShort ): UShort?
Накапливает значение, начиная с последнего элемента, и применяет operation справа налево к каждому элементу с его индексом в исходном списке и текущим значением аккумулятора.
fun <S, T : S> List<T>.reduceRightIndexedOrNull( operation: (index: Int, T, acc: S) -> S ): S?
reduceRightOrNull
Накапливает значение, начиная с последнего элемента, и применяет operation справа налево к каждому элементу и текущему значению аккумулятора.
fun <S, T : S> Array<out T>.reduceRightOrNull( operation: (T, acc: S) -> S ): S?
fun ByteArray.reduceRightOrNull( operation: (Byte, acc: Byte) -> Byte ): Byte?
fun ShortArray.reduceRightOrNull( operation: (Short, acc: Short) -> Short ): Short?
fun IntArray.reduceRightOrNull( operation: (Int, acc: Int) -> Int ): Int?
fun LongArray.reduceRightOrNull( operation: (Long, acc: Long) -> Long ): Long?
fun FloatArray.reduceRightOrNull( operation: (Float, acc: Float) -> Float ): Float?
fun DoubleArray.reduceRightOrNull( operation: (Double, acc: Double) -> Double ): Double?
fun BooleanArray.reduceRightOrNull( operation: (Boolean, acc: Boolean) -> Boolean ): Boolean?
fun CharArray.reduceRightOrNull( operation: (Char, acc: Char) -> Char ): Char?
fun <S, T : S> List<T>.reduceRightOrNull( operation: (T, acc: S) -> S ): S?
fun UIntArray.reduceRightOrNull( operation: (UInt, acc: UInt) -> UInt ): UInt?
fun ULongArray.reduceRightOrNull( operation: (ULong, acc: ULong) -> ULong ): ULong?
fun UByteArray.reduceRightOrNull( operation: (UByte, acc: UByte) -> UByte ): UByte?
fun UShortArray.reduceRightOrNull( operation: (UShort, acc: UShort) -> UShort ): UShort?
reduceTo
Группирует элементы из источника Grouping по ключу и применяет редуцирующую operation к элементам каждой группы последовательно, начиная со второго элемента группы, передавая ранее накопленное значение и текущий элемент в качестве аргументов, и сохраняет результаты в заданном destination отображении. Начальное значение аккумулятора - первый элемент группы.
fun <S, T : S, K, M : MutableMap<in K, S>> Grouping<T, K>.reduceTo( destination: M, operation: (key: K, accumulator: S, element: T) -> S ): M
remove
Удаляет указанный ключ и соответствующее ему значение из этого отображения.
fun <K, V> MutableMap<out K, V>.remove(key: K): V?
Удаляет один экземпляр указанного элемента из этого набора, если он присутствует.
fun <T> MutableCollection<out T>.remove(element: T): Boolean
Удаляет элемент по указанному индексу из этого списка. В Kotlin следует использовать функцию MutableList.removeAt вместо этого.
fun <T> MutableList<T>.remove(index: Int): T
Удаляет запись для указанного ключа только в том случае, если она в настоящее время отображается для указанного значения.
fun <K, V> MutableMap<out K, out V>.remove( key: K, value: V ): Boolean
удаление всех
Удаляет все элементы этой коллекции, которые также содержатся в указанной коллекции.
fun <T> MutableCollection<out T>.removeAll( elements: Collection<T> ): Boolean
Удаляет все элементы из этого MutableCollection, которые также содержатся в заданной коллекции элементов.
fun <T> MutableCollection<in T>.removeAll( elements: Iterable<T> ): Boolean
Удаляет все элементы из этого MutableCollection, которые также содержатся в заданной последовательности элементов.
fun <T> MutableCollection<in T>.removeAll( elements: Sequence<T> ): Boolean
Удаляет все элементы из этого MutableCollection, которые также содержатся в заданном массиве элементов.
fun <T> MutableCollection<in T>.removeAll( elements: Array<out T> ): Boolean
Удаляет все элементы из этого MutableIterable, которые соответствуют заданному предикату.
fun <T> MutableIterable<T>.removeAll( predicate: (T) -> Boolean ): Boolean
Удаляет все элементы из этого MutableList, которые соответствуют заданному предикату.
fun <T> MutableList<T>.removeAll( predicate: (T) -> Boolean ): Boolean
удалить первый
Удаляет первый элемент из этого изменяемого списка и возвращает удаленный элемент, или выбрасывает исключение NoSuchElementException, если список пуст.
fun <T> MutableList<T>.removeFirst(): T
удалить первый или null
Удаляет первый элемент из этого изменяемого списка и возвращает удаленный элемент, или возвращает null , если список пуст.
fun <T> MutableList<T>.removeFirstOrNull(): T?
удалить последний
Удаляет последний элемент из этого изменяемого списка и возвращает удаленный элемент, или выбрасывает исключение NoSuchElementException, если список пуст.
fun <T> MutableList<T>.removeLast(): T
удалить последний или null
Удаляет последний элемент из этого изменяемого списка и возвращает удаленный элемент, или возвращает null , если список пуст.
fun <T> MutableList<T>.removeLastOrNull(): T?
требовать отсутствие null
Возвращает исходную коллекцию, содержащую все элементы, не являющиеся null, выбрасывая исключение IllegalArgumentException, если есть какие-либо null элементы.
fun <T : Any> Array<T?>.requireNoNulls(): Array<T>
fun <T : Any> Iterable<T?>.requireNoNulls(): Iterable<T>
fun <T : Any> List<T?>.requireNoNulls(): List<T>
сохранить все
Сохраняет только элементы в этой коллекции, которые содержатся в указанной коллекции.
fun <T> MutableCollection<out T>.retainAll( elements: Collection<T> ): Boolean
Сохраняет только элементы этого MutableCollection, которые содержатся в заданной коллекции элементов.
fun <T> MutableCollection<in T>.retainAll( elements: Iterable<T> ): Boolean
Сохраняет только элементы этого MutableCollection, которые содержатся в заданном массиве элементов.
fun <T> MutableCollection<in T>.retainAll( elements: Array<out T> ): Boolean
Сохраняет только элементы этого MutableCollection, которые содержатся в заданной последовательности элементов.
fun <T> MutableCollection<in T>.retainAll( elements: Sequence<T> ): Boolean
Сохраняет только элементы этого MutableIterable, которые соответствуют заданному предикату.
fun <T> MutableIterable<T>.retainAll( predicate: (T) -> Boolean ): Boolean
Сохраняет только элементы этого MutableList, которые соответствуют заданному предикату.
fun <T> MutableList<T>.retainAll( predicate: (T) -> Boolean ): Boolean
reverse
Инвертирует элементы в массиве на месте.
fun <T> Array<T>.reverse()
fun ByteArray.reverse()
fun ShortArray.reverse()
fun IntArray.reverse()
fun LongArray.reverse()
fun FloatArray.reverse()
fun DoubleArray.reverse()
fun BooleanArray.reverse()
fun CharArray.reverse()
fun UIntArray.reverse()
fun ULongArray.reverse()
fun UByteArray.reverse()
fun UShortArray.reverse()
Инвертирует элементы массива в указанном диапазоне на месте.
fun <T> Array<T>.reverse(fromIndex: Int, toIndex: Int)
fun ByteArray.reverse(fromIndex: Int, toIndex: Int)
fun ShortArray.reverse(fromIndex: Int, toIndex: Int)
fun IntArray.reverse(fromIndex: Int, toIndex: Int)
fun LongArray.reverse(fromIndex: Int, toIndex: Int)
fun FloatArray.reverse(fromIndex: Int, toIndex: Int)
fun DoubleArray.reverse(fromIndex: Int, toIndex: Int)
fun BooleanArray.reverse(fromIndex: Int, toIndex: Int)
fun CharArray.reverse(fromIndex: Int, toIndex: Int)
fun UIntArray.reverse(fromIndex: Int, toIndex: Int)
fun ULongArray.reverse(fromIndex: Int, toIndex: Int)
fun UByteArray.reverse(fromIndex: Int, toIndex: Int)
fun UShortArray.reverse(fromIndex: Int, toIndex: Int)
Инвертирует элементы списка на месте.
fun <T> MutableList<T>.reverse()
reversed
Возвращает список с элементами в обратном порядке.
fun <T> Array<out T>.reversed(): List<T>
fun ByteArray.reversed(): List<Byte>
fun ShortArray.reversed(): List<Short>
fun IntArray.reversed(): List<Int>
fun LongArray.reversed(): List<Long>
fun FloatArray.reversed(): List<Float>
fun DoubleArray.reversed(): List<Double>
fun BooleanArray.reversed(): List<Boolean>
fun CharArray.reversed(): List<Char>
fun UIntArray.reversed(): List<UInt>
fun ULongArray.reversed(): List<ULong>
fun UByteArray.reversed(): List<UByte>
fun UShortArray.reversed(): List<UShort>
reversedArray
Возвращает массив с элементами этого массива в обратном порядке.
fun <T> Array<T>.reversedArray(): Array<T>
fun ByteArray.reversedArray(): ByteArray
fun ShortArray.reversedArray(): ShortArray
fun IntArray.reversedArray(): IntArray
fun LongArray.reversedArray(): LongArray
fun FloatArray.reversedArray(): FloatArray
fun DoubleArray.reversedArray(): DoubleArray
fun BooleanArray.reversedArray(): BooleanArray
fun UIntArray.reversedArray(): UIntArray
fun ULongArray.reversedArray(): ULongArray
fun UByteArray.reversedArray(): UByteArray
fun UShortArray.reversedArray(): UShortArray
runningFold
Возвращает список, содержащий последовательные накопительные значения, сгенерированные путём применения operation слева направо к каждому элементу и текущему значению аккумулятора, начиная со значения .
fun <T, R> Array<out T>.runningFold( initial: R, operation: (acc: R, T) -> R ): List<R>
fun <R> ByteArray.runningFold( initial: R, operation: (acc: R, Byte) -> R ): List<R>
fun <R> ShortArray.runningFold( initial: R, operation: (acc: R, Short) -> R ): List<R>
fun <R> IntArray.runningFold( initial: R, operation: (acc: R, Int) -> R ): List<R>
fun <R> LongArray.runningFold( initial: R, operation: (acc: R, Long) -> R ): List<R>
fun <R> FloatArray.runningFold( initial: R, operation: (acc: R, Float) -> R ): List<R>
fun <R> DoubleArray.runningFold( initial: R, operation: (acc: R, Double) -> R ): List<R>
fun <R> BooleanArray.runningFold( initial: R, operation: (acc: R, Boolean) -> R ): List<R>
fun <R> CharArray.runningFold( initial: R, operation: (acc: R, Char) -> R ): List<R>
fun <T, R> Iterable<T>.runningFold( initial: R, operation: (acc: R, T) -> R ): List<R>
fun <R> UIntArray.runningFold( initial: R, operation: (acc: R, UInt) -> R ): List<R>
fun <R> ULongArray.runningFold( initial: R, operation: (acc: R, ULong) -> R ): List<R>
fun <R> UByteArray.runningFold( initial: R, operation: (acc: R, UByte) -> R ): List<R>
fun <R> UShortArray.runningFold( initial: R, operation: (acc: R, UShort) -> R ): List<R>
runningFoldIndexed
Возвращает список, содержащий последовательные значения накопления, полученные путём применения операции слева направо к каждому элементу, его индексу в исходном массиве и текущему значению накопителя, которое начинается со значения initial.
fun <T, R> Array<out T>.runningFoldIndexed( initial: R, operation: (index: Int, acc: R, T) -> R ): List<R>
fun <R> ByteArray.runningFoldIndexed( initial: R, operation: (index: Int, acc: R, Byte) -> R ): List<R>
fun <R> ShortArray.runningFoldIndexed( initial: R, operation: (index: Int, acc: R, Short) -> R ): List<R>
fun <R> IntArray.runningFoldIndexed( initial: R, operation: (index: Int, acc: R, Int) -> R ): List<R>
fun <R> LongArray.runningFoldIndexed( initial: R, operation: (index: Int, acc: R, Long) -> R ): List<R>
fun <R> FloatArray.runningFoldIndexed( initial: R, operation: (index: Int, acc: R, Float) -> R ): List<R>
fun <R> DoubleArray.runningFoldIndexed( initial: R, operation: (index: Int, acc: R, Double) -> R ): List<R>
fun <R> BooleanArray.runningFoldIndexed( initial: R, operation: (index: Int, acc: R, Boolean) -> R ): List<R>
fun <R> CharArray.runningFoldIndexed( initial: R, operation: (index: Int, acc: R, Char) -> R ): List<R>
fun <R> UIntArray.runningFoldIndexed( initial: R, operation: (index: Int, acc: R, UInt) -> R ): List<R>
fun <R> ULongArray.runningFoldIndexed( initial: R, operation: (index: Int, acc: R, ULong) -> R ): List<R>
fun <R> UByteArray.runningFoldIndexed( initial: R, operation: (index: Int, acc: R, UByte) -> R ): List<R>
fun <R> UShortArray.runningFoldIndexed( initial: R, operation: (index: Int, acc: R, UShort) -> R ): List<R>
Возвращает список, содержащий последовательные значения накопления, полученные путём применения операции слева направо к каждому элементу, его индексу в исходном наборе и текущему значению накопителя, которое начинается со значения initial.
fun <T, R> Iterable<T>.runningFoldIndexed( initial: R, operation: (index: Int, acc: R, T) -> R ): List<R>
runningReduce
Возвращает список, содержащий последовательные значения накопления, полученные путём применения операции слева направо к каждому элементу и текущему значению накопителя, которое начинается с первого элемента этого массива.
fun <S, T : S> Array<out T>.runningReduce( operation: (acc: S, T) -> S ): List<S>
fun ByteArray.runningReduce( operation: (acc: Byte, Byte) -> Byte ): List<Byte>
fun ShortArray.runningReduce( operation: (acc: Short, Short) -> Short ): List<Short>
fun IntArray.runningReduce( operation: (acc: Int, Int) -> Int ): List<Int>
fun LongArray.runningReduce( operation: (acc: Long, Long) -> Long ): List<Long>
fun FloatArray.runningReduce( operation: (acc: Float, Float) -> Float ): List<Float>
fun DoubleArray.runningReduce( operation: (acc: Double, Double) -> Double ): List<Double>
fun BooleanArray.runningReduce( operation: (acc: Boolean, Boolean) -> Boolean ): List<Boolean>
fun CharArray.runningReduce( operation: (acc: Char, Char) -> Char ): List<Char>
fun UIntArray.runningReduce( operation: (acc: UInt, UInt) -> UInt ): List<UInt>
fun ULongArray.runningReduce( operation: (acc: ULong, ULong) -> ULong ): List<ULong>
fun UByteArray.runningReduce( operation: (acc: UByte, UByte) -> UByte ): List<UByte>
fun UShortArray.runningReduce( operation: (acc: UShort, UShort) -> UShort ): List<UShort>
Возвращает список, содержащий последовательные значения накопления, полученные путём применения операции слева направо к каждому элементу и текущему значению накопителя, которое начинается с первого элемента этого набора.
fun <S, T : S> Iterable<T>.runningReduce( operation: (acc: S, T) -> S ): List<S>
runningReduceIndexed
Возвращает список, содержащий последовательные значения накопления, полученные путём применения операции слева направо к каждому элементу, его индексу в исходном массиве и текущему значению накопителя, которое начинается с первого элемента этого массива.
fun <S, T : S> Array<out T>.runningReduceIndexed( operation: (index: Int, acc: S, T) -> S ): List<S>
fun ByteArray.runningReduceIndexed( operation: (index: Int, acc: Byte, Byte) -> Byte ): List<Byte>
fun ShortArray.runningReduceIndexed( operation: (index: Int, acc: Short, Short) -> Short ): List<Short>
fun IntArray.runningReduceIndexed( operation: (index: Int, acc: Int, Int) -> Int ): List<Int>
fun LongArray.runningReduceIndexed( operation: (index: Int, acc: Long, Long) -> Long ): List<Long>
fun FloatArray.runningReduceIndexed( operation: (index: Int, acc: Float, Float) -> Float ): List<Float>
fun DoubleArray.runningReduceIndexed( operation: (index: Int, acc: Double, Double) -> Double ): List<Double>
fun BooleanArray.runningReduceIndexed( operation: (index: Int, acc: Boolean, Boolean) -> Boolean ): List<Boolean>
fun CharArray.runningReduceIndexed( operation: (index: Int, acc: Char, Char) -> Char ): List<Char>
fun UIntArray.runningReduceIndexed( operation: (index: Int, acc: UInt, UInt) -> UInt ): List<UInt>
fun ULongArray.runningReduceIndexed( operation: (index: Int, acc: ULong, ULong) -> ULong ): List<ULong>
fun UByteArray.runningReduceIndexed( operation: (index: Int, acc: UByte, UByte) -> UByte ): List<UByte>
fun UShortArray.runningReduceIndexed( operation: (index: Int, acc: UShort, UShort) -> UShort ): List<UShort>
Возвращает список, содержащий последовательные значения накопления, полученные путём применения операции слева направо к каждому элементу, его индексу в исходном наборе и текущему значению накопителя, которое начинается с первого элемента этого набора.
fun <S, T : S> Iterable<T>.runningReduceIndexed( operation: (index: Int, acc: S, T) -> S ): List<S>
scan
Возвращает список, содержащий последовательные накопленные значения, полученные путём применения operation слева направо к каждому элементу и текущему значению накопителя, начиная со значения initial.
fun <T, R> Array<out T>.scan( initial: R, operation: (acc: R, T) -> R ): List<R>
fun <R> ByteArray.scan( initial: R, operation: (acc: R, Byte) -> R ): List<R>
fun <R> ShortArray.scan( initial: R, operation: (acc: R, Short) -> R ): List<R>
fun <R> IntArray.scan( initial: R, operation: (acc: R, Int) -> R ): List<R>
fun <R> LongArray.scan( initial: R, operation: (acc: R, Long) -> R ): List<R>
fun <R> FloatArray.scan( initial: R, operation: (acc: R, Float) -> R ): List<R>
fun <R> DoubleArray.scan( initial: R, operation: (acc: R, Double) -> R ): List<R>
fun <R> BooleanArray.scan( initial: R, operation: (acc: R, Boolean) -> R ): List<R>
fun <R> CharArray.scan( initial: R, operation: (acc: R, Char) -> R ): List<R>
fun <T, R> Iterable<T>.scan( initial: R, operation: (acc: R, T) -> R ): List<R>
fun <R> UIntArray.scan( initial: R, operation: (acc: R, UInt) -> R ): List<R>
fun <R> ULongArray.scan( initial: R, operation: (acc: R, ULong) -> R ): List<R>
fun <R> UByteArray.scan( initial: R, operation: (acc: R, UByte) -> R ): List<R>
fun <R> UShortArray.scan( initial: R, operation: (acc: R, UShort) -> R ): List<R>
scanIndexed
Возвращает список, содержащий последовательные накопленные значения, полученные путём применения operation слева направо к каждому элементу, его индексу в исходном массиве и текущему значению накопителя, начиная со значения initial.
fun <T, R> Array<out T>.scanIndexed( initial: R, operation: (index: Int, acc: R, T) -> R ): List<R>
fun <R> ByteArray.scanIndexed( initial: R, operation: (index: Int, acc: R, Byte) -> R ): List<R>
fun <R> ShortArray.scanIndexed( initial: R, operation: (index: Int, acc: R, Short) -> R ): List<R>
fun <R> IntArray.scanIndexed( initial: R, operation: (index: Int, acc: R, Int) -> R ): List<R>
fun <R> LongArray.scanIndexed( initial: R, operation: (index: Int, acc: R, Long) -> R ): List<R>
fun <R> FloatArray.scanIndexed( initial: R, operation: (index: Int, acc: R, Float) -> R ): List<R>
fun <R> DoubleArray.scanIndexed( initial: R, operation: (index: Int, acc: R, Double) -> R ): List<R>
fun <R> BooleanArray.scanIndexed( initial: R, operation: (index: Int, acc: R, Boolean) -> R ): List<R>
fun <R> CharArray.scanIndexed( initial: R, operation: (index: Int, acc: R, Char) -> R ): List<R>
fun <R> UIntArray.scanIndexed( initial: R, operation: (index: Int, acc: R, UInt) -> R ): List<R>
fun <R> ULongArray.scanIndexed( initial: R, operation: (index: Int, acc: R, ULong) -> R ): List<R>
fun <R> UByteArray.scanIndexed( initial: R, operation: (index: Int, acc: R, UByte) -> R ): List<R>
fun <R> UShortArray.scanIndexed( initial: R, operation: (index: Int, acc: R, UShort) -> R ): List<R>
Возвращает список, содержащий последовательные накопленные значения, полученные путём применения operation слева направо к каждому элементу, его индексу в исходной коллекции и текущему значению накопителя, начиная со значения initial value.
fun <T, R> Iterable<T>.scanIndexed( initial: R, operation: (index: Int, acc: R, T) -> R ): List<R>
set
Позволяет использовать оператор индекса для хранения значений в изменяемой карте.
operator fun <K, V> MutableMap<K, V>.set(key: K, value: V)
setOf
Возвращает новую неизменяемую коллекцию (set) с заданными элементами. Элементы множества перебираются в порядке их указания. Возвращаемое множество сериализуемо (JVM).
fun <T> setOf(vararg elements: T): Set<T>
Возвращает пустое неизменяемое множество. Возвращаемое множество сериализуемо (JVM).
fun <T> setOf(): Set<T>
Возвращает неизменяемое множество, содержащее только указанный объект element. Возвращаемое множество сериализуемо.
fun <T> setOf(element: T): Set<T>
setOfNotNull
Возвращает новое неизменяемое множество, содержащее только один элемент, если он не null, или пустое множество, если элемент null. Возвращаемое множество сериализуемо (JVM).
fun <T : Any> setOfNotNull(element: T?): Set<T>
Возвращает новое неизменяемое множество, содержащее только те элементы, которые не null. Элементы множества перебираются в порядке их указания. Возвращаемое множество сериализуемо (JVM).
fun <T : Any> setOfNotNull(vararg elements: T?): Set<T>
setValue
Хранит значение свойства для данного объекта в этой изменяемой карте.
operator fun <V> MutableMap<in String, in V>.setValue( thisRef: Any?, property: KProperty<*>, value: V)
перемешать
Случайным образом перемешивает элементы в этом массиве на месте.
fun <T> Array<T>.shuffle()
fun ByteArray.shuffle()
fun ShortArray.shuffle()
fun IntArray.shuffle()
fun LongArray.shuffle()
fun FloatArray.shuffle()
fun DoubleArray.shuffle()
fun BooleanArray.shuffle()
fun CharArray.shuffle()
fun UIntArray.shuffle()
fun ULongArray.shuffle()
fun UByteArray.shuffle()
fun UShortArray.shuffle()
Случайным образом перемешивает элементы в этом массиве на месте, используя указанный источник случайности.
fun <T> Array<T>.shuffle(random: Random)
fun ByteArray.shuffle(random: Random)
fun ShortArray.shuffle(random: Random)
fun IntArray.shuffle(random: Random)
fun LongArray.shuffle(random: Random)
fun FloatArray.shuffle(random: Random)
fun DoubleArray.shuffle(random: Random)
fun BooleanArray.shuffle(random: Random)
fun CharArray.shuffle(random: Random)
fun UIntArray.shuffle(random: Random)
fun ULongArray.shuffle(random: Random)
fun UByteArray.shuffle(random: Random)
fun UShortArray.shuffle(random: Random)
Случайным образом перемешивает элементы в этом списке на месте, используя указанный источник случайности.
fun <T> MutableList<T>.shuffle(random: Random)
Случайным образом перемешивает элементы в этом изменяемом списке, используя указанный источник случайности.
fun <T> MutableList<T>.shuffle(random: Random)
Случайным образом перемешивает элементы в этом изменяемом списке.
fun <T> MutableList<T>.shuffle()
получить перемешанный
Возвращает новый список с элементами этого списка, случайным образом перемешанными, используя указанный источник случайности.
fun <T> Iterable<T>.shuffled(random: Random): List<T>
fun <T> Iterable<T>.shuffled(random: Random): List<T>
Возвращает новый список с элементами этого списка, случайным образом перемешанными.
fun <T> Iterable<T>.shuffled(): List<T>
один
Возвращает единственный элемент или выбрасывает исключение, если массив пуст или содержит более одного элемента.
fun <T> Array<out T>.single(): T
fun ByteArray.single(): Byte
fun ShortArray.single(): Short
fun IntArray.single(): Int
fun LongArray.single(): Long
fun FloatArray.single(): Float
fun DoubleArray.single(): Double
fun BooleanArray.single(): Boolean
fun CharArray.single(): Char
fun UIntArray.single(): UInt
fun ULongArray.single(): ULong
fun UByteArray.single(): UByte
fun UShortArray.single(): UShort
Возвращает единственный элемент, соответствующий заданному
fun <T> Array<out T>.single(predicate: (T) -> Boolean): T
fun ByteArray.single(predicate: (Byte) -> Boolean): Byte
fun ShortArray.single(predicate: (Short) -> Boolean): Short
fun IntArray.single(predicate: (Int) -> Boolean): Int
fun LongArray.single(predicate: (Long) -> Boolean): Long
fun FloatArray.single(predicate: (Float) -> Boolean): Float
fun DoubleArray.single( predicate: (Double) -> Boolean ): Double
fun BooleanArray.single( predicate: (Boolean) -> Boolean ): Boolean
fun CharArray.single(predicate: (Char) -> Boolean): Char
fun <T> Iterable<T>.single(predicate: (T) -> Boolean): T
fun UIntArray.single(predicate: (UInt) -> Boolean): UInt
fun ULongArray.single(predicate: (ULong) -> Boolean): ULong
fun UByteArray.single(predicate: (UByte) -> Boolean): UByte
fun UShortArray.single( predicate: (UShort) -> Boolean ): UShort
Возвращает единственный элемент или выбрасывает исключение, если коллекция пуста или содержит более одного элемента.
fun <T> Iterable<T>.single(): T
Возвращает единственный элемент или выбрасывает исключение, если список пуст или содержит более одного элемента.
fun <T> List<T>.single(): T
singleOrNull
Возвращает единственный элемент, или null если массив пустой или содержит более одного элемента.
fun <T> Array<out T>.singleOrNull(): T?
fun ByteArray.singleOrNull(): Byte?
fun ShortArray.singleOrNull(): Short?
fun IntArray.singleOrNull(): Int?
fun LongArray.singleOrNull(): Long?
fun FloatArray.singleOrNull(): Float?
fun DoubleArray.singleOrNull(): Double?
fun BooleanArray.singleOrNull(): Boolean?
fun CharArray.singleOrNull(): Char?
fun UIntArray.singleOrNull(): UInt?
fun ULongArray.singleOrNull(): ULong?
fun UByteArray.singleOrNull(): UByte?
fun UShortArray.singleOrNull(): UShort?
Возвращает единственный элемент, соответствующий заданному предикату, или null если элемент не найден или найдено более одного элемента.
fun <T> Array<out T>.singleOrNull( predicate: (T) -> Boolean ): T?
fun ByteArray.singleOrNull( predicate: (Byte) -> Boolean ): Byte?
fun ShortArray.singleOrNull( predicate: (Short) -> Boolean ): Short?
fun IntArray.singleOrNull(predicate: (Int) -> Boolean): Int?
fun LongArray.singleOrNull( predicate: (Long) -> Boolean ): Long?
fun FloatArray.singleOrNull( predicate: (Float) -> Boolean ): Float?
fun DoubleArray.singleOrNull( predicate: (Double) -> Boolean ): Double?
fun BooleanArray.singleOrNull( predicate: (Boolean) -> Boolean ): Boolean?
fun CharArray.singleOrNull( predicate: (Char) -> Boolean ): Char?
fun <T> Iterable<T>.singleOrNull( predicate: (T) -> Boolean ): T?
fun UIntArray.singleOrNull( predicate: (UInt) -> Boolean ): UInt?
fun ULongArray.singleOrNull( predicate: (ULong) -> Boolean ): ULong?
fun UByteArray.singleOrNull( predicate: (UByte) -> Boolean ): UByte?
fun UShortArray.singleOrNull( predicate: (UShort) -> Boolean ): UShort?
Возвращает единственный элемент, или null если коллекция пустая или содержит более одного элемента.
fun <T> Iterable<T>.singleOrNull(): T?
Возвращает единственный элемент, или null если список пустой или содержит более одного элемента.
fun <T> List<T>.singleOrNull(): T?
slice
Возвращает список, содержащий элементы по индексам в указанном диапазоне indices.
fun <T> Array<out T>.slice(indices: IntRange): List<T>
fun ByteArray.slice(indices: IntRange): List<Byte>
fun ShortArray.slice(indices: IntRange): List<Short>
fun IntArray.slice(indices: IntRange): List<Int>
fun LongArray.slice(indices: IntRange): List<Long>
fun FloatArray.slice(indices: IntRange): List<Float>
fun DoubleArray.slice(indices: IntRange): List<Double>
fun BooleanArray.slice(indices: IntRange): List<Boolean>
fun CharArray.slice(indices: IntRange): List<Char>
fun <T> List<T>.slice(indices: IntRange): List<T>
fun UIntArray.slice(indices: IntRange): List<UInt>
fun ULongArray.slice(indices: IntRange): List<ULong>
fun UByteArray.slice(indices: IntRange): List<UByte>
fun UShortArray.slice(indices: IntRange): List<UShort>
Возвращает список, содержащий элементы по указанным индексам.
fun <T> Array<out T>.slice(indices: Iterable<Int>): List<T>
fun ByteArray.slice(indices: Iterable<Int>): List<Byte>
fun ShortArray.slice(indices: Iterable<Int>): List<Short>
fun IntArray.slice(indices: Iterable<Int>): List<Int>
fun LongArray.slice(indices: Iterable<Int>): List<Long>
fun FloatArray.slice(indices: Iterable<Int>): List<Float>
fun DoubleArray.slice(indices: Iterable<Int>): List<Double>
fun BooleanArray.slice(indices: Iterable<Int>): List<Boolean>
fun CharArray.slice(indices: Iterable<Int>): List<Char>
fun <T> List<T>.slice(indices: Iterable<Int>): List<T>
fun UIntArray.slice(indices: Iterable<Int>): List<UInt>
fun ULongArray.slice(indices: Iterable<Int>): List<ULong>
fun UByteArray.slice(indices: Iterable<Int>): List<UByte>
fun UShortArray.slice(indices: Iterable<Int>): List<UShort>
sliceArray
Возвращает массив, содержащий элементы этого массива по указанным индексам.
fun <T> Array<T>.sliceArray( indices: Collection<Int> ): Array<T>
fun ByteArray.sliceArray(indices: Collection<Int>): ByteArray
fun ShortArray.sliceArray( indices: Collection<Int> ): ShortArray
fun IntArray.sliceArray(indices: Collection<Int>): IntArray
fun LongArray.sliceArray(indices: Collection<Int>): LongArray
fun FloatArray.sliceArray( indices: Collection<Int> ): FloatArray
fun DoubleArray.sliceArray( indices: Collection<Int> ): DoubleArray
fun BooleanArray.sliceArray( indices: Collection<Int> ): BooleanArray
fun CharArray.sliceArray(indices: Collection<Int>): CharArray
fun UIntArray.sliceArray(indices: Collection<Int>): UIntArray
fun ULongArray.sliceArray( indices: Collection<Int> ): ULongArray
fun UByteArray.sliceArray( indices: Collection<Int> ): UByteArray
fun UShortArray.sliceArray( indices: Collection<Int> ): UShortArray
Возвращает массив, содержащий элементы по индексам в указанном диапазоне индексов.
fun <T> Array<T>.sliceArray(indices: IntRange): Array<T>
fun ByteArray.sliceArray(indices: IntRange): ByteArray
fun ShortArray.sliceArray(indices: IntRange): ShortArray
fun IntArray.sliceArray(indices: IntRange): IntArray
fun LongArray.sliceArray(indices: IntRange): LongArray
fun FloatArray.sliceArray(indices: IntRange): FloatArray
fun DoubleArray.sliceArray(indices: IntRange): DoubleArray
fun BooleanArray.sliceArray(indices: IntRange): BooleanArray
fun CharArray.sliceArray(indices: IntRange): CharArray
fun UIntArray.sliceArray(indices: IntRange): UIntArray
fun ULongArray.sliceArray(indices: IntRange): ULongArray
fun UByteArray.sliceArray(indices: IntRange): UByteArray
fun UShortArray.sliceArray(indices: IntRange): UShortArray
sort
Сортирует массив на месте.
fun UIntArray.sort()
fun ULongArray.sort()
fun UByteArray.sort()
fun UShortArray.sort()
fun IntArray.sort()
fun LongArray.sort()
fun ByteArray.sort()
fun ShortArray.sort()
fun DoubleArray.sort()
fun FloatArray.sort()
fun CharArray.sort()
Сортирует диапазон в массиве на месте.
fun UIntArray.sort(fromIndex: Int = 0, toIndex: Int = size)
fun ULongArray.sort(fromIndex: Int = 0, toIndex: Int = size)
fun UByteArray.sort(fromIndex: Int = 0, toIndex: Int = size)
fun UShortArray.sort(fromIndex: Int = 0, toIndex: Int = size)
fun <T : Comparable<T>> Array<out T>.sort( fromIndex: Int = 0, toIndex: Int = size)
fun ByteArray.sort(fromIndex: Int = 0, toIndex: Int = size)
fun ShortArray.sort(fromIndex: Int = 0, toIndex: Int = size)
fun IntArray.sort(fromIndex: Int = 0, toIndex: Int = size)
fun LongArray.sort(fromIndex: Int = 0, toIndex: Int = size)
fun FloatArray.sort(fromIndex: Int = 0, toIndex: Int = size)
fun DoubleArray.sort(fromIndex: Int = 0, toIndex: Int = size)
fun CharArray.sort(fromIndex: Int = 0, toIndex: Int = size)
fun <T> MutableList<T>.sort(comparator: Comparator<in T>)
fun <T> MutableList<T>.sort(comparison: (T, T) -> Int)
Сортирует массив на месте в соответствии с порядком, заданным данной функцией сравнения.
fun <T> any_array<T>.sort(comparison: (a: T, b: T) -> Int)
Сортирует массив на месте в соответствии с естественным порядком элементов.
fun <T : Comparable<T>> any_array<T>.sort()
Сортирует элементы в списке на месте в соответствии с их естественным порядком сортировки.
fun <T : Comparable<T>> MutableList<T>.sort()
sortBy
Сортирует элементы в массиве на месте в соответствии с естественным порядком сортировки значения, возвращаемого заданной функцией селектора.
fun <T, R : Comparable<R>> Array<out T>.sortBy( selector: (T) -> R?)
Сортирует элементы в списке на месте в соответствии с естественным порядком сортировки значения, возвращаемого заданной функцией селектора.
fun <T, R : Comparable<R>> MutableList<T>.sortBy( selector: (T) -> R?)
sortByDescending
Сортирует элементы в массиве на месте в порядке убывания в соответствии с естественным порядком сортировки значения, возвращаемого заданной функцией селектора.
fun <T, R : Comparable<R>> Array<out T>.sortByDescending( selector: (T) -> R?)
Сортирует элементы в списке на месте в порядке убывания в соответствии с естественным порядком сортировки значения, возвращаемого заданной функцией селектора.
fun <T, R : Comparable<R>> MutableList<T>.sortByDescending( selector: (T) -> R?)
sortDescending
Сортирует элементы в массиве по убыванию в соответствии с их естественным порядком сортировки.
fun <T : Comparable<T>> Array<out T>.sortDescending()
fun ByteArray.sortDescending()
fun ShortArray.sortDescending()
fun IntArray.sortDescending()
fun LongArray.sortDescending()
fun FloatArray.sortDescending()
fun DoubleArray.sortDescending()
fun CharArray.sortDescending()
fun UIntArray.sortDescending()
fun ULongArray.sortDescending()
fun UByteArray.sortDescending()
fun UShortArray.sortDescending()
Сортирует элементы массива в указанном диапазоне на месте. Элементы сортируются по убыванию в соответствии с их естественным порядком сортировки.
fun <T : Comparable<T>> Array<out T>.sortDescending( fromIndex: Int, toIndex: Int)
fun ByteArray.sortDescending(fromIndex: Int, toIndex: Int)
fun ShortArray.sortDescending(fromIndex: Int, toIndex: Int)
fun IntArray.sortDescending(fromIndex: Int, toIndex: Int)
fun LongArray.sortDescending(fromIndex: Int, toIndex: Int)
fun FloatArray.sortDescending(fromIndex: Int, toIndex: Int)
fun DoubleArray.sortDescending(fromIndex: Int, toIndex: Int)
fun CharArray.sortDescending(fromIndex: Int, toIndex: Int)
fun UIntArray.sortDescending(fromIndex: Int, toIndex: Int)
fun ULongArray.sortDescending(fromIndex: Int, toIndex: Int)
fun UByteArray.sortDescending(fromIndex: Int, toIndex: Int)
fun UShortArray.sortDescending(fromIndex: Int, toIndex: Int)
Сортирует элементы в списке по убыванию в соответствии с их естественным порядком сортировки.
fun <T : Comparable<T>> MutableList<T>.sortDescending()
sorted
Возвращает список всех элементов, отсортированных в соответствии с их естественным порядком сортировки.
fun <T : Comparable<T>> Array<out T>.sorted(): List<T>
fun ByteArray.sorted(): List<Byte>
fun ShortArray.sorted(): List<Short>
fun IntArray.sorted(): List<Int>
fun LongArray.sorted(): List<Long>
fun FloatArray.sorted(): List<Float>
fun DoubleArray.sorted(): List<Double>
fun CharArray.sorted(): List<Char>
fun <T : Comparable<T>> Iterable<T>.sorted(): List<T>
fun UIntArray.sorted(): List<UInt>
fun ULongArray.sorted(): List<ULong>
fun UByteArray.sorted(): List<UByte>
fun UShortArray.sorted(): List<UShort>
sortedArray
Возвращает массив со всеми элементами этого массива, отсортированными в соответствии с их естественным порядком сортировки.
fun <T : Comparable<T>> Array<T>.sortedArray(): Array<T>
fun ByteArray.sortedArray(): ByteArray
fun ShortArray.sortedArray(): ShortArray
fun IntArray.sortedArray(): IntArray
fun LongArray.sortedArray(): LongArray
fun FloatArray.sortedArray(): FloatArray
fun DoubleArray.sortedArray(): DoubleArray
fun CharArray.sortedArray(): CharArray
fun UIntArray.sortedArray(): UIntArray
fun ULongArray.sortedArray(): ULongArray
fun UByteArray.sortedArray(): UByteArray
fun UShortArray.sortedArray(): UShortArray
sortedArrayDescending
Возвращает массив со всеми элементами этого массива, отсортированными по убыванию в соответствии с их естественным порядком сортировки.
fun <T : Comparable<T>> Array<T>.sortedArrayDescending(): Array<T>
fun ByteArray.sortedArrayDescending(): ByteArray
fun ShortArray.sortedArrayDescending(): ShortArray
fun IntArray.sortedArrayDescending(): IntArray
fun LongArray.sortedArrayDescending(): LongArray
fun FloatArray.sortedArrayDescending(): FloatArray
fun DoubleArray.sortedArrayDescending(): DoubleArray
fun CharArray.sortedArrayDescending(): CharArray
fun UIntArray.sortedArrayDescending(): UIntArray
fun ULongArray.sortedArrayDescending(): ULongArray
fun UByteArray.sortedArrayDescending(): UByteArray
fun UShortArray.sortedArrayDescending(): UShortArray
sortedArrayWith
Возвращает массив со всеми элементами этого массива, отсортированными в соответствии с указанным компаратором.
fun <T> Array<out T>.sortedArrayWith( comparator: Comparator<in T> ): Array<out T>
sortedBy
Возвращает список всех элементов, отсортированных по естественному порядку сортировки значения, возвращаемого указанной функцией-селектором.
fun <T, R : Comparable<R>> Array<out T>.sortedBy( selector: (T) -> R? ): List<T>
fun <R : Comparable<R>> ByteArray.sortedBy( selector: (Byte) -> R? ): List<Byte>
fun <R : Comparable<R>> ShortArray.sortedBy( selector: (Short) -> R? ): List<Short>
fun <R : Comparable<R>> IntArray.sortedBy( selector: (Int) -> R? ): List<Int>
fun <R : Comparable<R>> LongArray.sortedBy( selector: (Long) -> R? ): List<Long>
fun <R : Comparable<R>> FloatArray.sortedBy( selector: (Float) -> R? ): List<Float>
fun <R : Comparable<R>> DoubleArray.sortedBy( selector: (Double) -> R? ): List<Double>
fun <R : Comparable<R>> BooleanArray.sortedBy( selector: (Boolean) -> R? ): List<Boolean>
fun <R : Comparable<R>> CharArray.sortedBy( selector: (Char) -> R? ): List<Char>
fun <T, R : Comparable<R>> Iterable<T>.sortedBy( selector: (T) -> R? ): List<T>
sortedByDescending
Возвращает список всех элементов, отсортированных в обратном порядке по естественному порядку сортировки значения, возвращаемого указанной функцией-селектором.
fun <T, R : Comparable<R>> Array<out T>.sortedByDescending( selector: (T) -> R? ): List<T>
fun <R : Comparable<R>> ByteArray.sortedByDescending( selector: (Byte) -> R? ): List<Byte>
fun <R : Comparable<R>> ShortArray.sortedByDescending( selector: (Short) -> R? ): List<Short>
fun <R : Comparable<R>> IntArray.sortedByDescending( selector: (Int) -> R? ): List<Int>
fun <R : Comparable<R>> LongArray.sortedByDescending( selector: (Long) -> R? ): List<Long>
fun <R : Comparable<R>> FloatArray.sortedByDescending( selector: (Float) -> R? ): List<Float>
fun <R : Comparable<R>> DoubleArray.sortedByDescending( selector: (Double) -> R? ): List<Double>
fun <R : Comparable<R>> BooleanArray.sortedByDescending( selector: (Boolean) -> R? ): List<Boolean>
fun <R : Comparable<R>> CharArray.sortedByDescending( selector: (Char) -> R? ): List<Char>
fun <T, R : Comparable<R>> Iterable<T>.sortedByDescending( selector: (T) -> R? ): List<T>
sortedDescending
Возвращает список всех элементов, отсортированных в обратном порядке по их естественному порядку сортировки.
fun <T : Comparable<T>> Array<out T>.sortedDescending(): List<T>
fun ByteArray.sortedDescending(): List<Byte>
fun ShortArray.sortedDescending(): List<Short>
fun IntArray.sortedDescending(): List<Int>
fun LongArray.sortedDescending(): List<Long>
fun FloatArray.sortedDescending(): List<Float>
fun DoubleArray.sortedDescending(): List<Double>
fun CharArray.sortedDescending(): List<Char>
fun UIntArray.sortedDescending(): List<UInt>
fun ULongArray.sortedDescending(): List<ULong>
fun UByteArray.sortedDescending(): List<UByte>
fun UShortArray.sortedDescending(): List<UShort>
sortedMapOf
Возвращает новый SortedMap с указанным содержимым, представленным в виде списка пар, где первое значение — ключ, а второе — значение.
fun <K : Comparable<K>, V> sortedMapOf( vararg pairs: Pair<K, V> ): SortedMap<K, V>
fun <K, V> sortedMapOf( comparator: Comparator<in K>, vararg pairs: Pair<K, V> ): SortedMap<K, V>
sortedSetOf
Возвращает новый java.util.SortedSet с заданными элементами.
fun <T> sortedSetOf(vararg elements: T): TreeSet<T>
Возвращает новый java.util.SortedSet с заданным компаратором и элементами.
fun <T> sortedSetOf( comparator: Comparator<in T>, vararg elements: T ): TreeSet<T>
sortedWith
Возвращает список всех элементов, отсортированных в соответствии с указанным компаратором.
fun <T> Array<out T>.sortedWith( comparator: Comparator<in T> ): List<T>
fun ByteArray.sortedWith( comparator: Comparator<in Byte> ): List<Byte>
fun ShortArray.sortedWith( comparator: Comparator<in Short> ): List<Short>
fun IntArray.sortedWith( comparator: Comparator<in Int> ): List<Int>
fun LongArray.sortedWith( comparator: Comparator<in Long> ): List<Long>
fun FloatArray.sortedWith( comparator: Comparator<in Float> ): List<Float>
fun DoubleArray.sortedWith( comparator: Comparator<in Double> ): List<Double>
fun BooleanArray.sortedWith( comparator: Comparator<in Boolean> ): List<Boolean>
fun CharArray.sortedWith( comparator: Comparator<in Char> ): List<Char>
fun <T> Iterable<T>.sortedWith( comparator: Comparator<in T> ): List<T>
sortWith
Сортирует массив на месте в соответствии с порядком, заданным данным компаратором.
fun <T> any_array<T>.sortWith(comparator: Comparator<in T>)
Сортирует диапазон в массиве на месте с помощью данного компаратора.
fun <T> any_array<T>.sortWith( comparator: Comparator<in T>, fromIndex: Int = 0, toIndex: Int = size)
Сортирует элементы в списке на месте в соответствии с порядком, заданным компаратором.
fun <T> MutableList<T>.sortWith(comparator: Comparator<in T>)
fun <T> MutableList<T>.sortWith(comparator: Comparator<in T>)
stringMapOf
Создаёт специализированную реализацию HashMap со строковыми ключами, которая хранит ключи как свойства объекта JS без их хеширования.
fun <V> stringMapOf( vararg pairs: Pair<String, V> ): HashMap<String, V>
stringSetOf
Создаёт новый экземпляр специализированной реализации HashSet со строковыми элементами, где элементы хранятся как свойства объекта JS без их хеширования.
fun stringSetOf(vararg elements: String): HashSet<String>
subtract
Возвращает множество, содержащее все элементы, которые присутствуют в этом массиве, но отсутствуют в указанном наборе.
infix fun <T> any_array<T>.subtract( other: Iterable<T> ): Set<T>
Возвращает множество, содержащее все элементы, которые присутствуют в этом наборе, но отсутствуют в указанном наборе.
infix fun <T> Iterable<T>.subtract( other: Iterable<T> ): Set<T>
sum
Возвращает сумму всех элементов в массиве.
fun Array<out Byte>.sum(): Int
fun Array<out Short>.sum(): Int
fun Array<out Int>.sum(): Int
fun Array<out Long>.sum(): Long
fun Array<out Float>.sum(): Float
fun Array<out Double>.sum(): Double
fun ByteArray.sum(): Int
fun ShortArray.sum(): Int
fun IntArray.sum(): Int
fun LongArray.sum(): Long
fun FloatArray.sum(): Float
fun DoubleArray.sum(): Double
fun Array<out UInt>.sum(): UInt
fun Array<out ULong>.sum(): ULong
fun Array<out UByte>.sum(): UInt
fun Array<out UShort>.sum(): UInt
fun UIntArray.sum(): UInt
fun ULongArray.sum(): ULong
fun UByteArray.sum(): UInt
fun UShortArray.sum(): UInt
Возвращает сумму всех элементов в наборе.
fun Iterable<Byte>.sum(): Int
fun Iterable<Short>.sum(): Int
fun Iterable<Int>.sum(): Int
fun Iterable<Long>.sum(): Long
fun Iterable<Float>.sum(): Float
fun Iterable<Double>.sum(): Double
fun Iterable<UInt>.sum(): UInt
fun Iterable<ULong>.sum(): ULong
fun Iterable<UByte>.sum(): UInt
fun Iterable<UShort>.sum(): UInt
sumBy
Возвращает сумму всех значений, полученных функцией selector, применённой к каждому элементу массива.
fun <T> Array<out T>.sumBy(selector: (T) -> Int): Int
fun ByteArray.sumBy(selector: (Byte) -> Int): Int
fun ShortArray.sumBy(selector: (Short) -> Int): Int
fun IntArray.sumBy(selector: (Int) -> Int): Int
fun LongArray.sumBy(selector: (Long) -> Int): Int
fun FloatArray.sumBy(selector: (Float) -> Int): Int
fun DoubleArray.sumBy(selector: (Double) -> Int): Int
fun BooleanArray.sumBy(selector: (Boolean) -> Int): Int
fun CharArray.sumBy(selector: (Char) -> Int): Int
fun UIntArray.sumBy(selector: (UInt) -> UInt): UInt
fun ULongArray.sumBy(selector: (ULong) -> UInt): UInt
fun UByteArray.sumBy(selector: (UByte) -> UInt): UInt
fun UShortArray.sumBy(selector: (UShort) -> UInt): UInt
Возвращает сумму всех значений, полученных функцией selector, применённой к каждому элементу набора.
fun <T> Iterable<T>.sumBy(selector: (T) -> Int): Int
sumByDouble
Возвращает сумму всех значений, полученных функцией selector, применённой к каждому элементу массива.
fun <T> Array<out T>.sumByDouble( selector: (T) -> Double ): Double
fun ByteArray.sumByDouble(selector: (Byte) -> Double): Double
fun ShortArray.sumByDouble( selector: (Short) -> Double ): Double
fun IntArray.sumByDouble(selector: (Int) -> Double): Double
fun LongArray.sumByDouble(selector: (Long) -> Double): Double
fun FloatArray.sumByDouble( selector: (Float) -> Double ): Double
fun DoubleArray.sumByDouble( selector: (Double) -> Double ): Double
fun BooleanArray.sumByDouble( selector: (Boolean) -> Double ): Double
fun UIntArray.sumByDouble(selector: (UInt) -> Double): Double
fun ULongArray.sumByDouble( selector: (ULong) -> Double ): Double
fun UByteArray.sumByDouble( selector: (UByte) -> Double ): Double
fun UShortArray.sumByDouble( selector: (UShort) -> Double ): Double
Возвращает сумму всех значений, полученных функцией selector, применённой к каждому элементу набора.
fun <T> Iterable<T>.sumByDouble( selector: (T) -> Double ): Double
sumOf
Возвращает сумму всех значений, вычисленных функцией selector, применённой к каждому элементу массива.
fun <T> Array<out T>.sumOf(selector: (T) -> Double): Double
fun ByteArray.sumOf(selector: (Byte) -> Double): Double
fun ShortArray.sumOf(selector: (Short) -> Double): Double
fun IntArray.sumOf(selector: (Int) -> Double): Double
fun LongArray.sumOf(selector: (Long) -> Double): Double
fun FloatArray.sumOf(selector: (Float) -> Double): Double
fun DoubleArray.sumOf(selector: (Double) -> Double): Double
fun BooleanArray.sumOf(selector: (Boolean) -> Double): Double
fun CharArray.sumOf(selector: (Char) -> Double): Double
fun <T> Array<out T>.sumOf(selector: (T) -> Int): Int
fun ByteArray.sumOf(selector: (Byte) -> Int): Int
fun ShortArray.sumOf(selector: (Short) -> Int): Int
fun IntArray.sumOf(selector: (Int) -> Int): Int
fun LongArray.sumOf(selector: (Long) -> Int): Int
fun FloatArray.sumOf(selector: (Float) -> Int): Int
fun DoubleArray.sumOf(selector: (Double) -> Int): Int
fun BooleanArray.sumOf(selector: (Boolean) -> Int): Int
fun CharArray.sumOf(selector: (Char) -> Int): Int
fun <T> Array<out T>.sumOf(selector: (T) -> Long): Long
fun ByteArray.sumOf(selector: (Byte) -> Long): Long
fun ShortArray.sumOf(selector: (Short) -> Long): Long
fun IntArray.sumOf(selector: (Int) -> Long): Long
fun LongArray.sumOf(selector: (Long) -> Long): Long
fun FloatArray.sumOf(selector: (Float) -> Long): Long
fun DoubleArray.sumOf(selector: (Double) -> Long): Long
fun BooleanArray.sumOf(selector: (Boolean) -> Long): Long
fun CharArray.sumOf(selector: (Char) -> Long): Long
fun <T> Array<out T>.sumOf(selector: (T) -> UInt): UInt
fun ByteArray.sumOf(selector: (Byte) -> UInt): UInt
fun ShortArray.sumOf(selector: (Short) -> UInt): UInt
fun IntArray.sumOf(selector: (Int) -> UInt): UInt
fun LongArray.sumOf(selector: (Long) -> UInt): UInt
fun FloatArray.sumOf(selector: (Float) -> UInt): UInt
fun DoubleArray.sumOf(selector: (Double) -> UInt): UInt
fun BooleanArray.sumOf(selector: (Boolean) -> UInt): UInt
fun CharArray.sumOf(selector: (Char) -> UInt): UInt
fun <T> Array<out T>.sumOf(selector: (T) -> ULong): ULong
fun ByteArray.sumOf(selector: (Byte) -> ULong): ULong
fun ShortArray.sumOf(selector: (Short) -> ULong): ULong
fun IntArray.sumOf(selector: (Int) -> ULong): ULong
fun LongArray.sumOf(selector: (Long) -> ULong): ULong
fun FloatArray.sumOf(selector: (Float) -> ULong): ULong
fun DoubleArray.sumOf(selector: (Double) -> ULong): ULong
fun BooleanArray.sumOf(selector: (Boolean) -> ULong): ULong
fun CharArray.sumOf(selector: (Char) -> ULong): ULong
fun UIntArray.sumOf(selector: (UInt) -> Double): Double
fun ULongArray.sumOf(selector: (ULong) -> Double): Double
fun UByteArray.sumOf(selector: (UByte) -> Double): Double
fun UShortArray.sumOf(selector: (UShort) -> Double): Double
fun UIntArray.sumOf(selector: (UInt) -> Int): Int
fun ULongArray.sumOf(selector: (ULong) -> Int): Int
fun UByteArray.sumOf(selector: (UByte) -> Int): Int
fun UShortArray.sumOf(selector: (UShort) -> Int): Int
fun UIntArray.sumOf(selector: (UInt) -> Long): Long
fun ULongArray.sumOf(selector: (ULong) -> Long): Long
fun UByteArray.sumOf(selector: (UByte) -> Long): Long
fun UShortArray.sumOf(selector: (UShort) -> Long): Long
fun UIntArray.sumOf(selector: (UInt) -> UInt): UInt
fun ULongArray.sumOf(selector: (ULong) -> UInt): UInt
fun UByteArray.sumOf(selector: (UByte) -> UInt): UInt
fun UShortArray.sumOf(selector: (UShort) -> UInt): UInt
fun UIntArray.sumOf(selector: (UInt) -> ULong): ULong
fun ULongArray.sumOf(selector: (ULong) -> ULong): ULong
fun UByteArray.sumOf(selector: (UByte) -> ULong): ULong
fun UShortArray.sumOf(selector: (UShort) -> ULong): ULong
fun <T> Array<out T>.sumOf( selector: (T) -> BigDecimal ): BigDecimal
fun ByteArray.sumOf( selector: (Byte) -> BigDecimal ): BigDecimal
fun ShortArray.sumOf( selector: (Short) -> BigDecimal ): BigDecimal
fun IntArray.sumOf(selector: (Int) -> BigDecimal): BigDecimal
fun LongArray.sumOf( selector: (Long) -> BigDecimal ): BigDecimal
fun FloatArray.sumOf( selector: (Float) -> BigDecimal ): BigDecimal
fun DoubleArray.sumOf( selector: (Double) -> BigDecimal ): BigDecimal
fun BooleanArray.sumOf( selector: (Boolean) -> BigDecimal ): BigDecimal
fun CharArray.sumOf( selector: (Char) -> BigDecimal ): BigDecimal
fun <T> Array<out T>.sumOf( selector: (T) -> BigInteger ): BigInteger
fun ByteArray.sumOf( selector: (Byte) -> BigInteger ): BigInteger
fun ShortArray.sumOf( selector: (Short) -> BigInteger ): BigInteger
fun IntArray.sumOf(selector: (Int) -> BigInteger): BigInteger
fun LongArray.sumOf( selector: (Long) -> BigInteger ): BigInteger
fun FloatArray.sumOf( selector: (Float) -> BigInteger ): BigInteger
fun DoubleArray.sumOf( selector: (Double) -> BigInteger ): BigInteger
fun BooleanArray.sumOf( selector: (Boolean) -> BigInteger ): BigInteger
fun CharArray.sumOf( selector: (Char) -> BigInteger ): BigInteger
fun UIntArray.sumOf( selector: (UInt) -> BigDecimal ): BigDecimal
fun ULongArray.sumOf( selector: (ULong) -> BigDecimal ): BigDecimal
fun UByteArray.sumOf( selector: (UByte) -> BigDecimal ): BigDecimal
fun UShortArray.sumOf( selector: (UShort) -> BigDecimal ): BigDecimal
fun UIntArray.sumOf( selector: (UInt) -> BigInteger ): BigInteger
fun ULongArray.sumOf( selector: (ULong) -> BigInteger ): BigInteger
fun UByteArray.sumOf( selector: (UByte) -> BigInteger ): BigInteger
fun UShortArray.sumOf( selector: (UShort) -> BigInteger ): BigInteger
Возвращает сумму всех значений, полученных функцией selector, применённой к каждому элементу в коллекции.
fun <T> Iterable<T>.sumOf(selector: (T) -> Double): Double
fun <T> Iterable<T>.sumOf(selector: (T) -> Int): Int
fun <T> Iterable<T>.sumOf(selector: (T) -> Long): Long
fun <T> Iterable<T>.sumOf(selector: (T) -> UInt): UInt
fun <T> Iterable<T>.sumOf(selector: (T) -> ULong): ULong
fun <T> Iterable<T>.sumOf( selector: (T) -> BigDecimal ): BigDecimal
fun <T> Iterable<T>.sumOf( selector: (T) -> BigInteger ): BigInteger
take
Возвращает список, содержащий первые n элементов.
fun <T> Array<out T>.take(n: Int): List<T>
fun ByteArray.take(n: Int): List<Byte>
fun ShortArray.take(n: Int): List<Short>
fun IntArray.take(n: Int): List<Int>
fun LongArray.take(n: Int): List<Long>
fun FloatArray.take(n: Int): List<Float>
fun DoubleArray.take(n: Int): List<Double>
fun BooleanArray.take(n: Int): List<Boolean>
fun CharArray.take(n: Int): List<Char>
fun <T> Iterable<T>.take(n: Int): List<T>
fun UIntArray.take(n: Int): List<UInt>
fun ULongArray.take(n: Int): List<ULong>
fun UByteArray.take(n: Int): List<UByte>
fun UShortArray.take(n: Int): List<UShort>
takeLast
Возвращает список, содержащий последние n элементов.
fun <T> Array<out T>.takeLast(n: Int): List<T>
fun ByteArray.takeLast(n: Int): List<Byte>
fun ShortArray.takeLast(n: Int): List<Short>
fun IntArray.takeLast(n: Int): List<Int>
fun LongArray.takeLast(n: Int): List<Long>
fun FloatArray.takeLast(n: Int): List<Float>
fun DoubleArray.takeLast(n: Int): List<Double>
fun BooleanArray.takeLast(n: Int): List<Boolean>
fun CharArray.takeLast(n: Int): List<Char>
fun <T> List<T>.takeLast(n: Int): List<T>
fun UIntArray.takeLast(n: Int): List<UInt>
fun ULongArray.takeLast(n: Int): List<ULong>
fun UByteArray.takeLast(n: Int): List<UByte>
fun UShortArray.takeLast(n: Int): List<UShort>
takeLastWhile
Возвращает список, содержащий последние элементы, удовлетворяющие заданному
fun <T> Array<out T>.takeLastWhile(
predicate: (T) -> Boolean
): List<T>
fun ByteArray.takeLastWhile( predicate: (Byte) -> Boolean ): List<Byte>
fun ShortArray.takeLastWhile( predicate: (Short) -> Boolean ): List<Short>
fun IntArray.takeLastWhile( predicate: (Int) -> Boolean ): List<Int>
fun LongArray.takeLastWhile( predicate: (Long) -> Boolean ): List<Long>
fun FloatArray.takeLastWhile( predicate: (Float) -> Boolean ): List<Float>
fun DoubleArray.takeLastWhile( predicate: (Double) -> Boolean ): List<Double>
fun BooleanArray.takeLastWhile( predicate: (Boolean) -> Boolean ): List<Boolean>
fun CharArray.takeLastWhile( predicate: (Char) -> Boolean ): List<Char>
fun <T> List<T>.takeLastWhile( predicate: (T) -> Boolean ): List<T>
fun UIntArray.takeLastWhile( predicate: (UInt) -> Boolean ): List<UInt>
fun ULongArray.takeLastWhile( predicate: (ULong) -> Boolean ): List<ULong>
fun UByteArray.takeLastWhile( predicate: (UByte) -> Boolean ): List<UByte>
fun UShortArray.takeLastWhile( predicate: (UShort) -> Boolean ): List<UShort>
takeWhile
Возвращает список, содержащий первые элементы, удовлетворяющие заданному
fun <T> Array<out T>.takeWhile(
predicate: (T) -> Boolean
): List<T>
fun ByteArray.takeWhile( predicate: (Byte) -> Boolean ): List<Byte>
fun ShortArray.takeWhile( predicate: (Short) -> Boolean ): List<Short>
fun IntArray.takeWhile( predicate: (Int) -> Boolean ): List<Int>
fun LongArray.takeWhile( predicate: (Long) -> Boolean ): List<Long>
fun FloatArray.takeWhile( predicate: (Float) -> Boolean ): List<Float>
fun DoubleArray.takeWhile( predicate: (Double) -> Boolean ): List<Double>
fun BooleanArray.takeWhile( predicate: (Boolean) -> Boolean ): List<Boolean>
fun CharArray.takeWhile( predicate: (Char) -> Boolean ): List<Char>
fun <T> Iterable<T>.takeWhile( predicate: (T) -> Boolean ): List<T>
fun UIntArray.takeWhile( predicate: (UInt) -> Boolean ): List<UInt>
fun ULongArray.takeWhile( predicate: (ULong) -> Boolean ): List<ULong>
fun UByteArray.takeWhile( predicate: (UByte) -> Boolean ): List<UByte>
fun UShortArray.takeWhile( predicate: (UShort) -> Boolean ): List<UShort>
toBooleanArray
Возвращает массив Boolean, содержащий все элементы этого массива с типом данных.
fun Array<out Boolean>.toBooleanArray(): BooleanArray
Возвращает массив Boolean, содержащий все элементы этого набора.
fun Collection<Boolean>.toBooleanArray(): BooleanArray
toByteArray
Возвращает массив Byte, содержащий все элементы этого массива с типом данных.
fun Array<out Byte>.toByteArray(): ByteArray
Возвращает массив Byte, содержащий все элементы этого набора.
fun Collection<Byte>.toByteArray(): ByteArray
Возвращает массив типа ByteArray, который является копией этого массива, где каждый элемент является знаковым переосмыслением соответствующего элемента этого массива.
fun UByteArray.toByteArray(): ByteArray
toCharArray
Возвращает массив Char, содержащий все элементы этого массива с типом данных.
fun Array<out Char>.toCharArray(): CharArray
Возвращает массив Char, содержащий все элементы этого набора.
fun Collection<Char>.toCharArray(): CharArray
toCollection
Добавляет все элементы в заданную коллекцию
fun <T, C : MutableCollection<in T>> Array<out T>.toCollection(
destination: C
): C
fun <C : MutableCollection<in Byte>> ByteArray.toCollection( destination: C ): C
fun <C : MutableCollection<in Short>> ShortArray.toCollection( destination: C ): C
fun <C : MutableCollection<in Int>> IntArray.toCollection( destination: C ): C
fun <C : MutableCollection<in Long>> LongArray.toCollection( destination: C ): C
fun <C : MutableCollection<in Float>> FloatArray.toCollection( destination: C ): C
fun <C : MutableCollection<in Double>> DoubleArray.toCollection( destination: C ): C
fun <C : MutableCollection<in Boolean>> BooleanArray.toCollection( destination: C ): C
fun <C : MutableCollection<in Char>> CharArray.toCollection( destination: C ): C
fun <T, C : MutableCollection<in T>> Iterable<T>.toCollection( destination: C ): C
toDoubleArray
Возвращает массив Double, содержащий все элементы этого массива с типом данных.
fun Array<out Double>.toDoubleArray(): DoubleArray
Возвращает массив Double, содержащий все элементы этого набора.
fun Collection<Double>.toDoubleArray(): DoubleArray
toFloatArray
Возвращает массив Float, содержащий все элементы этого массива с типом данных.
fun Array<out Float>.toFloatArray(): FloatArray
Возвращает массив Float, содержащий все элементы этого набора.
fun Collection<Float>.toFloatArray(): FloatArray
toHashSet
Возвращает новый HashSet всех элементов.
fun <T> Array<out T>.toHashSet(): HashSet<T>
fun ByteArray.toHashSet(): HashSet<Byte>
fun ShortArray.toHashSet(): HashSet<Short>
fun IntArray.toHashSet(): HashSet<Int>
fun LongArray.toHashSet(): HashSet<Long>
fun FloatArray.toHashSet(): HashSet<Float>
fun DoubleArray.toHashSet(): HashSet<Double>
fun BooleanArray.toHashSet(): HashSet<Boolean>
fun CharArray.toHashSet(): HashSet<Char>
fun <T> Iterable<T>.toHashSet(): HashSet<T>
toIntArray
Возвращает массив Int, содержащий все элементы этого обобщенного массива.
fun Array<out Int>.toIntArray(): IntArray
Возвращает массив Int, содержащий все элементы этого набора.
fun Collection<Int>.toIntArray(): IntArray
Возвращает массив типа IntArray, который является копией этого массива, где каждый элемент представляет собой знаковое переосмысление соответствующего элемента этого массива.
fun UIntArray.toIntArray(): IntArray
toList
Возвращает List, содержащую все элементы.
fun <T> Array<out T>.toList(): List<T>
fun ByteArray.toList(): List<Byte>
fun ShortArray.toList(): List<Short>
fun IntArray.toList(): List<Int>
fun LongArray.toList(): List<Long>
fun FloatArray.toList(): List<Float>
fun DoubleArray.toList(): List<Double>
fun BooleanArray.toList(): List<Boolean>
fun CharArray.toList(): List<Char>
fun <T> Iterable<T>.toList(): List<T>
Возвращает List, содержащую все пары ключ-значение.
fun <K, V> Map<out K, V>.toList(): List<Pair<K, V>>
toLongArray
Возвращает массив Long, содержащий все элементы этого обобщенного массива.
fun Array<out Long>.toLongArray(): LongArray
Возвращает массив Long, содержащий все элементы этого набора.
fun Collection<Long>.toLongArray(): LongArray
Возвращает массив типа LongArray, который является копией этого массива, где каждый элемент представляет собой знаковое переосмысление соответствующего элемента этого массива.
fun ULongArray.toLongArray(): LongArray
toMap
Возвращает новый map, содержащий все пары ключ-значение из заданного набора пар.
fun <K, V> Iterable<Pair<K, V>>.toMap(): Map<K, V>
Заполняет и возвращает destination изменяемый map парами ключ-значение из заданного набора пар.
fun <K, V, M : MutableMap<in K, in V>> Iterable<Pair<K, V>>.toMap( destination: M ): M
Возвращает новый map, содержащий все пары ключ-значение из заданного массива пар.
fun <K, V> Array<out Pair<K, V>>.toMap(): Map<K, V>
Заполняет и возвращает destination изменяемый map парами ключ-значение из заданного массива пар.
fun <K, V, M : MutableMap<in K, in V>> Array<out Pair<K, V>>.toMap( destination: M ): M
Возвращает новый map, содержащий все пары ключ-значение из заданной последовательности пар.
fun <K, V> Sequence<Pair<K, V>>.toMap(): Map<K, V>
Заполняет и возвращает destination изменяемый map парами ключ-значение из заданной последовательности пар.
fun <K, V, M : MutableMap<in K, in V>> Sequence<Pair<K, V>>.toMap( destination: M ): M
Возвращает новый неизменяемый map, содержащий все пары ключ-значение из исходного map.
fun <K, V> Map<out K, V>.toMap(): Map<K, V>
Заполняет и возвращает destination изменяемый map парами ключ-значение из заданного map.
fun <K, V, M : MutableMap<in K, in V>> Map<out K, V>.toMap( destination: M ): M
toMutableList
Возвращает новый MutableList, заполненный всеми элементами этого массива.
fun <T> any_array<T>.toMutableList(): MutableList<T>
Возвращает новый MutableList, заполненный всеми элементами этого набора.
fun <T> Iterable<T>.toMutableList(): MutableList<T>
fun <T> Collection<T>.toMutableList(): MutableList<T>
toMutableMap
Возвращает новый изменяемый map, содержащий все пары ключ-значение из исходного map.
fun <K, V> Map<out K, V>.toMutableMap(): MutableMap<K, V>
toMutableSet
Возвращает новый MutableSet, содержащий все уникальные элементы из заданного массива.
fun <T> any_array<T>.toMutableSet(): MutableSet<T>
Возвращает новый MutableSet, содержащий все уникальные элементы из заданной коллекции.
fun <T> Iterable<T>.toMutableSet(): MutableSet<T>
toPair
Преобразует запись в Pair, где ключ — первый компонент, а значение — второй.
fun <K, V> Entry<K, V>.toPair(): Pair<K, V>
toProperties
Преобразует этот Map в объект Properties.
fun Map<String, String>.toProperties(): Properties
toSet
Возвращает Set всех элементов.
fun <T> Array<out T>.toSet(): Set<T>
fun ByteArray.toSet(): Set<Byte>
fun ShortArray.toSet(): Set<Short>
fun IntArray.toSet(): Set<Int>
fun LongArray.toSet(): Set<Long>
fun FloatArray.toSet(): Set<Float>
fun DoubleArray.toSet(): Set<Double>
fun BooleanArray.toSet(): Set<Boolean>
fun CharArray.toSet(): Set<Char>
fun <T> Iterable<T>.toSet(): Set<T>
toShortArray
Возвращает массив Short, содержащий все элементы этого обобщенного массива.
fun Array<out Short>.toShortArray(): ShortArray
Возвращает массив Short, содержащий все элементы этой коллекции.
fun Collection<Short>.toShortArray(): ShortArray
Возвращает массив типа ShortArray, который является копией этого массива, где каждый элемент — знаковое переинтерпретированное соответствие элементу этого массива.
fun UShortArray.toShortArray(): ShortArray
toSortedMap
Преобразует этот Map в SortedMap. Полученный SortedMap определяет равенство и порядок ключей в соответствии с их естественным порядком сортировки.
fun <K : Comparable<K>, V> Map<out K, V>.toSortedMap(): SortedMap<K, V>
Преобразует этот Map в SortedMap. Полученный SortedMap определяет равенство и порядок ключей в соответствии с порядком сортировки, заданным данным компаратором.
fun <K, V> Map<out K, V>.toSortedMap( comparator: Comparator<in K> ): SortedMap<K, V>
toSortedSet
Возвращает новый SortedSet всех элементов.
fun <T : Comparable<T>> Array<out T>.toSortedSet(): SortedSet<T>
fun ByteArray.toSortedSet(): SortedSet<Byte>
fun ShortArray.toSortedSet(): SortedSet<Short>
fun IntArray.toSortedSet(): SortedSet<Int>
fun LongArray.toSortedSet(): SortedSet<Long>
fun FloatArray.toSortedSet(): SortedSet<Float>
fun DoubleArray.toSortedSet(): SortedSet<Double>
fun BooleanArray.toSortedSet(): SortedSet<Boolean>
fun CharArray.toSortedSet(): SortedSet<Char>
fun <T> Array<out T>.toSortedSet( comparator: Comparator<in T> ): SortedSet<T>
fun <T : Comparable<T>> Iterable<T>.toSortedSet(): SortedSet<T>
fun <T> Iterable<T>.toSortedSet( comparator: Comparator<in T> ): SortedSet<T>
toString
Преобразует содержимое этого массива байтов в строку, используя указанный charset.
fun ByteArray.toString(charset: Charset): String
toTypedArray
Возвращает массив типизированных объектов, содержащий все элементы этого примитивного массива.
fun UIntArray.toTypedArray(): Array<UInt>
fun ULongArray.toTypedArray(): Array<ULong>
fun UByteArray.toTypedArray(): Array<UByte>
fun UShortArray.toTypedArray(): Array<UShort>
fun ByteArray.toTypedArray(): Array<Byte>
fun ShortArray.toTypedArray(): Array<Short>
fun IntArray.toTypedArray(): Array<Int>
fun LongArray.toTypedArray(): Array<Long>
fun FloatArray.toTypedArray(): Array<Float>
fun DoubleArray.toTypedArray(): Array<Double>
fun BooleanArray.toTypedArray(): Array<Boolean>
fun CharArray.toTypedArray(): Array<Char>
Возвращает массив типизированных элементов, содержащий все элементы этой коллекции.
fun <T> Collection<T>.toTypedArray(): Array<T>
toUByteArray
Возвращает массив UByte, содержащий все элементы этого обобщённого массива.
fun Array<out UByte>.toUByteArray(): UByteArray
Возвращает массив типа UByteArray, который является копией этого массива, где каждый элемент — это беззнаковое переосмысление соответствующего элемента этого массива.
fun ByteArray.toUByteArray(): UByteArray
Возвращает массив UByte, содержащий все элементы этого набора.
fun Collection<UByte>.toUByteArray(): UByteArray
toUIntArray
Возвращает массив UInt, содержащий все элементы этого обобщённого массива.
fun Array<out UInt>.toUIntArray(): UIntArray
Возвращает массив типа UIntArray, который является копией этого массива, где каждый элемент — это беззнаковое переосмысление соответствующего элемента этого массива.
fun IntArray.toUIntArray(): UIntArray
Возвращает массив UInt, содержащий все элементы этого набора.
fun Collection<UInt>.toUIntArray(): UIntArray
toULongArray
Возвращает массив ULong, содержащий все элементы этого обобщённого массива.
fun Array<out ULong>.toULongArray(): ULongArray
Возвращает массив типа ULongArray, который является копией этого массива, где каждый элемент — это беззнаковое переосмысление соответствующего элемента этого массива.
fun LongArray.toULongArray(): ULongArray
Возвращает массив ULong, содержащий все элементы этого набора.
fun Collection<ULong>.toULongArray(): ULongArray
toUShortArray
Возвращает массив UShort, содержащий все элементы этого обобщённого массива.
fun Array<out UShort>.toUShortArray(): UShortArray
Возвращает массив типа UShortArray, который является копией этого массива, где каждый элемент — это беззнаковое переосмысление соответствующего элемента этого массива.
fun ShortArray.toUShortArray(): UShortArray
Возвращает массив UShort, содержащий все элементы этого набора.
fun Collection<UShort>.toUShortArray(): UShortArray
union
Возвращает множество, содержащее все уникальные элементы из обоих наборов.
infix fun <T> Array<out T>.union(other: Iterable<T>): Set<T>
infix fun ByteArray.union(other: Iterable<Byte>): Set<Byte>
infix fun ShortArray.union( other: Iterable<Short> ): Set<Short>
infix fun IntArray.union(other: Iterable<Int>): Set<Int>
infix fun LongArray.union(other: Iterable<Long>): Set<Long>
infix fun FloatArray.union( other: Iterable<Float> ): Set<Float>
infix fun DoubleArray.union( other: Iterable<Double> ): Set<Double>
infix fun BooleanArray.union( other: Iterable<Boolean> ): Set<Boolean>
infix fun CharArray.union(other: Iterable<Char>): Set<Char>
infix fun <T> Iterable<T>.union(other: Iterable<T>): Set<T>
unzip
Возвращает пару списков, где список first создаётся из первых значений каждой пары из этого массива, список second — из вторых значений каждой пары из этого массива.
fun <T, R> Array<out Pair<T, R>>.unzip(): Pair<List<T>, List<R>>
Возвращает пару списков, где список first создаётся из первых значений каждой пары из этого набора, список second — из вторых значений каждой пары из этого набора.
fun <T, R> Iterable<Pair<T, R>>.unzip(): Pair<List<T>, List<R>>
windowed
Возвращает список снимков окна заданного размера, скользящего по этому набору с заданным шагом, где каждый снимок — список.
fun <T> Iterable<T>.windowed( size: Int, step: Int = 1, partialWindows: Boolean = false ): List<List<T>>
Возвращает список результатов применения заданной функции преобразования к каждому списку, представляющему просмотр окна заданного размера, скользящего по этому набору с заданным шагом.
fun <T, R> Iterable<T>.windowed( size: Int, step: Int = 1, partialWindows: Boolean = false, transform: (List<T>) -> R ): List<R>
withDefault
Возвращает оболочку этого неизменяемого отображения, имеющего неявное значение по умолчанию, предоставленное с помощью указанной функции defaultValue.
fun <K, V> Map<K, V>.withDefault( defaultValue: (key: K) -> V ): Map<K, V>
Возвращает оболочку этого изменяемого отображения, имеющего неявное значение по умолчанию, предоставленное с помощью указанной функции defaultValue.
fun <K, V> MutableMap<K, V>.withDefault( defaultValue: (key: K) -> V ): MutableMap<K, V>
withIndex
Возвращает ленивое Iterable, которое оборачивает каждый элемент исходного массива в IndexedValue, содержащий индекс этого элемента и сам элемент.
fun <T> Array<out T>.withIndex(): Iterable<IndexedValue<T>>
fun ByteArray.withIndex(): Iterable<IndexedValue<Byte>>
fun ShortArray.withIndex(): Iterable<IndexedValue<Short>>
fun IntArray.withIndex(): Iterable<IndexedValue<Int>>
fun LongArray.withIndex(): Iterable<IndexedValue<Long>>
fun FloatArray.withIndex(): Iterable<IndexedValue<Float>>
fun DoubleArray.withIndex(): Iterable<IndexedValue<Double>>
fun BooleanArray.withIndex(): Iterable<IndexedValue<Boolean>>
fun CharArray.withIndex(): Iterable<IndexedValue<Char>>
fun UIntArray.withIndex(): Iterable<IndexedValue<UInt>>
fun ULongArray.withIndex(): Iterable<IndexedValue<ULong>>
fun UByteArray.withIndex(): Iterable<IndexedValue<UByte>>
fun UShortArray.withIndex(): Iterable<IndexedValue<UShort>>
Возвращает ленивое Iterable, которое оборачивает каждый элемент исходного набора в IndexedValue, содержащий индекс этого элемента и сам элемент.
fun <T> Iterable<T>.withIndex(): Iterable<IndexedValue<T>>
Возвращает Iterator, который оборачивает каждый элемент, производимый исходным итератором, в IndexedValue, содержащий индекс этого элемента и сам элемент.
fun <T> Iterator<T>.withIndex(): Iterator<IndexedValue<T>>
zip
Возвращает список пар, составленных из элементов массива this и массива other с тем же индексом. Возвращаемый список имеет длину самого короткого из массивов.
infix fun <T, R> Array<out T>.zip( other: Array<out R> ): List<Pair<T, R>>
infix fun <R> ByteArray.zip( other: Array<out R> ): List<Pair<Byte, R>>
infix fun <R> ShortArray.zip( other: Array<out R> ): List<Pair<Short, R>>
infix fun <R> IntArray.zip( other: Array<out R> ): List<Pair<Int, R>>
infix fun <R> LongArray.zip( other: Array<out R> ): List<Pair<Long, R>>
infix fun <R> FloatArray.zip( other: Array<out R> ): List<Pair<Float, R>>
infix fun <R> DoubleArray.zip( other: Array<out R> ): List<Pair<Double, R>>
infix fun <R> BooleanArray.zip( other: Array<out R> ): List<Pair<Boolean, R>>
infix fun <R> CharArray.zip( other: Array<out R> ): List<Pair<Char, R>>
infix fun ByteArray.zip( other: ByteArray ): List<Pair<Byte, Byte>>
infix fun ShortArray.zip( other: ShortArray ): List<Pair<Short, Short>>
infix fun IntArray.zip(other: IntArray): List<Pair<Int, Int>>
infix fun LongArray.zip( other: LongArray ): List<Pair<Long, Long>>
infix fun FloatArray.zip( other: FloatArray ): List<Pair<Float, Float>>
infix fun DoubleArray.zip( other: DoubleArray ): List<Pair<Double, Double>>
infix fun BooleanArray.zip( other: BooleanArray ): List<Pair<Boolean, Boolean>>
infix fun CharArray.zip( other: CharArray ): List<Pair<Char, Char>>
infix fun <R> UIntArray.zip( other: Array<out R> ): List<Pair<UInt, R>>
infix fun <R> ULongArray.zip( other: Array<out R> ): List<Pair<ULong, R>>
infix fun <R> UByteArray.zip( other: Array<out R> ): List<Pair<UByte, R>>
infix fun <R> UShortArray.zip( other: Array<out R> ): List<Pair<UShort, R>>
infix fun UIntArray.zip( other: UIntArray ): List<Pair<UInt, UInt>>
infix fun ULongArray.zip( other: ULongArray ): List<Pair<ULong, ULong>>
infix fun UByteArray.zip( other: UByteArray ): List<Pair<UByte, UByte>>
infix fun UShortArray.zip( other: UShortArray ): List<Pair<UShort, UShort>>
Возвращает список значений, созданных из элементов массива this и массива other с тем же индексом с применением предоставленной функции transform к каждой паре элементов. Возвращаемый список имеет длину самого короткого из массивов.
fun <T, R, V> Array<out T>.zip( other: Array<out R>, transform: (a: T, b: R) -> V ): List<V>
fun <R, V> ByteArray.zip( other: Array<out R>, transform: (a: Byte, b: R) -> V ): List<V>
fun <R, V> ShortArray.zip( other: Array<out R>, transform: (a: Short, b: R) -> V ): List<V>
fun <R, V> IntArray.zip( other: Array<out R>, transform: (a: Int, b: R) -> V ): List<V>
fun <R, V> LongArray.zip( other: Array<out R>, transform: (a: Long, b: R) -> V ): List<V>
fun <R, V> FloatArray.zip( other: Array<out R>, transform: (a: Float, b: R) -> V ): List<V>
fun <R, V> DoubleArray.zip( other: Array<out R>, transform: (a: Double, b: R) -> V ): List<V>
fun <R, V> BooleanArray.zip( other: Array<out R>, transform: (a: Boolean, b: R) -> V ): List<V>
fun <R, V> CharArray.zip( other: Array<out R>, transform: (a: Char, b: R) -> V ): List<V>
fun <R, V> UIntArray.zip( other: Array<out R>, transform: (a: UInt, b: R) -> V ): List<V>
fun <R, V> ULongArray.zip( other: Array<out R>, transform: (a: ULong, b: R) -> V ): List<V>
fun <R, V> UByteArray.zip( other: Array<out R>, transform: (a: UByte, b: R) -> V ): List<V>
fun <R, V> UShortArray.zip( other: Array<out R>, transform: (a: UShort, b: R) -> V ): List<V>
Возвращает список пар, составленных из элементов this коллекции и массива other с тем же индексом. Возвращаемый список имеет длину самого короткого из коллекций.
infix fun <T, R> Array<out T>.zip( other: Iterable<R> ): List<Pair<T, R>>
infix fun <R> ByteArray.zip( other: Iterable<R> ): List<Pair<Byte, R>>
infix fun <R> ShortArray.zip( other: Iterable<R> ): List<Pair<Short, R>>
infix fun <R> IntArray.zip( other: Iterable<R> ): List<Pair<Int, R>>
infix fun <R> LongArray.zip( other: Iterable<R> ): List<Pair<Long, R>>
infix fun <R> FloatArray.zip( other: Iterable<R> ): List<Pair<Float, R>>
infix fun <R> DoubleArray.zip( other: Iterable<R> ): List<Pair<Double, R>>
infix fun <R> BooleanArray.zip( other: Iterable<R> ): List<Pair<Boolean, R>>
infix fun <R> CharArray.zip( other: Iterable<R> ): List<Pair<Char, R>>
infix fun <R> UIntArray.zip( other: Iterable<R> ): List<Pair<UInt, R>>
infix fun <R> ULongArray.zip( other: Iterable<R> ): List<Pair<ULong, R>>
infix fun <R> UByteArray.zip( other: Iterable<R> ): List<Pair<UByte, R>>
infix fun <R> UShortArray.zip( other: Iterable<R> ): List<Pair<UShort, R>>
Возвращает список значений, созданных из элементов массива this и коллекции other с тем же индексом с применением предоставленной функции transform к каждой паре элементов. Возвращаемый список имеет длину самой короткой коллекции.
fun <T, R, V> Array<out T>.zip( other: Iterable<R>, transform: (a: T, b: R) -> V ): List<V>
fun <R, V> ByteArray.zip( other: Iterable<R>, transform: (a: Byte, b: R) -> V ): List<V>
fun <R, V> ShortArray.zip( other: Iterable<R>, transform: (a: Short, b: R) -> V ): List<V>
fun <R, V> IntArray.zip( other: Iterable<R>, transform: (a: Int, b: R) -> V ): List<V>
fun <R, V> LongArray.zip( other: Iterable<R>, transform: (a: Long, b: R) -> V ): List<V>
fun <R, V> FloatArray.zip( other: Iterable<R>, transform: (a: Float, b: R) -> V ): List<V>
fun <R, V> DoubleArray.zip( other: Iterable<R>, transform: (a: Double, b: R) -> V ): List<V>
fun <R, V> BooleanArray.zip( other: Iterable<R>, transform: (a: Boolean, b: R) -> V ): List<V>
fun <R, V> CharArray.zip( other: Iterable<R>, transform: (a: Char, b: R) -> V ): List<V>
fun <R, V> UIntArray.zip( other: Iterable<R>, transform: (a: UInt, b: R) -> V ): List<V>
fun <R, V> ULongArray.zip( other: Iterable<R>, transform: (a: ULong, b: R) -> V ): List<V>
fun <R, V> UByteArray.zip( other: Iterable<R>, transform: (a: UByte, b: R) -> V ): List<V>
fun <R, V> UShortArray.zip( other: Iterable<R>, transform: (a: UShort, b: R) -> V ): List<V>
Возвращает список значений, построенных из элементов массива this и массива other с тем же индексом, используя предоставленную функцию transform, применённую к каждой паре элементов. Возвращаемый список имеет длину самого короткого массива.
fun <V> ByteArray.zip( other: ByteArray, transform: (a: Byte, b: Byte) -> V ): List<V>
fun <V> ShortArray.zip( other: ShortArray, transform: (a: Short, b: Short) -> V ): List<V>
fun <V> IntArray.zip( other: IntArray, transform: (a: Int, b: Int) -> V ): List<V>
fun <V> LongArray.zip( other: LongArray, transform: (a: Long, b: Long) -> V ): List<V>
fun <V> FloatArray.zip( other: FloatArray, transform: (a: Float, b: Float) -> V ): List<V>
fun <V> DoubleArray.zip( other: DoubleArray, transform: (a: Double, b: Double) -> V ): List<V>
fun <V> BooleanArray.zip( other: BooleanArray, transform: (a: Boolean, b: Boolean) -> V ): List<V>
fun <V> CharArray.zip( other: CharArray, transform: (a: Char, b: Char) -> V ): List<V>
fun <V> UIntArray.zip( other: UIntArray, transform: (a: UInt, b: UInt) -> V ): List<V>
fun <V> ULongArray.zip( other: ULongArray, transform: (a: ULong, b: ULong) -> V ): List<V>
fun <V> UByteArray.zip( other: UByteArray, transform: (a: UByte, b: UByte) -> V ): List<V>
fun <V> UShortArray.zip( other: UShortArray, transform: (a: UShort, b: UShort) -> V ): List<V>
Возвращает список пар, построенных из элементов коллекции this и массива other с тем же индексом. Возвращаемый список имеет длину самой короткой коллекции.
infix fun <T, R> Iterable<T>.zip( other: Array<out R> ): List<Pair<T, R>>
Возвращает список значений, построенных из элементов коллекции this и массива other с тем же индексом, используя предоставленную функцию transform, применённую к каждой паре элементов. Возвращаемый список имеет длину самой короткой коллекции.
fun <T, R, V> Iterable<T>.zip( other: Array<out R>, transform: (a: T, b: R) -> V ): List<V>
Возвращает список пар, построенных из элементов коллекции this и коллекции other с тем же индексом. Возвращаемый список имеет длину самой короткой коллекции.
infix fun <T, R> Iterable<T>.zip( other: Iterable<R> ): List<Pair<T, R>>
Возвращает список значений, построенных из элементов коллекции this и коллекции other с тем же индексом, используя предоставленную функцию transform, применённую к каждой паре элементов. Возвращаемый список имеет длину самой короткой коллекции.
fun <T, R, V> Iterable<T>.zip( other: Iterable<R>, transform: (a: T, b: R) -> V ): List<V>
zipWithNext
Возвращает список пар из двух соседних элементов в этой коллекции.
fun <T> Iterable<T>.zipWithNext(): List<Pair<T, T>>
Возвращает список, содержащий результаты применения данной функции transform к каждой паре двух соседних элементов в этой коллекции.
fun <T, R> Iterable<T>.zipWithNext( transform: (a: T, b: T) -> R ): List<R>
© 2010–2023 JetBrains s.r.o. and Kotlin Programming Language contributors
Licensed under the Apache License, Version 2.0.
https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/index.html
