40 Kotlin Interview Questions Android Devs Must Know

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

Just use object.

object SomeSingleton

The above Kotlin object will be compiled to the following equivalent Java code:

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.

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

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;

• 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.

  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)

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

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

• 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.

+----------------+-----------------------------+---------------------------+
|                |             val             |            var            |
+----------------+-----------------------------+---------------------------+
| Reference type | Immutable(once initialized  | Mutable(can able to change|
|                | can't be reassigned)        | value)                    |
+----------------+-----------------------------+---------------------------+
| Example        | val n = 20                  | var n = 20                |
+----------------+-----------------------------+---------------------------+
| In Java        | final int n = 20;           | int n = 20;               |
+----------------+-----------------------------+---------------------------+

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

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.

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

In Java we use switch but in Kotlin, that switch gets converted to when. When has a better design. It is more concise and powerful than a traditional switch. when can be used either as an expression or as a statement.

Some examples of when usage:

• Two or more choices

when(number) {
    1 -> println("One")
    2, 3 -> println("Two or Three")
    4 -> println("Four")
    else -> println("Number is not between 1 and 4")
}

• "when" without arguments

when {
    number < 1 -> print("Number is less than 1")
    number > 1 -> print("Number is greater than 1")
}

• Any type passed in "when"

fun describe(obj: Any): String =
    when (obj) {
      1 -> "One"
      "Hello" -> "Greeting"
      is Long -> "Long"
      !is String -> "Not a string"
      else -> "Unknown"
    }

• Smart casting

when (x) {
    is Int -> print("X is integer")
    is String -> print("X is string")
}

• Ranges

when(number) {
    1 -> println("One") //statement 1
    2 -> println("Two") //statement 2
    3 -> println("Three") //statement 3
    in 4..8 -> println("Number between 4 and 8") //statement 4
    !in 9..12 -> println("Number not in between 9 and 12") //statement 5
    else -> println("Number is not between 1 and 8") //statement 6
}

Kotlin's type system is aimed at eliminating the danger of null references from code, also known as the The Billion Dollar Mistake.

One of the most common pitfalls in many programming languages, including Java, is that accessing a member of a null reference will result in a null reference exception. In Java this would be the equivalent of a NullPointerException or NPE for short.

In Kotlin, the type system distinguishes between references that can hold null (nullable references) and those that can not (non-null references). For example, a regular variable of type String can not hold null:

var a: String = "abc"
a = null // compilation error

To allow nulls, we can declare a variable as nullable string, written String?:

var b: String? = "abc"
b = null // ok
print(b)

The property of the class can’t be declared inside the secondary constructor.. This will give an error because here we are declaring a property id of the class in the secondary constructor, which is not allowed.

If you want to use some property inside the secondary constructor, then declare the property inside the class and use it in the secondary constructor:

class Student (var name: String) {

    var id: Int = -1
    init() {
        println("Student has got a name as $name")
    }
    
    constructor(secname: String, id: Int) this(secname) {
        this.id = id
    }
}

In Kotlin, if you want to create the local constants which are supposed to be used with in the class then you can create it like below:

val MY_CONSTANT_1 = "Constants1"
// or 
const val MY_CONSTANT_2 = "Constants2"

Like val, variables defined with the const keyword are immutable. The difference here is that const is used for variables that are known at compile-time.

Also avoid using companion objects. Behind the hood, getter and setter instance methods are created for the fields to be accessible. Calling instance methods is technically more expensive than calling static methods. Instead define the constants in object:

object DbConstants {
        const val TABLE_USER_ATTRIBUTE_EMPID = "_id"
        const val TABLE_USER_ATTRIBUTE_DATA = "data"
}

You can write:

class Message(message: String, signature: String) {
  val body = MessageBody().apply {
    text = message + "\n" + signature
  }
}

Array<Int> is an Integer[] under the hood, while IntArray is an int[].

This means that when you put an Int in an Array<Int>, it will always be boxed (specifically, with an Integer.valueOf() call). In the case of IntArray, no boxing will occur, because it translates to a Java primitive array.

So no, we can't use them interchangeably.

Using Kotlin:

object Singleton

Unlike many other languages with similar capabilities, async and await are not keywords in Kotlin and are not even part of its standard library.

kotlinx.coroutines is a rich library for coroutines developed by JetBrains. It contains a number of high-level coroutine-enabled primitives, including launch, async and others. Kotlin Coroutines give you an API to write your asynchronous code sequentially.

The documentation says Kotlin Coroutines are like lightweight threads. They are lightweight because creating coroutines doesn’t allocate new threads. Instead, they use predefined thread pools, and smart scheduling. Scheduling is the process of determining which piece of work you will execute next.

Additionally, coroutines can be suspended and resumed mid-execution. This means you can have a long-running task, which you can execute little-by-little. You can pause it any number of times, and resume it when you’re ready again.

Some think that Kotlin is a mess of extra syntax and keywords. Here are a few keywords which have non-obvious meanings: internal, crossinline, expect, reified, sealed, inner, open. Java has none of these. Kotlin is also amusingly inconsistent in its keywords: a function is is declared with ‘fun’, but an interface is declared with ‘interface’ (not ‘inter’?). Kotlin also doesn’t have checked exceptions. Checked exceptions have become unfashionable, yet many (including me) find them a powerful way to ensure that your code is robust. Finally, Kotlin hides a lot of what goes on. In Java, you can trace through almost every step of program logic. This can be vital for hunting down bugs. In Kotlin, if you define a data class, then getters, setters, equality testing, to string, and hash code are added for you invisibly. This can be a bad idea.

Also according docs, what Java has that Kotlin does not:

• Checked exceptions
• Primitive types that are not classes
• Static members
• Non-private fields
• Wildcard-types
• Ternary-operator a ? b : c

Basically for me less thinking required to write kotlin equivalent to most java code:

data class

• java: you have to write getters and setters for each thing, you have to write hashCode properly (or let IDE auto generate, which you have to do again every time you change the class), toString (same problem as hashcode) and equals (same problem as hashCode). or you could use lombok, but that comes with some quirky problems of its own. record types are hopefully on the way. *kotlin: data class does it all for you.

getter and setter patterns

• java: rewrite the getter and setter for each variable you use it for

• kotlin: don't have to write getter and setter, and custom getter and setter take a lot less typing in kotlin if you do want to. also delegates exist for identical getters\setters

abstract vs open classes

• java: you have to make an abstract class implementation

• kotlin: open class lets you make an inheritable class while also being usable itself. nice mix of interface and regular class imo

extension functions

• java: doesnt exist

• kotlin: does exist, makes functions more clear in usage and feels more natural.

null

• java: Anything but primitives can be null at any time.

• kotlin: you get to decide what can and cant be null. allows for nice things like inline class

singleton

• java: Memorize singleton pattern

• kotlin: object instead of class

generics

• java: Theyre alright, nothing fancy

• kotlin: Reified generics (you can access the actual type), in and out for covariance

named parameters

• java: does not exist, easy to break api back-compatibility if you arent careful.

• kotlin: does exist, easy to preserve api back-compatiblity.

primary constructor

• java: does not have per-se, you still have to define everything inside the class

• kotlin: very nice to be able to quickly write a constructor without any constructor function or extra needless declarations

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.

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).

Unlike Java or C#, Kotlin doesn’t have static members or member functions. If you need to write a function that can be called without having a class instance but needs access to the internals of a class, you can write it as a member of a companion object declaration inside that class.

class EventManager {

    companion object FirebaseManager {
    }  
}

val firebaseManager = EventManager.FirebaseManager

The companion object is a singleton. The companion object is a proper object on its own, and can have its own supertypes - and you can assign it to a variable and pass it around. If you're integrating with Java code and need a true static member, you can annotate a member inside a companion object with @JvmStatic.

The not-null assertion operator !! converts any value to a non-null type and throws a KotlinNullPointerException exception if the value is null.

Consider:

fun main(args: Array<String>) {
    var email: String?
    email = null
    println(email!!)
}

This operator should be used in cases where the developer is guaranteeing – it allows you to be 100% sure that its value is not null.

• A blocking call to a function means that a call to any other function, from the same thread, will halt the parent’s execution. Following up, this means that if you make a blocking call on the main thread’s execution, you effectively freeze the UI. Until that blocking calls finishes, the user will see a static screen, which is not a good thing.

• Suspending doesn’t necessarily block your parent function’s execution. If you call a suspending function in some thread, you can easily push that function to a different thread. In case it is a heavy operation, it won’t block the main thread. If the suspending function has to suspend, it will simply pause its execution. This way you free up its thread for other work. Once it’s done suspending, it will get the next free thread from the pool, to finish its work.

The major difference from usage side is that Arrays have a fixed size while (Mutable)Listcan adjust their size dynamically. Moreover Array is mutable whereas List is not.

Furthermore kotlin.collections.List is an interface implemented among others by java.util.ArrayList. It's also extended by kotlin.collections.MutableListto be used when a collections that allows for item modification is needed.

On the jvm level Array is represented by arrays. List on the other hand is represented by java.util.List since there are no immutable collections equivalents available in Java.

consts are compile time constants. Meaning that their value has to be assigned during compile time, unlike vals, where it can be done at runtime.

This means, that consts can never be assigned to a function or any class constructor, but only to a String or primitive.

For example:

const val foo = complexFunctionCall()   //Not okay
val fooVal = complexFunctionCall()      //Okay
 
const val bar = "Hello world"           //Also okay

• The open keyword means “open for extension“. The open annotation on a class is the opposite of Java's final: it allows others to inherit from this class.
• If you do not specify any visibility modifier, public is used by default, which means that your declarations will be visible everywhere. public is the default if nothing else is specified explicitly.

Place the function in the companion object.

class Foo {
  public static int a() { return 1; }
}

will become:

class Foo {
  companion object {
     fun a() : Int = 1
  }
}

// to run
Foo.a();

Another way is to solve most of the needs for static functions with package-level functions. They are simply declared outside a class in a source code file. The package of a file can be specified at the beginning of a file with the package keyword. Under the hood these "top-level" or "package" functions are actually compiled into their own class. In the above example, the compiler would create a class FooPackage with all of the top-level properties and functions, and route all of your references to them appropriately.

Consider:

package foo

fun bar() = {}

usage:

import foo.bar

The purpose is the same as C's or Java's void. Only Unit is a proper type, so it can be passed as a generic argument etc.

1. Why we don't call it "Void": because the word "void" means "nothing", and there's another type, Nothing, that means just "no value at all", i.e. the computation did not complete normally (looped forever or threw an exception). We could not afford the clash of meanings.

2. Why Unit has a value (i.e. is not the same as Nothing): because generic code can work smoothly then. If you pass Unit for a generic parameter T, the code written for any T will expect an object, and there must be an object, the sole value of Unit.

3. How to access that value of Unit: since it's a singleton object, just say Unit

4. UNIT actually contains valuable information, it basically just means "DONE". It just returns the information to the caller, that the method has been finished.

For lazy the first time you access the Lazy property, the initialisation (lazy() function invocation) takes place. The second time, this value is remembered and returned:

I am computing this value
Hola
Hola

There are some simple rules to determined if you should use one or the other for properties initialisation:

• If properties are mutable (i.e. might change at a later stage) use lateInit
• If properties are set externally (e.g. need to pass in some external variable to set it), use lateinit. There’s still workaround to use lazy but not as direct.
• If they are only meant to initialized once and shared by all, and it’s more internally set (dependent on variable internal to the class), then use lazy. Tactically, you could still use lateinit, but using lazy would better encapsulate your initialization code.

Also compare:

The Elvis operator is part of many programming languages, e.g. Kotlin but also Groovy or C#. The Elvis operator is the ternary operator with its second operand omitted.

x ?: y // yields `x` if `x` is not null, `y` otherwise.

If x isn't null, then it will be returned. If it is null, then the y will be returned.