collections/dev.funkymuse.collections

Package-level declarations

Properties

arrayList

val <E> List<E>?.arrayList: ArrayList<E>

half

val Collection<*>.half: Int

isBinarySearchable

val List<Int>.isBinarySearchable: Boolean

isNotNullOrEmpty

val <T> Collection<T>?.isNotNullOrEmpty: Boolean

midIndex

val <T> ArrayList<T>.midIndex: Int

val <T> List<T>.midIndex: Int

get mid index of a list

values

val <T> SparseArray<T>.values: List<T>

Returns a list containing all values in a SparseArray.

Functions

addAll

fun <T> MutableCollection<T>.addAll(vararg items: T)

addAnd

fun <S : MutableCollection<T>, T> S.addAnd(item: T): S

fun <S : MutableList<T>, T> S.addAnd(index: Int, item: T): S

addIfNotExist

infix fun <E> ArrayList<E>.addIfNotExist(obj: E): Boolean

Adds E to this list if the same doesn't exist

infix fun <E> MutableList<E>.addIfNotExist(obj: E): Boolean

Adds E to this list if the same doesn't previously exist. so

fun <K, E> HashMap<K, E>.addIfNotExist(key: K, obj: E): E?

fun <K, E> MutableMap<K, E>.addIfNotExist(key: K, obj: E): E?

Adds E to this map if the same doesn't exist

addOrRemove

fun <T> MutableCollection<T>.addOrRemove(item: T): Boolean

Adds the item if it is not in the collection or removes it if it is.

addOrReplace

fun <T> MutableList<T>.addOrReplace(item: T, predicate: (T) -> Boolean): Boolean

Replaces the first item within the list that matches the given predicate or adds the item to the list if none match.

addToList

inline fun <T> T.addToList(list: MutableList<T>): T

allNull

fun <T> Collection<T?>.allNull(): Boolean

anyNull

fun <T> Collection<T?>.anyNull(): Boolean

appendTo

infix fun <T> T.appendTo(list: List<T>): List<T>

arrayDequeOf

fun <T> arrayDequeOf(): ArrayDeque<T>

Returns an empty new ArrayDeque.

fun <T> arrayDequeOf(vararg elements: T): ArrayDeque<T>

Returns a new ArrayDeque with the given elements.

associateBy

inline fun <V> Iterable<V>.associateBy(keySelector: (V) -> Int): SparseArray<V>

Populates and returns a SparseArray by populating with keys provided by keySelector and values that are the elements themselves.

inline fun <T, V> Iterable<T>.associateBy(keySelector: (T) -> Int, valueTransform: (T) -> V): SparseArray<V>

Populates and returns a SparseArray by populating with keys provided by keySelector and values provided by valueTransform.

associateByTo

inline fun <V, M : SparseArray<in V>> Iterable<V>.associateByTo(destination: M, keySelector: (V) -> Int): M

Populates and returns the destination array by populating with keys provided by keySelector and values that are the elements themselves.

inline fun <T, V, M : SparseArray<in V>> Iterable<T>.associateByTo(destination: M, keySelector: (T) -> Int, valueTransform: (T) -> V): M

Populates and returns the destination array by populating with keys provided by keySelector and values provided by valueTransform.

combinations

fun <T> combinations(vararg listOfList: List<T>): List<List<T>>

@JvmName(name = "combinations")

fun <A, B> combinations(listA: List<A>, listB: List<B>): List<Pair<A, B>>

@JvmName(name = "combinations")

fun <A, B, C> combinations(listA: List<A>, listB: List<B>, listC: List<C>): List<Triple<A, B, C>>

combinations

@JvmName(name = "combinationsExtension")

fun <A, B> List<A>.combinations(listB: List<B>): List<Pair<A, B>>

@JvmName(name = "combinationsExtension")

fun <A, B, C> List<A>.combinations(listB: List<B>, listC: List<C>): List<Triple<A, B, C>>

combine

fun <T1, T2> Iterable<T1>.combine(other: Iterable<T2>): List<Pair<T1, T2>>

inline fun <T1, T2, R> Iterable<T1>.combine(other: Iterable<T2>, transform: (thisItem: T1, otherItem: T2) -> R): List<R>

