What are the dangers of passing a lambda from Java to a method in Kotlin?

When passing a lambda from Java to a Kotlin method:

1. SAM Conversion: The lambda in Java must correspond to a functional interface (an interface with a single abstract method) for automatic conversion to a Kotlin functional type. If the lambda does not match such an interface, automatic conversion will not occur, and manual transformation or wrapping will be required.
2. Nullable type: The functional type in Kotlin obtained from Java is non-nullable by default (() -> Unit). If the Kotlin method expects a nullable type (() -> Unit?), explicit nullable type declaration in Kotlin may be necessary when called from Java.
3. Exceptions: Exceptions that can be thrown inside the lambda code in Java are not automatically handled in Kotlin. Kotlin code must explicitly handle these exceptions using try-catch.
4. Performance: Although SAM conversion is generally efficient, in some cases, excessive creation of wrapper objects for lambdas may slightly impact performance.
5. Version Compatibility: The interaction features between Kotlin and Java may change between compiler versions, which may require attention when updating.

Example:

// Java code
interface MyFunctionalInterface {
    void doSomething();
}

class JavaConsumer {
    public void consume(MyFunctionalInterface callback) {
        callback.doSomething();
    }
}

// Kotlin code
class KotlinUser {
    fun useConsumer(consumer: JavaConsumer) {
        // Automatic SAM conversion from Java lambda to Kotlin functional type
        consumer.consume { println("Doing something from Kotlin") }

        // Example where nullable type may be needed in Kotlin function,
        // if Java method can accept null
        // fun consumeNullable(callback: (() -> Unit)?) { ... }
    }
}