Kotlin: `toString()` on Null Object Causes Crash

When working with Kotlin, you might sometimes come across an issue where calling the toString() method on a null object leads to an application crash. This can be a stumbling block for both new and experienced Kotlin developers, especially for those transitioning from Java, where toString() is often safely ignored when dealing with nulls.

In Kotlin, nullable types are explicitly defined, which means you need to be careful about calling methods on nullable objects. For instance, let’s take a look at the following example:

var str: String? = null
println(str.toString())

The above Kotlin code may crash with a “NullPointerException” because str is a nullable string type (String?), and yet toString() is invoked without checking if the string is null.

Using Safe Calls

The most idiomatic way to handle nullable types and prevent such crashes is through safe calls using the ?. operator. This operator allows you to safely access a method or property of a nullable type without risking a NullPointerException. Here is how you can use this:

var str: String? = null
println(str?.toString())  // Will print 'null' without crashing

Using the safe call operator, ?.toString(), now safely returns null instead of causing a crash.

Using Default Value with Elvis Operator

Another powerful feature in Kotlin to safely handle nulls is the Elvis operator ?:. This operator provides a way to supply a default value when dealing with nulls. Here’s an example:

var str: String? = null
println(str?.toString() ?: "Default Value")  // Prints: Default Value

In this code snippet, if str is null, instead of crashing, the program will output "Default Value".

Checking for Nulls Explicitly

Another option is simply to perform an explicit null check. This is less idiomatic in Kotlin but can be useful if you have specific conditions or logging needs:

var str: String? = null
if (str != null) {
    println(str.toString())
} else {
    println("str is null")
}

Here, you explicitly check whether str is null before calling toString().

Leveraging the requireNonNull Function

If you are sure that a variable should never be null at a certain point and want the program to throw a specific exception if it is, you can use Kotlin’s requireNotNull function:

var str: String? = "Hello, World!"
println(requireNotNull(str).toString())  // Prints: Hello, World!

If str is null, requireNotNull will throw an IllegalArgumentException with the message you provide or a default one.

Conclusion

Understanding how Kotlin handles nullability is crucial for writing robust and crash-free applications. Leveraging safe calls, Elvis operators, and null checks allows you to confidently work with nullable types without fear of runtime crashes due to null pointer exceptions.

By adopting Kotlin’s null safety features, you can create safer, more predictable codebases that are less prone to bugs and runtime errors. Remember to consult the Kotlin documentation and explore these features in your application development process to take full advantage of Kotlin's potential.