SparseArrayCompat

<E : Any?> SparseArrayCompat(initialCapacity: Int = 10)

Creates a new SparseArray containing no mappings that will not require any additional memory allocation to store the specified number of mappings. If you supply an initial capacity of 0, the sparse array will be initialized with a light-weight representation not requiring any additional array allocations.

open fun append(key: Int, value: E): Unit

Puts a key/value pair into the array, optimizing for the case where the key is greater than all existing keys in the array.

open fun clear(): Unit

Removes all key-value mappings from this SparseArray.

open fun containsKey(key: Int): Boolean

Returns true if the specified key is mapped.

open fun containsValue(value: E): Boolean

Returns true if the specified value is mapped from any key.

open operator fun get(key: Int): E?

Gets the Object mapped from the specified key, or null if no such mapping has been made.

open fun get(key: Int, defaultValue: E): E

Gets the Object mapped from the specified key, or defaultValue if no such mapping has been made.

open fun indexOfKey(key: Int): Int

Returns the index for which keyAt would return the specified key, or a negative number if the specified key is not mapped.

open fun indexOfValue(value: E): Int

Returns an index for which valueAt would return the specified key, or a negative number if no keys map to the specified value.

Beware that this is a linear search, unlike lookups by key, and that multiple keys can map to the same value and this will find only one of them.

Note also that unlike most collections' indexOf methods, this method compares values using === rather than equals.

open fun isEmpty(): Boolean

Return true if size is 0.

open fun keyAt(index: Int): Int

Given an index in the range 0...size()-1, returns the key from the indexth key-value mapping that this SparseArray stores.

open fun put(key: Int, value: E): Unit

Adds a mapping from the specified key to the specified value, replacing the previous mapping from the specified key if there was one.

open fun putAll(other: SparseArrayCompat<E>): Unit

Copies all of the mappings from the other to this map. The effect of this call is equivalent to that of calling put on this map once for each mapping from key to value in other.

open fun putIfAbsent(key: Int, value: E): E?

Add a new value to the array map only if the key does not already have a value or it is mapped to null.

open fun remove(key: Int): Unit

Removes the mapping from the specified key, if there was any.

open fun remove(key: Int, value: Any?): Boolean

Remove an existing key from the array map only if it is currently mapped to value.

open fun removeAt(index: Int): Unit

Removes the mapping at the specified index.

open fun removeAtRange(index: Int, size: Int): Unit

Remove a range of mappings as a batch.

open fun replace(key: Int, value: E): E?

Replace the mapping for key only if it is already mapped to a value.

open fun replace(key: Int, oldValue: E, newValue: E): Boolean

Replace the mapping for key only if it is already mapped to a value.

open fun setValueAt(index: Int, value: E): Unit

Given an index in the range 0...size()-1, sets a new value for the indexth key-value mapping that this SparseArray stores.

open fun size(): Int

Returns the number of key-value mappings that this SparseArray currently stores.

open fun toString(): String

Returns a string representation of the object.

This implementation composes a string by iterating over its mappings. If this map contains itself as a value, the string "(this Map)" will appear in its place.

open fun valueAt(index: Int): E

Given an index in the range 0...size()-1, returns the value from the indexth key-value mapping that this SparseArray stores.

val isEmpty: Boolean

Return true if size is 0.

inline operator fun <T : Any?> SparseArrayCompat<T>.contains(key: Int): Boolean

Returns true if the collection contains key.

inline fun <T : Any?> SparseArrayCompat<T>.forEach(action: (key: Int, value) -> Unit): Unit

Performs the given action for each key/value entry.

inline fun <T : Any?> SparseArrayCompat<T>.getOrDefault(key: Int, defaultValue: T): T

Return the value corresponding to key, or defaultValue when not present.

inline fun <T : Any?> SparseArrayCompat<T>.getOrElse(key: Int, defaultValue: () -> T): T

Return the value corresponding to key, or from defaultValue when not present.

inline fun <T : Any?> SparseArrayCompat<T>.isNotEmpty(): Boolean

Return true when the collection contains elements.

fun <T : Any?> SparseArrayCompat<T>.keyIterator(): IntIterator

Return an iterator over the collection's keys.

operator fun <T : Any?> SparseArrayCompat<T>.plus(other: SparseArrayCompat<T>): SparseArrayCompat<T>

Creates a new collection by adding or replacing entries from other.

inline operator fun <T : Any?> SparseArrayCompat<T>.set(key: Int, value: T): Unit

Allows the use of the index operator for storing values in the collection.

fun <T : Any?> SparseArrayCompat<T>.valueIterator(): Iterator<T>

Return an iterator over the collection's values.

val SparseArrayCompat<T>.size: Int

Returns the number of key/value pairs in the collection.