combineToMutableList

fun <T1, T2> Iterable<T1>.combineToMutableList(other: Iterable<T2>): MutableList<Pair<T1, T2>>

inline fun <T1, T2, R> Iterable<T1>.combineToMutableList(other: Iterable<T2>, transform: (thisItem: T1, otherItem: T2) -> R): MutableList<R>

compose

fun <T, S> MutableList<T>.compose(mixList: List<S>, mixFilter: (T, S) -> Boolean, mixOperate: (T?, S) -> T, removeCannotMix: Boolean = true)

concat

fun <T> List<List<T>>.concat(): List<T>

concatToMutableList

fun <T> List<List<T>>.concatToMutableList(): MutableList<T>

contains

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

Returns true if an element matching the given predicate was found.

containsIgnoreCase

fun Array<String>.containsIgnoreCase(element: String): Boolean

Checks if element is contained (ignoring case) by the array

count

fun count(start: Byte, step: Byte = 1): Sequence<Byte>

fun count(start: Double, step: Double = 1.0): Sequence<Double>

fun count(start: Float, step: Float = 1.0f): Sequence<Float>

fun count(start: Int, step: Int = 1): Sequence<Int>

fun count(start: Long, step: Long = 1): Sequence<Long>

fun count(start: Short, step: Short = 1): Sequence<Short>

Make an iterator that returns values starting with start with evenly space step.

inline fun <T> count(start: T, step: T, crossinline add: (T, T) -> T): Sequence<T>

countNonNulls

fun <T> Collection<T?>.countNonNulls(): Int

countNulls

fun <T> Collection<T?>.countNulls(): Int

cycle

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

Make an iterator returning elements from the iterable and saving a copy of each. When the iterable is exhausted, return elements from the saved copy. Repeats indefinitely.

deepCopy

fun <K, V> MutableMap<K, MutableList<V>>.deepCopy(): MutableMap<K, MutableList<V>>

dequeOf

fun <T> dequeOf(): Deque<T>

Returns an empty new Deque.

fun <T> dequeOf(vararg elements: T): Deque<T>

Returns a new Deque with the given elements.

doIf

fun <T> MutableList<T>.doIf(predicate: Boolean, action: MutableList<T>.() -> Any): MutableList<T>

doIfContained

fun <T> Collection<T>.doIfContained(t: T, func: T.() -> Unit): Boolean

encapsulate

fun <T> List<T>.encapsulate(): List<List<T>>

encapsulateToMutableList

fun <T> List<T>.encapsulateToMutableList(): MutableList<MutableList<T>>

filter

inline fun <V> SparseArray<V>.filter(predicate: (Int, V) -> Boolean): SparseArray<V>

Filters all entries matching given predicate into a new SparseArray.

filterNotNullValues

fun <K, V> Map<K, V?>.filterNotNullValues(): Map<K, V>

filterTo

inline fun <V> SparseArray<V>.filterTo(destination: SparseArray<V>, predicate: (Int, V) -> Boolean): SparseArray<V>

Writes all entries matching given predicate to destination array.

firstHalf

fun <T> Collection<T>.firstHalf(): List<T>

firstIndexed

inline fun <T> Array<T>.firstIndexed(filter: (index: Int, T) -> Boolean, onNext: (index: Int, T) -> Unit = { _, _ -> }, onSuccess: () -> Unit = {}, onFail: () -> Unit = {}, onComplete: () -> Unit = {})

firstNotNull

fun <T> ArrayList<T?>.firstNotNull(): T

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

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

Returns the first element which is not null.

firstNotNullOrElse

inline fun <T> Iterable<T?>.firstNotNullOrElse(defaultValue: () -> T): T

inline fun <T> List<T?>.firstNotNullOrElse(defaultValue: () -> T): T

Returns the first element which is not null, or the result of calling the defaultValue function if there are no elements or all elements are null.

firstOrElse

inline fun <T> Iterable<T>.firstOrElse(predicate: (T) -> Boolean, defaultValue: () -> T): T

Returns the first element matching the given predicate, or the result of calling the defaultValue function if no such element is found.

flatMapToMutableList

