Top 68 Kotlin Interview Questions And Answers

Question 1

Where should I use `var` and where `val`?

Accepted Answer

Use **var** where value is changing _frequently_. For example while getting location of android device:

```kotlin
var integerVariable : Int? = null
```

Use **val** where there is _no change_ in value in whole class. For example you want set textview or button's text programmatically.

```kotlin
val stringVariables : String = "Button's Constant or final Text"
```

Question 2

What is the _idiomatic_ way to _remove duplicate strings_ from array?

Accepted Answer

Use the `distinct` extension function:

```kotlin
val a = arrayOf("a", "a", "b", "c", "c")
val b = a.distinct() // ["a", "b", "c"]
```

You can also use:
* `toSet`, `toMutableSet`
* `toHashSet` - if you don't need the original ordering to be preserved

These functions produce a `Set` instead of a `List` and should be a little bit more efficient than distinct.

Question 3

How to correctly concatenate a `String` in Kotlin?

Accepted Answer

In Kotlin, you can concatenate 
1. using string interpolation / templates
 ```kotlin
val a = "Hello"
val b = "World"
val c = "$a $b"
 ```
2. using the + / `plus()` operator
 ```kotlin
 val a = "Hello"
 val b = "World" 
 val c = a + b   // same as calling operator function a.plus(b)
 val c = a.plus(b)
 
 print(c)
 ```
3. using the `StringBuilder`
 ```kotlin
 val a = "Hello"
 val b = "World"
 
 val sb = StringBuilder()
 sb.append(a).append(b)
 val c = sb.toString()
 
 print(c)
 ```

Question 4

What is basic difference between `fold` and `reduce` in Kotlin? When to use which?

Accepted Answer

* `fold` takes an initial value, and the first invocation of the lambda you pass to it will receive that initial value and the first element of the collection as parameters.

```kotlin 
 listOf(1, 2, 3).fold(0) { sum, element -> sum + element }
 ```
 The first call to the lambda will be with parameters `0` and `1`.

Having the ability to pass in an initial value is useful _if you have to provide some sort of default value or parameter for your operation_.

* `reduce` doesn't take an initial value, but instead starts with the first element of the collection as the accumulator (called `sum` in the following example)

```kotlin
 listOf(1, 2, 3).reduce { sum, element -> sum + element }
 ```

The first call to the lambda here will be with parameters `1` and `2`.

Question 5

How to _initialize an array_ in Kotlin with values?

Accepted Answer

```kotlin
val numbers: IntArray = intArrayOf(10, 20, 30, 40, 50)
```

Question 6

What is a _primary constructor_ in Kotlin?

Accepted Answer

The **primary constructor** is part of the class header. Unlike Java, you don't need to declare a constructor in the body of the class. Here's an example:

```kotlin
class Person(val firstName: String, var age: Int) {
    // class body
}
```

The main idea is by removing the constructor keyword, our code gets simplified and easy to understand.

Question 7

What is the difference between `var` and `val` in Kotlin?

Accepted Answer

* **var** is like `general` variable and it's known as a _mutable_ variable in kotlin and can be assigned multiple times.

* **val** is like `Final` variable and it's known as _immutable_ in Kotlin and can be initialized only single time.

Question 8

How to create _singleton_ in Kotlin?

Accepted Answer

Just use `object`.
```kotlin
object SomeSingleton
```
The above Kotlin object will be compiled to the following equivalent Java code:
```java
public final class SomeSingleton {
   public static final SomeSingleton INSTANCE;

private SomeSingleton() {
      INSTANCE = (SomeSingleton)this;
      System.out.println("init complete");
   }

static {
      new SomeSingleton();
   }
}
```
This is the preferred way to implement singletons on a JVM because it enables thread-safe lazy initialization without having to rely on a locking algorithm like the complex double-checked locking.

Question 9

What is a _data class_ in Kotlin?

Accepted Answer

We frequently create classes whose main purpose is to hold data. In Kotlin, this is called a data class and is marked as `data`:

```kotlin
data class User(val name: String, val age: Int)
```

To ensure consistency and meaningful behavior of the generated code, data classes have to fulfill the following requirements:

* The primary constructor needs to have at least one parameter;
* All primary constructor parameters need to be marked as val or var;
* Data classes cannot be abstract, open, sealed or inner;

Question 10

What is `lateinit` in Kotlin and when would you use it?

Accepted Answer

**lateinit** means _late initialization_. If you do not want to initialize a variable in the constructor instead you want to initialize it later on and if you can guarantee the initialization before using it, then declare that variable with lateinit keyword. It will not allocate memory until initialized. You cannot use lateinit for primitive type properties like Int, Long etc.

```kotlin
lateinit var test: String

fun doSomething() {
    test = "Some value"
    println("Length of string is "+test.length)
    test = "change value"
}
```

There are a handful of use cases where this is extremely helpful, for example:

* Android: variables that get initialized in lifecycle methods;
* Using Dagger for DI: injected class variables are initialized outside and independently from the constructor;
* Setup for unit tests: test environment variables are initialized in a `@Before` - annotated method;
* Spring Boot annotations (eg. `@Autowired`).

