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;

In Java an array can be initialized such as:

 int numbers[] = new int[] {10, 20, 30, 40, 50}

How does Kotlin's array initialization look like?

How to remove duplicates from an Array<String?> in Kotlin?

Use the distinct extension function:

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.

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"

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

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:

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.

In Kotlin, you can concatenate 1. using string interpolation / templates

val a = "Hello"
val b = "World"
val c = "$a $b"

2. using the + / plus() operator

   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

   val a = "Hello"
   val b = "World"
   
   val sb = StringBuilder()
   sb.append(a).append(b)
   val c = sb.toString()
   print(c)

• 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;               |
+----------------+-----------------------------+---------------------------+

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.

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

Mutable and immutable list increase the design clarity of the model.
This is to force developer to think and clarify the purpose of collection.

1. If the collection will change as part of design, use mutable collection
2. If model is meant only for viewing, use immutable list

Purpose of val and var is different from immutable and mutable list.
val and var keyword talk about the how a value/reference of a variable should be treated.

• var - value/reference assigned to a variable can be changed at any point of time.
• val - value/reference can be assigned only once to a variable and can't be changed later point in the execution.

There are several reasons why immutable objects are often preferable:

• They encourage functional programming, where state is not mutated, but passed on to the next function which creates a new state based on it. This is very well visible in the Kotlin collection methods such as map, filter, reduce, etc.
• A program without side effects is often easier to understand and debug (you can be sure that the value of an object will always be the one at its definition).
• In multithreaded programs, immutable resources cannot cause race conditions, as no write access is involved.

You have also some disadvantages:

• Copying entire collections just to add/remove a single element is computationally expensive.
• In some cases, immutability can make the code more complex, when you tediously need to change single fields. In Kotlin, data classes come with a built-in copy() method where you can copy an instance, while providing new values for only some of the fields.

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

Extensions do not actually modify classes they extend. By defining an extension, you do not insert new members into a class, but merely make new functions callable with the dot-notation on variables of this type.

The extension functions dispatched statically. That means the extension function which will be called is determined by the type of the expression on which the function is invoked, not by the type of the result of evaluating that expression at runtime. In short, they are not virtual by receiver type.

Consider:

open class BaseClass

class DerivedClass : BaseClass()
fun BaseClass.someMethod(){
print("BaseClass.someMethod")
}
fun DerivedClass.someMethod(){
print("DerivedClass.someMethod")
}
fun printMessage(base : BaseClass){
base.someMethod()
}
printMessage(DerivedClass())

This will print

BaseClass.someMethod

because the extension function being called depends only on the declared type of the parameter base in printMessage method, which is the BaseClass class. This is different from runtime polymorphism as here it is resolved statically but not at the runtime.

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