Generics Kotlin：为可比较的对象消除未检查的强制类型转换

我刚刚实施了选择排序来熟悉Kotlin，并遇到了一个我发现很难摆脱的未经检查的演员阵容。实现基于

kotlin。可比较的
接口：

object SelectionSort {

    fun <T> sort(a: Array<Comparable<T>>) {
        val N = a.size
        for(i in 0..N - 2) {
            var min = i
            for(j in i + 1..N - 1) {
                if(less(a[j], a[min])) {
                    min = j
                }
            }
            exchange(a, i, min)
        }
    }

    private fun <T> exchange(a: Array<Comparable<T>>, i: Int, min: Int) {
        val temp = a[i]
        a[i] = a[min]
        a[min] = temp
    }

    private fun <T> less(comparable: Comparable<T>, comparable1: Comparable<T>): Boolean {
        return comparable < (comparable1 as T) // Here is the unchecked cast
    }
}

此实现现在没有警告。
问题的解决方案，但太复杂了
这就解决了您的问题：

inline fun <reified T> less(c1: Comparable<T>, c2: Comparable<T>) =
   if (c2 is T) {
       c1 < c2
   } else {
       throw IllegalStateException() // whatever
   }

这确保了只有
T
可以被排序，实现了
可比的
，它在泛型类型中用
：
（上限）表示。然后您的
less
方法如下所示：

private fun <T : Comparable<T>> less(comparable: T, comparable1: T): Boolean {
    return comparable < comparable1
}

private-fun-less（可比：T，可比1:T）：布尔值{
返回可比<可比1
}

无需浇铸：-）

（这同样适用于
交换
）
您应该在
排序
和
少排序时使用绑定的

fun <T : Comparable<T>> sort(arr: Array<T>) = ...
fun <T : Comparable<T>> less(l: T, r: T) = ...

因为
sort
需要一个
数组
，但是
arr
是一个
数组

此外，没有理由在
exchange

fun <T> exchange(arr: Array<T>, i: Int, j: Int) = ...

fun交换（arr:Array，i:Int，j:Int）=。。。
是的，“更好的解决方案”是一条路要走。是的。但我也想给你一个解决铸造问题的办法。
fun <T : Comparable<T>> sort(arr: Array<T>) = ...
fun <T : Comparable<T>> less(l: T, r: T) = ...

val arr: Array<String> = ...
sort(arr);

fun <T> exchange(arr: Array<T>, i: Int, j: Int) = ...