Package kotlin.comparisons

Helper functions for creating Comparator instances.

Helper functions for creating Comparator instances.

Functions

Common
JVM
JS
Native
1.0

compareBy

Creates a comparator using the sequence of functions to calculate a result of comparison. The functions are called sequentially, receive the given values a and b and return Comparable objects. As soon as the Comparable instances returned by a function for a and b values do not compare as equal, the result of that comparison is returned from the Comparator.

fun <T> compareBy(
    vararg selectors: (T) -> Comparable<*>?
): Comparator<T>

Creates a comparator using the function to transform value to a Comparable instance for comparison.

fun <T> compareBy(
    selector: (T) -> Comparable<*>?
): Comparator<T>

Creates a comparator using the selector function to transform values being compared and then applying the specified comparator to compare transformed values.

fun <T, K> compareBy(
    comparator: Comparator<in K>,
    selector: (T) -> K
): Comparator<T>
Common
JVM
JS
Native
1.0

compareByDescending

Creates a descending comparator using the function to transform value to a Comparable instance for comparison.

fun <T> compareByDescending(
    selector: (T) -> Comparable<*>?
): Comparator<T>

Creates a descending comparator using the selector function to transform values being compared and then applying the specified comparator to compare transformed values.

fun <T, K> compareByDescending(
    comparator: Comparator<in K>,
    selector: (T) -> K
): Comparator<T>
Common
JVM
JS
Native
1.0

compareValues

Compares two nullable Comparable values. Null is considered less than any value.

fun <T : Comparable<*>> compareValues(a: T?, b: T?): Int
Common
JVM
JS
Native
1.0

compareValuesBy

Compares two values using the specified functions selectors to calculate the result of the comparison. The functions are called sequentially, receive the given values a and b and return Comparable objects. As soon as the Comparable instances returned by a function for a and b values do not compare as equal, the result of that comparison is returned.

fun <T> compareValuesBy(
    a: T,
    b: T,
    vararg selectors: (T) -> Comparable<*>?
): Int

Compares two values using the specified selector function to calculate the result of the comparison. The function is applied to the given values a and b and return Comparable objects. The result of comparison of these Comparable instances is returned.

fun <T> compareValuesBy(
    a: T,
    b: T,
    selector: (T) -> Comparable<*>?
): Int

Compares two values using the specified selector function to calculate the result of the comparison. The function is applied to the given values a and b and return objects of type K which are then being compared with the given comparator.

fun <T, K> compareValuesBy(
    a: T,
    b: T,
    comparator: Comparator<in K>,
    selector: (T) -> K
): Int
Common
JVM
JS
Native
1.1

maxOf

Returns the greater of three values according to the order specified by the given comparator.

fun <T> maxOf(
    a: T,
    b: T,
    c: T,
    comparator: Comparator<in T>
): T

Returns the greater of two values according to the order specified by the given comparator.

fun <T> maxOf(a: T, b: T, comparator: Comparator<in T>): T

Returns the greater of the given values according to the order specified by the given comparator.

fun <T> maxOf(
    a: T,
    vararg other: T,
    comparator: Comparator<in T>
): T

Returns the greater of two values.

fun maxOf(a: UInt, b: UInt): UInt
fun maxOf(a: ULong, b: ULong): ULong
fun maxOf(a: UByte, b: UByte): UByte
fun maxOf(a: UShort, b: UShort): UShort
fun <T : Comparable<T>> maxOf(a: T, b: T): T
fun maxOf(a: Byte, b: Byte): Byte
fun maxOf(a: Short, b: Short): Short
fun maxOf(a: Int, b: Int): Int
fun maxOf(a: Long, b: Long): Long
fun maxOf(a: Float, b: Float): Float
fun maxOf(a: Double, b: Double): Double

Returns the greater of three values.

fun maxOf(a: UInt, b: UInt, c: UInt): UInt
fun maxOf(a: ULong, b: ULong, c: ULong): ULong
fun maxOf(a: UByte, b: UByte, c: UByte): UByte
fun maxOf(a: UShort, b: UShort, c: UShort): UShort
fun <T : Comparable<T>> maxOf(a: T, b: T, c: T): T
fun maxOf(a: Byte, b: Byte, c: Byte): Byte
fun maxOf(a: Short, b: Short, c: Short): Short
fun maxOf(a: Int, b: Int, c: Int): Int
fun maxOf(a: Long, b: Long, c: Long): Long
fun maxOf(a: Float, b: Float, c: Float): Float
fun maxOf(a: Double, b: Double, c: Double): Double

Returns the greater of the given values.

fun maxOf(a: UInt, vararg other: UInt): UInt
fun maxOf(a: ULong, vararg other: ULong): ULong
fun maxOf(a: UByte, vararg other: UByte): UByte
fun maxOf(a: UShort, vararg other: UShort): UShort
fun <T : Comparable<T>> maxOf(a: T, vararg other: T): T
fun maxOf(a: Byte, vararg other: Byte): Byte
fun maxOf(a: Short, vararg other: Short): Short
fun maxOf(a: Int, vararg other: Int): Int
fun maxOf(a: Long, vararg other: Long): Long
fun maxOf(a: Float, vararg other: Float): Float
fun maxOf(a: Double, vararg other: Double): Double
Common
JVM
JS
Native
1.1

minOf

Returns the smaller of three values according to the order specified by the given comparator.

fun <T> minOf(
    a: T,
    b: T,
    c: T,
    comparator: Comparator<in T>
): T

Returns the smaller of two values according to the order specified by the given comparator.