Top 68 Kotlin Interview Questions

How to correctly concatenate a String in Kotlin?

What is a data class in Kotlin?

How to initialize an array in Kotlin with values?

What is the idiomatic way to remove duplicate strings from array?

Where should I use var and where val?

What is the difference between var and val in Kotlin?

What is basic difference between fold and reduce in Kotlin? When to use which?

What is a primary constructor in Kotlin?

May you use IntArray and an Array<Int> is in Kotlin interchangeably?

What are the advantages of Kotlin over Java?

Explain advantages of when vs switch in Kotlin

What is the difference between List and Array types?

Explain lazy initialization in Kotlin

What are coroutines in Kotlin?

When to use lateinit over lazy initialization in Kotlin?

What is the purpose of Unit-returning in functions? Why is VALUE there? What is this VALUE?

When would you use Elvis operator in Kotlin?

What is suspending function in Kotlin?

What is a difference between a class and object in Kotlin?

What is the equivalent of Java static methods in Kotlin?

What are scope functions in Kotlin?

How would you create a singleton with parameter in Kotlin?

What is the Kotlin double-bang !! operator?

What is a purpose of Companion Objects in Kotlin?

What is the difference between suspending vs. blocking?

val mutableList vs var immutableList. When to use which in Kotlin?

What is lateinit in Kotlin and when would you use it?

How are extensions resolved in Kotlin and what doest it mean?

What is the difference between open and public in Kotlin?

May you briefly compare Kotlin vs Java?

What is the difference between const and val?

What are some disadvantages of Kotlin?

Why would you use apply in Kotlin?

Explain the null safety in Kotlin

How is it recommended to create constants in Kotlin?

What is the idiomatic way to deal with nullable values, referencing or converting them?

Provide a real use case when inline classes may be useful

What is Kotlin backing field is used for?

How can I create static method for enum in Kotiln?

Explain the difference between Inline classes vs type aliases

Why is there no static keyword in Kotlin?

What are Object expressions in Kotlin and when to use them?

What is Coroutine Scope and how is that different from Coroutine Context?

How does the reified keyword in Kotlin work?

What is the difference between Java field and Kotlin property?

When to use and do not use an inline function in Kotlin?

What is The Billion Dollar Mistake?

What is the difference between launch/join and async/await in Kotlin coroutines?

What is a motivation to make classes final by default in Kotlin? Do you agree with that decision?

Why do we use companion object as a kind of replacement for Java static fields in Kotlin?

How Kotlin coroutines are better than RxKotlin/RxJava?

What is SAM Conversion in Kotlin?

What is the difference between * and Any in Kotlin generics?

Explain the difference between lateinit and lazy in details

How to create singleton in Kotlin?

Rewrite this code in Kotlin

Explain what is wrong with that code?

How would you refactor this code using apply?

How to convert List to Map in Kotlin?

What will be result of the following code execution?

How to create empty constructor for data class in Kotlin?

Rewrite this code using run extension function

How would you override default getter for Kotlin data class?

What is inline class in Kotlin and when do we need one? Provide an example.

How to create an instance of anonymous class of abstract class in Kotlin?

Imagine you moving your code from Java to Kotlin. How would you rewrite this code in Kotlin?

How to implement Builder pattern in Kotlin?

What's wrong with that code?

How to correctly concatenate a `String` in Kotlin?

Where should I use `var` and where `val`?

What is the difference between `var` and `val` in Kotlin?

What is basic difference between `fold` and `reduce` in Kotlin? When to use which?

May you use `IntArray` and an `Array<Int>` is in Kotlin interchangeably?

Explain advantages of `when` vs `switch` in Kotlin

What is the difference between `List` and `Array` types?

When to use `lateinit` over `lazy` initialization in Kotlin?

What is the purpose of `Unit-returning` in functions? Why is `VALUE` there? What is this V`ALUE`?

When would you use `Elvis` operator in Kotlin?

What is a difference between a `class` and `object` in Kotlin?

What is the equivalent of Java `static` methods in Kotlin?

What is the Kotlin double-bang `!!` operator?

`val mutableList` vs `var immutableList`. When to use which in Kotlin?

What is `lateinit` in Kotlin and when would you use it?

What is the difference between `open` and `public` in Kotlin?

What is the difference between `const` and `val`?

Why would you use `apply` in Kotlin?

What is the idiomatic way to deal with `null`able values, referencing or converting them?

How can I create `static` method for enum in Kotiln?

Explain the difference between `Inline` classes vs `type` aliases

Why is there no `static` keyword in Kotlin?

How does the `reified` keyword in Kotlin work?

What is the difference between `launch/join` and `async/await` in Kotlin coroutines?

What is a motivation to make classes `final` by default in Kotlin? Do you agree with that decision?

What is the difference between `*` and `Any` in Kotlin generics?

Explain the difference between `lateinit` and `lazy` in details

How would you refactor this code using `apply`?

How to convert `List` to `Map` in Kotlin?

Rewrite this code using `run` extension function

What is `inline` class in Kotlin and when do we need one? Provide an example.

How to implement `Builder` pattern in Kotlin?