Kotlin Tutorial – Learn Kotlin Programming Online

The Kotlin Tutorial explains both the fundamental and more complex Kotlin principles. It is intended for both beginners and experts to learn the Kotlin Tutorial online. The trend of naming programming languages after islands was started by Java, and it is carried on by Kotlin. Compared to many other programming languages, Kotlin is intended to be safer, simpler to comprehend and write, and both. The language, compiler, and related tools are entirely open source and free to use in accordance with the Apache 2 license.

Kotlin Tutorial for Beginners

What is Kotlin?

The primary goals of the Kotlin language are to make code safe and concise. A piece of code is frequently considered brief when it is easy to read and comprehend. Conciseness when writing code also contributes to its effectiveness and speed.

Kotlin has a number of safety-related features that make it more likely that potential problems may be discovered when the code is being written rather than leading to runtime crashes.

Java, which Sun Microsystems originally made available in 1995, is still by far the most popular programming language in use today. Up until the introduction of Kotlin, it’s probable that every Android app available on the market was made in Java. Since acquiring the Android operating system, Google has made considerable efforts in fine-tuning and improving the compilation and runtime environments for running Java-based code on Android-powered devices.

Kotlin Overview

Kotlin is a language by JetBrains, the company behind IntelliJ IDEA and other  tools, and is purpose built for large-scale software projects to improve upon Java with a focus on readability, correctness, and developer productivity.

In response to Java’s limitations, which were limiting the development of JetBrains’ software products, and after an evaluation found that none of the other JVM languages were suitable, the Kotlin language was created. Because its primary goal was to be utilized to better their products, Kotlin places a strong emphasis on interoperability with Java code and the Java standard library.

Kotlin Features 

The main focus on interoperability in the Kotlin language and runtime is its most important feature. Idiomatic Kotlin should be able to call Java and have Java call into Kotlin with ease, unlike other JVM alternatives. Scala is a good example of this. In actuality, you shouldn’t even be conscious of crossing the line. The runtime for Kotlin is highly condensed and only serves the language’s features.

We can identify some of the Kotlin features that are most valuable to Android and resolve particular, recurring issues that afflict client application development.

Kotlin Tutorial : Arrays

Generic arrays in Kotlin are represented by Array<T>.

To create an empty array, use emptyArray<T>() factory function:

val empty = emptyArray<String>()

To create an array with given size and initial values, use the constructor:

var strings = Array<String>(size = 5, init = { index -> "Item #$index" })
print(Arrays.toString(a)) // prints "[Item #0, Item #1, Item #2, Item #3, Item #4]"
print(a.size) // prints 5

Arrays have get(index: Int): T and set(index: Int, value: T) functions:

strings.set(2, "ChangedItem")
print(strings.get(2)) // prints "ChangedItem"

// You can use subscription as well:
strings[2] = "ChangedItem"
print(strings[2]) // prints "ChangedItem"

Kotlin -Arrays of Primitives

These types do not inherit from Array<T> to avoid boxing, however, they have the same attributes and methods.

       Kotlin type               Factory function                  JVM type

• BooleanArray            booleanArrayOf(true, false)   boolean[]
• ByteArray                   byteArrayOf(1, 2, 3)                 byte[]
• CharArray                  charArrayOf(‘a’, ‘b’, ‘c’)            char[]
• DoubleArray             doubleArrayOf(1.2, 5.0)           double[]
• FloatArray                 floatArrayOf(1.2, 5.0)               float[]
• IntArray                     intArrayOf(1, 2, 3)                     int[]
• LongArray                 longArrayOf(1, 2, 3)                  long[]
• ShortArray                shortArrayOf(1, 2, 3)                 short[]

Kotlin -Create Array

val a = arrayOf(1, 2, 3) // creates an Array<Int> of size 3 containing [1, 2, 3].

Kotlin -Create Array using Closure

val a = Array(3) { i -> i * 2 } // creates an Array<Int> of size 3 containing [0, 2, 4]

Kotlin – Create an uninitialized array

val a = arrayOfNulls<Int>(3) // creates an Array<Int?> of [null, null, null]

The returned array will always have a nullable type. Arrays of non-nullable items can’t be created uninitialized.

Kotlin Tutorial : Collections

Kotlin distinguishes between mutable and immutable collections (lists, sets, maps, etc.) in order to contrast with many other languages.

It’s helpful to have precise control over when collections can be updated when creating effective APIs and removing problems.

Collections using List

// Create a new read-only List<String>
val list = listOf("Item 1", "Item 2", "Item 3")
println(list) // prints "[Item 1, Item 2, Item 3]"

Collections using Map

// Create a new read-only Map<Integer, String>
val map = mapOf(Pair(1, "Item 1"), Pair(2, "Item 2"), Pair(3, "Item 3"))
println(map) // prints "{1=Item 1, 2=Item 2, 3=Item 3}"

Collections using Set

// Create a new read-only Set<String>
val set = setOf(1, 3, 5)
println(set) // prints "[1, 3, 5]"

Kotlin Tutorial : Functions

     Parameter           Details

• Name                   Name of the function
• Params                 Values given to the function with a name and type: Name:Type
• Type                      Return type of the function
• Type Argument   Type parameter used in generic programming (not necessarily return type)
• ArgName              Name of value given to the function
• ArgType               Type specifier for ArgName
• ArgNames           List of ArgName separated by commas

Basic Functions

Functions are declared with the fun keyword, which is then followed by the function name and any associated parameters. It is also possible to specify a function’s return type, which is Unit by default. The body of the function is surrounded by braces. If the return type is something other than Unit, the body must emit a return statement for each ending branch.

fun sayMyName(name: String): String {
return "Your name is $name"
}

A shorthand version of the same:

fun sayMyName(name: String): String = "Your name is $name"

And the type can be omitted since it can be inferred:

fun sayMyName(name: String) = "Your name is $name"

Inline Functions

Function declarations can be made inline by using the inline prefix. In this situation, they operate similarly to C macros and are replaced at compilation time by the function’s body code rather than being called. When lambdas are used as function parameters, this occasionally leads to enhanced performance.

inline fun sayMyName(name: String) = "Your name is $name"

One difference from C macros is that inline functions can’t access the scope from which they’re called:

inline fun sayMyName() = "Your name is $name"
fun main() {
val name = "Foo"
sayMyName() # => Unresolved reference: name
}

Lambda Functions

Lambda functions, which act as function parameters, are anonymous functions that are typically formed during a function call. If arguments are required, they should be placed before the arrow ->. They are stated by enclosing expressions in braces.

{ name: String ->
"Your name is $name" //This is returned
}

The last statement inside a lambda function is automatically the return value.

The type’s are optional, if you put the lambda on a place where the compiler can infer the types.

Multiple arguments:

{ argumentOne:String, argumentTwo:String ->
"$argumentOne - $argumentTwo"
}

If the lambda function only needs one argument, then the argument list can be omitted and the single argument be referred to using it instead.

{ "Your name is $it" }

If the only argument to a function is a lambda function, then parentheses can be completely omitted from the function call.

# These are identical
listOf(1, 2, 3, 4).map { it + 2 }
listOf(1, 2, 3, 4).map({ it + 2 })

Operator Functions

Kotlin-only implementations are possible for a predetermined set of operators with fixed symbolic representation (like + or *) and fixed precedence.

To implement an operator, we provide a member function or an extension function with a fixed name for the corresponding type. Functions that overload operators must be identified using the operator modifier.

data class IntListWrapper (val wrapped: List<Int>) {
operator fun get(position: Int): Int = wrapped[position]
}
val a = IntListWrapper(listOf(1, 2, 3))
a[1] // == 2