fun <T> minOf(a: T, b: T, comparator: Comparator<in T>): T

Returns the smaller of the given values according to the order specified by the given comparator.

fun <T> minOf(
    a: T,
    vararg other: T,
    comparator: Comparator<in T>
): T

Returns the smaller of two values.

fun minOf(a: UInt, b: UInt): UInt
fun minOf(a: ULong, b: ULong): ULong
fun minOf(a: UByte, b: UByte): UByte
fun minOf(a: UShort, b: UShort): UShort
fun <T : Comparable<T>> minOf(a: T, b: T): T
fun minOf(a: Byte, b: Byte): Byte
fun minOf(a: Short, b: Short): Short
fun minOf(a: Int, b: Int): Int
fun minOf(a: Long, b: Long): Long
fun minOf(a: Float, b: Float): Float
fun minOf(a: Double, b: Double): Double

Returns the smaller of three values.

fun minOf(a: UInt, b: UInt, c: UInt): UInt
fun minOf(a: ULong, b: ULong, c: ULong): ULong
fun minOf(a: UByte, b: UByte, c: UByte): UByte
fun minOf(a: UShort, b: UShort, c: UShort): UShort
fun <T : Comparable<T>> minOf(a: T, b: T, c: T): T
fun minOf(a: Byte, b: Byte, c: Byte): Byte
fun minOf(a: Short, b: Short, c: Short): Short
fun minOf(a: Int, b: Int, c: Int): Int
fun minOf(a: Long, b: Long, c: Long): Long
fun minOf(a: Float, b: Float, c: Float): Float
fun minOf(a: Double, b: Double, c: Double): Double

Returns the smaller of the given values.

fun minOf(a: UInt, vararg other: UInt): UInt
fun minOf(a: ULong, vararg other: ULong): ULong
fun minOf(a: UByte, vararg other: UByte): UByte
fun minOf(a: UShort, vararg other: UShort): UShort
fun <T : Comparable<T>> minOf(a: T, vararg other: T): T
fun minOf(a: Byte, vararg other: Byte): Byte
fun minOf(a: Short, vararg other: Short): Short
fun minOf(a: Int, vararg other: Int): Int
fun minOf(a: Long, vararg other: Long): Long
fun minOf(a: Float, vararg other: Float): Float
fun minOf(a: Double, vararg other: Double): Double
Common
JVM
JS
Native
1.0

naturalOrder

Returns a comparator that compares Comparable objects in natural order.

fun <T : Comparable<T>> naturalOrder(): Comparator<T>
Common
JVM
JS
Native
1.0

nullsFirst

Extends the given comparator of non-nullable values to a comparator of nullable values considering null value less than any other value.

fun <T : Any> nullsFirst(
    comparator: Comparator<in T>
): Comparator<T?>

Provides a comparator of nullable Comparable values considering null value less than any other value.

fun <T : Comparable<T>> nullsFirst(): Comparator<T?>
Common
JVM
JS
Native
1.0

nullsLast

Extends the given comparator of non-nullable values to a comparator of nullable values considering null value greater than any other value.

fun <T : Any> nullsLast(
    comparator: Comparator<in T>
): Comparator<T?>

Provides a comparator of nullable Comparable values considering null value greater than any other value.

fun <T : Comparable<T>> nullsLast(): Comparator<T?>
Common
JVM
JS
Native
1.0

reversed

Returns a comparator that imposes the reverse ordering of this comparator.

fun <T> Comparator<T>.reversed(): Comparator<T>
Common
JVM
JS
Native
1.0

reverseOrder

Returns a comparator that compares Comparable objects in reversed natural order.

fun <T : Comparable<T>> reverseOrder(): Comparator<T>
Common
JVM
JS
Native
1.0

then

Combines this comparator and the given comparator such that the latter is applied only when the former considered values equal.

infix fun <T> Comparator<T>.then(
    comparator: Comparator<in T>
): Comparator<T>
Common
JVM
JS
Native
1.0

thenBy

Creates a comparator comparing values after the primary comparator defined them equal. It uses the function to transform value to a Comparable instance for comparison.

fun <T> Comparator<T>.thenBy(
    selector: (T) -> Comparable<*>?
): Comparator<T>

Creates a comparator comparing values after the primary comparator defined them equal. It uses the selector function to transform values and then compares them with the given comparator.

fun <T, K> Comparator<T>.thenBy(
    comparator: Comparator<in K>,
    selector: (T) -> K
): Comparator<T>
Common
JVM
JS
Native
1.0

thenByDescending

Creates a descending comparator using the primary comparator and the function to transform value to a Comparable instance for comparison.

fun <T> Comparator<T>.thenByDescending(
    selector: (T) -> Comparable<*>?
): Comparator<T>

Creates a descending comparator comparing values after the primary comparator defined them equal. It uses the selector function to transform values and then compares them with the given comparator.

fun <T, K> Comparator<T>.thenByDescending(
    comparator: Comparator<in K>,
    selector: (T) -> K
): Comparator<T>
Common
JVM
JS
Native
1.0

thenComparator

Creates a comparator using the primary comparator and function to calculate a result of comparison.

fun <T> Comparator<T>.thenComparator(
    comparison: (a: T, b: T) -> Int
): Comparator<T>
Common
JVM
JS
Native
1.0

thenDescending

Combines this comparator and the given comparator such that the latter is applied only when the former considered values equal.

infix fun <T> Comparator<T>.thenDescending(
    comparator: Comparator<in T>
): Comparator<T>