Question

虽然在Kotlin中开发了简单的主要队列，但我已经碰到了一个未经检查的演员阵容，其中有一个未经检查的警告我无法摆脱：

private val pq: Array<T> = arrayOfNulls<Comparable<T>>(capacity) as Array<T>

以下是Kotlin优先级队列的完整源代码：

class UnorderedMaxPQ<T : Comparable<T>>(capacity: Int) {

    private val pq: Array<T> = arrayOfNulls<Comparable<T>>(capacity) as Array<T>

    private var size = 0

    fun isEmpty() = size == 0

    fun size() = size

    fun insert(x: T) {
        pq[size++] = x
    }

    fun delMax(): T {
        var max = 0
        (1..size - 1)
                .asSequence()
                .filter { less(pq[max], pq[it]) }
                .forEach { max = it }
        exchange(pq, max, size - 1)
        return pq[--size]
    }

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

    fun <T : Comparable<T>> less(c1: T, c2: T) = c1 < c2

}

有关如何在创建空数组时避免未经检查的强制转换的任何建议吗？

以下是上述课程的简单单元测试：

import org.hamcrest.core.Is.`is`
import org.junit.Assert.assertThat
import org.junit.Test

class UnorderedMaxPQTest {

    @Test
    fun insert_delMax() {
        val pq = UnorderedMaxPQ<Int>(10)
        pq.insert(2)
        pq.insert(3)
        pq.insert(4)
        pq.insert(1)
        assertThat(pq.delMax(), `is`(4))
        assertThat(pq.delMax(), `is`(3))
        assertThat(pq.size(), `is`(2))
        pq.insert(10)
        assertThat(pq.size(), `is`(3))
        assertThat(pq.delMax(), `is`(10))
        assertThat(pq.isEmpty(), `is`(false))
    }
}

编辑1：

你可以重写这个：

private val pq: Array<T> = arrayOfNulls<Comparable<T>>(capacity) as Array<T>

为：

private val pq: Array<T> = Array<Comparable<T>?>(capacity, { null }) as Array<T>

但未经检查的演员问题仍然存在。此变体基于Andrey Breslav的帖子：https://stackoverflow.com/a/20297428/2735286

Answer 1

您创建的数组仅包含null（arrayOfNulls<Comparable<T>>(capacity)）。这意味着你有一个capacity空的数组。然后你想将数组转换为不可空的数组？这没有任何意义。你没有一个安全的方法可以摆脱未经检查的演员阵容，因为不安全，而会导致你遇到问题，如果你试图强行施放它。

使用arrayOfNulls时是否可以在Kotlin中删除未经检查的强制转换？

编辑1：

1 个答案: