如何在 Kotlin 中检查 List 是否包含 null？

Question

I'm having trouble understanding why

class Main {
    private val outputStreams: List<OutputStream>

    @JvmOverloads constructor(outputStreams: List<OutputStream> = LinkedList()) {
        if(outputStreams.contains(null)) {
            throw IllegalArgumentException("outputStreams mustn't contain null")
        }
        this.outputStreams = outputStreams
    }
}

causes the compilation error ...Main.kt:[12,26] Type inference failed. The value of the type parameter T should be mentioned in input types (argument types, receiver type or expected type). Try to specify it explicitly. ...Main.kt:[12,26] Type inference failed. The value of the type parameter T should be mentioned in input types (argument types, receiver type or expected type). Try to specify it explicitly. .

If I use outputStreams.contains(null as OutputStream)) the compilation succeeds, but Main(LinkedList<OutputStream>()) fails at runtime due to

kotlin.TypeCastException: null cannot be cast to non-null type java.io.OutputStream
    at kotlinn.collection.contains.nulll.check.Main.<init>(Main.kt:12)
    at kotlinn.collection.contains.nulll.check.MainTest.testInit(MainTest.kt:13)

which leaves me with no other approach for keeping the code as close to the original Java as possible which is my intend as well as understanding this issue as it is rather than searching for a workaround.

Answer 1

For the compiler, the parameter outputStreams cannot contain null as its type is List<OutputStream> as opposed to List<OutputStream?> . The type system does not expect null to be inside this list, thus no need to check it.

On the other hand , IF that parameter actually could contain null (since it comes from a Java caller) you should mark it as nullable explicitly: List<OutputStream?>

Answer 2

I belive that the answer is List<OutputStream?> . ? will make your list can contain null . Check the doc: enter link description here

Answer 3

filterNotNull() method can filter out all null objects from the collection so you could use the code below. Obviously, you need to inform the compiler that objects in the collection are nullable. I changed the OutputStream type to String for easier testing.

    class Main{
private val outputStreams: List<String?>

@JvmOverloads constructor(outputStreams: List<String?> = LinkedList()) {

    if(outputStreams.filterNotNull().size < outputStreams.size) {
        throw IllegalArgumentException("outputStreams mustn't contain null")
    }
    this.outputStreams = outputStreams
}

fun getOutputStream(): List<String?>{
    return outputStreams
}
 }

A second approach would be to use let T.let(block: (T) -> R): R where you would accept the nullable object, but then you would have to check whether there is any "null" string and react accordingly.

    class Main{
lateinit var outputStreams: List<String?>

@JvmOverloads constructor(outputStreams: List<String?> = LinkedList()) {

    outputStreams.let {
        this.outputStreams = outputStreams
    }

}

fun getOutputStream(): List<String?>{
    return outputStreams
}
}

    fun main(args: Array<String>) {
val outputStreamWithNull: List<String?> = listOf("alpha", "beta", null, "omega")
val mainA = Main(outputStreamWithNull)


mainA.getOutputStream().forEach {
    println(it)
}

}

If you are "confident" that the object parameter in the constructor should be a collection of non-null objects, then you can remove ? However, the nullable check on the List collection must be done by an object initialising Main class, so you would basically move the responsibility of catching NullPointerException to someone else.

Answer 4

I don't have enough rep to comment on ToraCode's answer, but further to what they have said, I expect the type of LinkedList() is actually List<OutputStream!> meaning that the type is either List<OutputStream> or List<OutputStream?>

Types with ! after them are platform types. So List<OutputStream!> would mean "Java List of OutputStream may be nullable or not" We simply have no way of knowing.

I think it is safest to follow ToraCode's recommendation, use List<OutputStream?> and check for nulls.

For more information on the interoperability of kotlin see: https://kotlinlang.org/docs/reference/java-interop.html#notation-for-platform-types