30+ Kotlin Interview Questions And Answers

Inline functions are used in Kotlin to reduce overhead from lambdas. Inlining substitutes the body of the function into the place where it is called, which can help with performance. Use them carefully, as they can increase the compiled code size if overused.

'List' in Kotlin is an ordered collection with access to elements by indices. 'Set' is a collection of unique elements and 'Map' is a set of key-value pairs. Keys are unique, and each key maps to exactly one value.

Kotlin has null safety features built into its type system. The Elvis operator, ?:, allows for providing a default value if an expression evaluates to null, which prevents null pointer exceptions.

Reified type parameters allow you to access the type at runtime, which is normally erased due to type erasure in Java. This is useful in inline functions since the type can be inlined as well.

inline fun  myGenericFun(value: Any) {
    if (value is T) {
        // Do something
    }
}

'const' is used to define compile-time constants, meaning their value has to be assigned during compile time. Unlike 'val', which can be assigned a value during runtime, 'const' can only hold primitives and String types.

Destructuring allows you to declare multiple variables at once and initialize them with the properties of an object. For instance, with a pair you can do:

val (a, b) = Pair(1, "x")
// a = 1, b = "x"

A 'typealias' is a feature that lets you provide alternate names for existing types, making the code more readable and understandable, especially when dealing with complex generic types.

Coroutines are lighter than threads as they don’t map one-to-one with the underlying threads. They can suspend and resume without blocking the thread, whereas threads can consume more resources and cause an overhead when there's a large number of concurrent tasks.

You can implement dependency injection in Kotlin by using constructor injection, property injection, or method injection manually without relying on a framework. However, using a DI framework (like Dagger or Koin) is usually more convenient.

The function returns the object itself if it's a non-negative number and implements the Comparable interface with T. If the number is negative, an IllegalArgumentException is thrown.

Smart casts automatically cast types if they have been checked in a control structure. For instance, if you check a variable is of a certain type, Kotlin allows you to use that variable as that type without explicit casting.

'with' is used to call multiple functions on an object within a block of code. 'apply' works similarly but returns the object itself after executing the block, usually used for configuration.

Inline properties optimize your code by inlining the property's getter and setter methods wherever they are accessed instead of actually calling the method. This can reduce overhead.

Kotlin doesn't have checked exceptions, which means you don't need to catch or declare any exceptions. However, you can still handle exceptions using try/catch blocks for better error management.

'let' is often used for null-checks and executing a block of code if the object is not null. It is also useful when you want to limit the scope of variables. 'run' is similar to 'let' but it's for scenarios when the receiver is already nullable or if you need to return a result from a block of code while using 'this' as the receiver.

myObject.run {
    this.performAction()
    this.anotherAction()
}