inline fun <T, R> Iterable<T>.flatMapToMutableList(transform: (T) -> Iterable<R>): MutableList<R>

flatten

fun <T> flatten(vararg elements: List<T>): List<T>

fun <T> flatten(list: List<List<T>>): List<T>

flatten

fun <K, V> Map<K, List<V>>.flatten(): List<Any?>

forEach

inline fun <V> SparseArray<V>.forEach(action: (Int, V) -> Unit)

Performs given action on each key/value pair.

forEachApply

inline fun <E> Iterable<E>.forEachApply(action: E.() -> Unit)

forEachApplyIndexed

inline fun <E> Iterable<E>.forEachApplyIndexed(action: E.(index: Int) -> Unit)

forEachReversed

inline fun <T> ArrayList<T>.forEachReversed(f: (T) -> Unit)

Iterate the receiver ArrayList backwards.

inline fun <T> List<T>.forEachReversed(f: (T) -> Unit)

Iterate the receiver List backwards.

forEachReversedIndexed

inline fun <T> ArrayList<T>.forEachReversedIndexed(f: (Int, T) -> Unit)

Iterate the receiver ArrayList backwards.

inline fun <T> List<T>.forEachReversedIndexed(f: (Int, T) -> Unit)

Iterate the receiver List backwards.

generateRandomIntegerList

fun generateRandomIntegerList(size: Int, range: IntRange): MutableList<Int>

generateRandomStringList

fun generateRandomStringList(size: Int): MutableList<String>

getOrPut

inline fun <V> SparseArray<V>.getOrPut(key: Int, defaultValue: () -> V): V

Gets value with specific key. If the value is not present, calls defaultValue to obtain a non-null value which is placed into the array, then returned.

getRandom

fun <T> List<T>.getRandom(generator: Random = Random()): T

getStringRepresentation

fun <T> List<T>.getStringRepresentation(maxElements: Int = Integer.MAX_VALUE): String

indexInSection

fun <K, V> Map<K, List<V>>.indexInSection(element: V): Int

indexOf

fun <E> List<E>.indexOf(item: E?): Int

indexOfMin

fun <T : Comparable<T>> indexOfMin(arr: Array<T>): Int

Find the index of the minimal element of an array.

init

fun <T> Collection<T>.init(): List<T>

initArrayOf

inline fun <T> initArrayOf(size: Int, predicate: (index: Int) -> T): Array<T>

isBlank

fun <T> Collection<T>?.isBlank(): Boolean

isEmpty

fun <T> Set<T>?.isEmpty(): Boolean

isIndexOutOfBounds

fun Collection<*>?.isIndexOutOfBounds(index: Int): Boolean

isLast

fun <E> Collection<E>.isLast(position: Int): Boolean

fun <E> List<E>.isLast(element: E): Boolean

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

isListAndNotNullOrEmpty

inline fun <T, R> T.isListAndNotNullOrEmpty(actionFalse: () -> R, actionTrue: () -> R): R

isListAndNullOrEmpty

inline fun <T, R> T.isListAndNullOrEmpty(actionFalse: () -> R, actionTrue: () -> R): R

isListSorted

fun <T : Comparable<T>> List<T>.isListSorted(): Boolean

isNotNullOrEmpty

fun <T> Array<T>?.isNotNullOrEmpty(): Boolean

fun BooleanArray?.isNotNullOrEmpty(): Boolean

fun ByteArray?.isNotNullOrEmpty(): Boolean

fun CharArray?.isNotNullOrEmpty(): Boolean

fun DoubleArray?.isNotNullOrEmpty(): Boolean

fun FloatArray?.isNotNullOrEmpty(): Boolean

fun IntArray?.isNotNullOrEmpty(): Boolean

fun LongArray?.isNotNullOrEmpty(): Boolean

fun ShortArray?.isNotNullOrEmpty(): Boolean

isNullOrEmpty

fun <T> Array<T>?.isNullOrEmpty(): Boolean

ARRAY

fun BooleanArray?.isNullOrEmpty(): Boolean

fun ByteArray?.isNullOrEmpty(): Boolean

fun CharArray?.isNullOrEmpty(): Boolean

fun DoubleArray?.isNullOrEmpty(): Boolean

fun FloatArray?.isNullOrEmpty(): Boolean

fun IntArray?.isNullOrEmpty(): Boolean

fun LongArray?.isNullOrEmpty(): Boolean

fun ShortArray?.isNullOrEmpty(): Boolean

fun <T> Set<T>?.isNullOrEmpty(): Boolean

SET

keyAt

fun <K, V> Map<K, V>.keyAt(value: V): K?

keyAtIndex

fun <K, V> Map<K, List<V>>.keyAtIndex(index: Int): K?

keyIndex

fun <K, V> Map<K, List<V>>.keyIndex(key: K?): Int

keySet

fun <T, E> List<Pair<T, E>>.keySet(): Set<T>

fun <T, E> Map<T, E>.keySet(): Set<T>

Isolate the keys out of a list of pairs and store them in a set

lastNotNull

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

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

Returns the last element which is not null.

lastNotNullOrElse

inline fun <T> Iterable<T?>.lastNotNullOrElse(defaultValue: () -> T): T

inline fun <T> List<T?>.lastNotNullOrElse(defaultValue: () -> T): T

Returns the last element which is not null, or the result of calling the defaultValue function if there are no elements or all elements are null.

lastOrElse

inline fun <T> Iterable<T>.lastOrElse(predicate: (T) -> Boolean, defaultValue: () -> T): T

inline fun <T> List<T>.lastOrElse(predicate: (T) -> Boolean, defaultValue: () -> T): T

Returns the last element matching the given predicate, or the result of calling the defaultValue function if no such element is found.

leastCommon

fun <T> ArrayList<T>.leastCommon(): T?

fun <T> Collection<T>.leastCommon(): T?

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

Finds the first least common item

listEqualsIgnoreOrder

fun <T> listEqualsIgnoreOrder(list1: List<T>, list2: List<T>): Boolean

makeTo

inline fun <T : Any> MutableMap<String, Any>.makeTo(fromKey: String, toKey: String, block: (from: Any?) -> T)

mapNotNullToSet

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

mapToMutableList

inline fun <T, R> Iterable<T>.mapToMutableList(transform: (T) -> R): MutableList<R>

mapToSet

inline fun <T, R> Iterable<T>.mapToSet(transform: (T) -> R): Set<R>

mergeWith

fun <T> T.mergeWith(vararg items: T): MutableList<T>

fun <T> T.mergeWith(items: Iterable<T>): MutableList<T>

LIST

midElement

fun <T> ArrayList<T>.midElement(): T?

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

Gets mid element

mostCommon

fun <T> ArrayList<T>.mostCommon(): T?

fun <T> Collection<T>.mostCommon(): T?

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

Finds the first most common item

move

fun <T> MutableList<T>.move(item: T, newIndex: Int)

Moves the given T item to the specified index

moveAll

fun <T> MutableList<T>.moveAll(newIndex: Int, predicate: (T) -> Boolean)

Moves all items meeting a predicate to the given index

moveAt

fun <T> MutableList<T>.moveAt(oldIndex: Int, newIndex: Int)

Moves the given item at the oldIndex to the newIndex

moveDown

fun <T> MutableList<T>.moveDown(item: T): Boolean

Moves the given element T up the MutableList by an index increment unless it is at the bottom already which will result in no movement. Returns a Boolean indicating if move was successful

inline fun <T> MutableList<T>.moveDown(crossinline predicate: (T) -> Boolean): Boolean?

Moves first element T down an index that satisfies the given predicate, unless its already at the bottom

moveDownAll

inline fun <T> MutableList<T>.moveDownAll(crossinline predicate: (T) -> Boolean)

Moves all T elements down an index that satisfy the given predicate, unless they are already at the bottom

moveDownAt

fun <T> MutableList<T>.moveDownAt(index: Int)

Moves the given element T up the MutableList by one increment unless it is at the bottom already which will result in no movement

moveUp

fun <T> MutableList<T>.moveUp(item: T): Boolean

Moves the given element T up the MutableList by an index increment unless it is at the top already which will result in no movement. Returns a Boolean indicating if move was successful