Kotlin - JVM language, Statically Typed, Object oriented, Functional

DataTypes - Var and val are used to declare variable in Kotlin

fun main(args: Array<String>) {

// In Kotlin, we don’t require usage of class explicitly to make our application run

val myNumber = 10 // Int -> explicit declaration of Int not required for Initialization
var myDecimal = 1.0 // Float
var isActive = true // Boolean

var myString: String // Mutable String & for declaration explicit type need to mention
myString = "Hello World"
myString = "Another World" // var <-> mutable, val <-> Immutable

val myAnotherString = "My constant string value" // Immutable String

// myAnotherString = "some value" // NOT ALLOWED, since val is immutable

print(myNumber)
}

To Pass a parameter to another function present inside class

fun main(args: Array<String>) {

val name = "Vivek"

var personObj = Person()
personObj.display(name)
}
// Parameters inside method -> fun methodName (variableName: dataType)
class Person{
fun display(name: String)
{
print(name)
}
}
String Interpolation

fun main(args: Array<String>) {

var name = "vivek"

println("The name of the student is " + name)
println("The name of the student is $name")

var str = "hello " + name

var str1 = "hello $name" // we can use $ sign instead of +
println(str) // hello vivek
println(str1) // hello vivek

println("Str name is $str and length is ${str.length}") //Str name is hello vivek and length is 11

val a = 10
val b = 5
println("The sum of $a and $b is ${a + b}") // The sum of 10 and 5 is 15

Double Dot Operators : Ranges used in loops

fun main(args: Array<String>) {

var r1 = 1..5 // The range contains the number 1,2,3,4,5

// var r2 = 5..1 -> doesn't have like this for decreasing use downTo
var r2 = 5 downTo 1 // The range contains the number 5,4,3,2,1

var r3 = 5 downTo 1 step 2 // The range contains 5,3,1 - two values has difference of 2

var r4 = 'a'..'z' // The range contains values "a" , "b" , "c" .... "Z"

var isPresent = 'c' in r4

println(isPresent) // prints true

var r5 = 1.rangeTo(10)

var r6 = 10.downTo(1) // instead of double dot I used downTo and rangeTO

var r6 = 10.downTo(1) step 3 // The range contains 10,7,4,1

}
IF as Expression

fun main(args: Array<String>) {

var a = 2
var b = 5
var maxValue: Int
if (a > b)
maxValue = a
else
maxValue = b
println(maxValue) // prints 5

var max: Int = if (a > b) // In kotlin we can directly assign the value from If
a
else
b
println(max) // prints 5
}

When as Expression

fun main(args: Array<String>) {

var x = 3
when (x) // in c and Java we have switch but in Kotlin we use when
{
1 -> println("x is 1") // ( case 1: ) in java in kotlin ( 1 -> )
2 -> println("x is 2")
in 3..20 -> println("x in between 3 and 20") // ranges can also be used
else -> {
println("x is unknown") // If we have multiple statements put that in block
println("x is $x") // Instead of default we use else
}
}
}
For Loop

fun main(args: Array<String>) {

var a = 1..10
for(i in a)
println(i) // prints 1 to 10

for(i in a step 2)
println(i) // prints 1,3,5,7,9 because we used step 2 so increment by 2
}

fun main(args: Array<String>) {

myLoop@ for (i in 1..3) //break the loop using @

for (j in 1..3) {
println("$i $j")
if (i == 2 && j == 2)
break@myLoop;
}
}

Function as Expression

fun main(args: Array<String>) {

var larger = greater(3, 5)

println("greater of two $larger")
}

fun greater(a: Int, b: Int): Int = if (a > b) {

a
} else {
b
}
Interoperability - Accessing Kotlin files in java and Java files in Kotlin

MyFirst.kt

fun main(args: Array<String>) {

println("the area is ${MyJava.area(7, 5)}") // accessing Java function

}

fun greater(a: Int, b: Int): Int {

return if (a > b)
a
else
b
}

MyJava.java

public class MyJava {

public static void main(String[] args) {

int grt = MyFirstKt.greater(10, 7); // accessing kotlin function

System.out.println("The greatest element is " + grt);
}

public static int area(int a, int b) {

return a * b;
}
}

Named Parameters : Pure Kotlin Feature not present in java

fun main(args: Array<String>) {

volume(b = 20, c = 10, a = 30)
}
fun volume(a: Int, b: Int, c: Int = 40) {
println("a = $a") // a =30
println("b = $b") // b =20
println("c = $c") // c= 10
}

// No matter the sequence of parameters inside main if we assign to actual arguments name

Extension Function -
fun main(args: Array<String>) {

var Student = Student()

println("Pass Status : " + Student.isPassed(67))
println("Scholar Status : " + Student.isScholar(67))
}

fun Student.isScholar(marks: Int): Boolean // Extension function of class student

// This function will behave like a function present inside the class student
{
return marks > 95
}

class Student { //our Own Class

fun isPassed(marks: Int): Boolean {

return marks > 40;
}
}

Primary constructor with initializer block

class myClass(name: String, id: Int) { // primary constructor does not have any code
val e_name: String
var e_id: Int
init{ // init block used to initialize the code

e_name = name
e_id = id
println("Name = ${e_name}")
println("Id = ${e_id}")
}
}
fun main(args: Array<String>){
val myclass = myClass ("Ashu", 101)
}

//class myClass(name: String, id: Int) // the name and id can’t be used inside class they just need to used for assigning to
another field variable inside init block (they are not properties of class)
/class myClass(var name: String , val id: Int) // the name and id can be used anywhere in the class

Kotlin Secondary Constructor

class MyClass {

constructor(name: String, id: Int) {

println("Name = ${name}")
println("Id = ${id}")
}
}

fun main(args: Array<String>) {

val myclass = MyClass("Ashu", 101, 2)
}

// var and val is not possible in Secondary constructor these parameters can’t be modified and can’t be used
anywhere

Calling one secondary constructor from another secondary constructor of same class

class MyClass {

constructor(name: String, id: Int) : this(name, id, "mypassword") {

println("this executes next")
println("Name = ${name}")
println("Id = ${id}")
}

constructor(name: String, id: Int, pass: String) {

// this executes first even calling above constructor because of using this() in above constructor

println("this executes first")

println("Name = ${name}")
println("Id = ${id}")
println("Password = ${pass}")
}
}

fun main(args: Array<String>) {

val myclass = MyClass("Ashu", 101)

Visibility Modifiers – public, private, internal, protected

open class Base() {
var a = 1 // public by default
private var b = 2 // private to Base class
protected open val c = 3 // visible to the Base and the Derived class
internal val d = 4 // visible inside the same module
protected fun e() {} // visible to the Base and the Derived class
}

class Derived : Base() {

// a, c, d, and e() of the Base class are visible
// b is not visible
override val c = 9 // c is protected
}

fun main(args: Array<String>) {

val base = Base()
// base.a and base.d are visible
// base.b, base.c and base.e() are not visible
val derived = Derived()
// derived.c is not visible
}

Inheritance: By default Classes are : public & final , For inheritance you need to make class open

open class Parent {

fun fly() {
println("flying...")
}
}

class Child : Parent() {

fun swim() {
println("swimming...")
}
}

fun main(args: Array<String>) {

val duck = Child()
duck.fly() // flying..
duck.swim() // swimming..
}

Inheritance and primary Constructor

open class Employee(name: String, salary: Float) {
init {
println("Name is $name.")
println("Salary is $salary")
}
}

class Programmer(name: String, dept: String, salary: Float) : Employee(name, salary) {

init {
println("Name $name of department $dept with salary $salary.")
}

fun doProgram() {
println("Programming is my passion.")

}
}

fun main(args: Array<String>) {

val obj1 = Programmer("Ashu", "Development", 40000f)
obj1.doProgram()
}

Inheritance and Secondary Constructor

open class Parent {

constructor(name: String, id: Int) {

println("execute super constructor $name: $id")
}
}

class Child : Parent {

constructor(name: String, id: Int, dept: String) : super(name, id) {

print("execute child class constructor with property $name, $id, $dept")
}
}

fun main(args: Array<String>) {

val child = Child("Ashu", 101, "Developer")
}
Method Overriding

open class Bird {

open var colour = "Black"
open fun fly() {
println("Bird is flying...")
}
}

class Parrot : Bird() {

override var colour = "green"
override fun fly() {
super.fly() // calling superclass method
println("Parrot is flying...")
}
}

fun main(args: Array<String>) {

val p = Parrot()
p.fly() // Method overriding - Parrot is flying...
// we have used super in fly() method in derived it prints Bird is f
println(p.colour) // Property overriding - green
}

Abstract Class -All the variables (properties) and member functions of an abstract class are by default non-
abstract. So, if we want to override these members in the child class then we need to use open keyword .

//abstract class
abstract class Employee(val name: String, val experience: Int) { // Non-Abstract
// Property
// Abstract Property (Must be overridden by Subclasses) property can’t be declared
abstract var salary: Double

// Abstract Methods (Must be implemented by Subclasses) method can’t have body

abstract fun dateOfBirth(date: String)

// Non-Abstract Method
fun employeeDetails() {
println("Name of the employee: $name")
println("Experience in years: $experience")
println("Annual Salary: $salary")
 }
}

// derived class
class Engineer(name: String, experience: Int) : Employee(name, experience) {
override var salary = 500000.00
override fun dateOfBirth(date: String) {
println("Date of Birth is: $date")
}
}

fun main(args: Array<String>) {

val eng = Engineer("Praveen", 2)
eng.employeeDetails()
eng.dateOfBirth("02 December 1994")
}

Interface Properties and Methods in interface are abstract by default unlike abstract class (Not abstract by
default), Normal methods are public and open by default but NOT FINAL unlike abstract class (final and public
not open) , supports functionality of multiple inheritance.

fun main(args: Array<String>) {

var myButton = MyButton()
myButton.onTouch()
myButton.onClick()
}

interface MyInterfaceListener { // You cannot create the instance of interface

fun onTouch() // Methods in interface are abstract by default
fun onClick() { // Normal methods are public and open by default but NOT FINAL
println("MyInterfaceListener: onClick")
}
}

interface MySecondInterface { // You cannot create the instance of interface

fun onTouch() { // Normal Method
println("MySecondInterface: onTouch")
}

fun onClick() { // Normal methods are public and open by default but NOT FINAL
println("MySecondInterface: onClick")
 }
}

class MyButton : MyInterfaceListener, MySecondInterface {

override fun onTouch() {
super<MyInterfaceListener>.onClick() // same method in both interface use super keyword
super<MySecondInterface>.onClick()
}

override fun onClick() {

super.onTouch()
}
}

Tailrec Functions - recursion which performs the calculation first, then makes the recursive call

fun main(args: Array<String>) {

var number = 100000000L
var dx = recursivesum(number)
println(dx)
}

tailrec fun recursivesum(n: Long, semiresult: Long = 0): Long {

return if (n <= 0) {
semiresult;
} else {
recursivesum(n - 1, n + semiresult)
}
}

Lambda Expressions

val lambda_name : Data_type = { argument_List -> code_body }

val sum1 = { a: Int, b: Int -> a + b }

// without type annotation in lambda expression

val sum2: (Int, Int) -> Int = { a, b -> a + b }
fun main(args: Array<String>) {
val result1 = sum1(2, 3)
val result2 = sum2(3, 4)
println("The sum of two numbers is: $result1")
println("The sum of two numbers is: $result2")

// directly print the return value of lambda without storing in a variable.

println(sum1(5, 7))
}

val sum1 = { a: Int, b: Int ->

val num = a + b
num.toString() //convert Integer to String
}

fun main(args: Array<String>) {

val result1 = sum1(2, 3)
println("The sum of two numbers is: $result1")
}

Type declaration in lambdas –

We must explicitly declare the type of our lambda expression. If lambda returns no value then we can
use: Unit
Pattern: (Input) -> Output
Lambdas examples with return type –
▪ val lambda1: (Int) -> Int = (a -> a * a)
▪ val lambda2: (String, String) -> String = { a , b -> a + b }
▪ val lambda3: (Int)-> Unit = {print(Int)}

Higher Order Functions - function which can accepts a function as parameter or can returns a function

There are two types of lambda expression which can be passed-

▪ Lambda expression which return Unit -. lmbd: () -> Unit
▪ Lambda expression which return any of the value integer string->.lmbd: (Int, Int) -> Int

// with type annotation in lambda expression

// lambda expressions returns unit and below one returns int
var lambda = { println("GeeksforGeeks: A Computer Science portal for Geeks") }

var lambda1 = { a: Int, b: Int -> a + b }

// higher-order function
fun higherfunc(lmbd: () -> Unit) { // accepting lambda as parameter
lmbd() // invokes lambda expression
}

fun higherfunc1(lmbd: (Int, Int) -> Int) { // accepting lambda as parameter

var result = lmbd(2, 4) // invokes the lambda expression by passing parameters

println("The sum of two numbers is: $result")
}

fun main(args: Array<String>) {

// invoke higher-order function
higherfunc(lambda) // passing lambda as parameter
higherfunc1(lambda1) // passing lambda1 as parameter
}

Anonymous Functions- similar to a regular function except for the name of the function which is omitted
from the declaration. The body of the anonymous function can be either an expression or block.

// anonymous function with body as an expression

val anonymous1 = fun(x: Int, y: Int): Int = x + y

// anonymous function with body as a block

val anonymous2 = fun(a: Int, b: Int): Int {
val mul = a * b
return mul
}

fun main(args: Array<String>) { //invoking functions

val sum = anonymous1(3, 5)
val mul = anonymous2(3, 5)
println("The sum of two numbers is: $sum")
println("The multiply of two numbers is: $mul")

Collections - store group of related objects (List , Set, Map)

Collections are two types:
▪ Immutable - listOf() , mapOf(), setOf()
▪ Mutable - arrayListOf(), mutableListOf(), hashMapOf(), mutableMapOf(), hashSetOf(),
mutablesetOf()

Listof()

fun main(args: Array<String>) { // variable name followed by : follows dataType

var stringList: List<String> = listOf<String>("Ajay", "Vijay", "Prakash", "Vijay", "Rohan")

// var and val are used to declare variable

var intList = listOf<Int>(24, 3, 78, 64) // list is immutable we can't increase or decrease size
for (index in intList) { // $ sign to get direct value instead of concatenation
print("$index,") // prints 24,3,78,64
}

println()
println(stringList.get(0)) // Ajay
println(stringList.indexOf("Vijay")) // 1 -> first Index
println(stringList.lastIndexOf("Vijay")) // 3 -> last Index having vijay
println(stringList.size) // 5 -> size of list
println(stringList.contains("Prakash")) // if contains return true
println(stringList.subList(2, 4)) // [Prakash, Vijay] -> from index 2 to 4 less 1
println(stringList.isEmpty()) // false -> if empty return true
println(stringList.drop(1)) // prints elements in List except last 1
println(stringList.dropLast(2)) // prints elements in List except last 2
println(stringList)

val sortlist = intList.sorted(); // list is mutable we can't apply sorting to list itself
println(sortlist); // [3,24,64,78]
}

ArrayListOf()
import java.util.*
import kotlin.collections.ArrayList

fun main(args: Array<String>) {

var read = Scanner (System.`in`) // to read input from user

var arrayList = ArrayList<String>() //Creating an empty arraylist
arrayList.add("Ajay") //Adding object in arraylist
arrayList.add("Vijay") // arrayList is mutable we can increase or decrease size
arrayList.add("Prakash")
arrayList.add("Rohan") // add elements to list using .add
arrayList.add("Vijay")
println(".......print ArrayList.......")
for (i in arrayList) {
println(i) // prints elements in arrayList
}

println("Enter elements into intList:")

var intList = ArrayList<Int>()
for (i in 0..5) {
intList.add(read.nextInt()) // reading elements from console
}

println(arrayList.size) // 5
println(arrayList.get(2)) // prakash prints index of 2 element in list
arrayList.set(3, "Ashu") // Mutable array we can modify elements
println(arrayList[3]) // prints Ashu
println(arrayList.indexOf("Vijay")) //1 -> first occurence Index having vijay
println(arrayList.lastIndexOf("Vijay")) //4- > last Index having vijay
arrayList.remove("Vijay") // removes vijay of first occurence
// arrayList.removeAt(index)
println(arrayList) // [Ajay, Prakash, Ashu, Vijay] after removing vijay
arrayList.clear() // to clear all elements in arraylist
println(arrayList) // [ empty array ] after clearing all elements

println(intList) // [5, 9, 1, 3, 4, 7]
val a = intList.sortedDescending() // sorted in descending order
println(a) // [9, 7, 5, 4, 3, 1] - > sort in descending order
val itr = intList.iterator() // using iterator for printing elements in list
while (itr.hasNext()) {
println(itr.next())
}
}
MapOf() - key and value pair. Map keys are unique and hold only one value for each key. The key and value may
be of different pairs such as <Int, Int>,<Int, String>, <Char, String>etc. This interface is immutable, fixed size and
its methods support read only access.

fun main(args: Array<String>) {

val myMap = mapOf<Int, String>(1 to "Ajay", 4 to "Vijay", 3 to "Prakash")

for (key in myMap.keys) {
println(myMap[key])
}

println(myMap) // {1=Ajay, 4=Vijay, 3=Prakash}

println(myMap.keys) // [1, 4, 3] -> keys in Map
println(myMap.values) // [Ajay, Vijay, Prakash] -> value sin map
println(myMap.size) // 3 -> size of map
println(myMap.containsKey(3)) // true -> key value of 3 is present
println(myMap.containsValue("Ajay")) // true -> value of ajay present
println(myMap.get(4)) // vijay -> key of 4 present and it prints that value
println(myMap.get(12)) // null -> key of 12 not present

myMap.plus(Pair(5, "Rohan"));
println(myMap) // {1=Ajay, 4=Vijay, 3=Prakash} mutable we can't add to myMap

var list = myMap.plus(5 to "vijay")

println(list) // {1=Ajay, 4=Vijay, 3=Prakash, 5=vijay} we can add to other var

// two values with same key

val map = mapOf(1 to "Vivek", 2 to "for", 1 to "Vivek")
//If two values have same key value , then the map will contain the last value of the those numbers.
println("Entries of map : " + map.entries) //Entries of map : [1=vivek, 2=for]
}
HashMapOf()

import java.util.*
import kotlin.collections.HashMap

fun main(args: Array<String>) {

var read = Scanner(System.`in`)

val stringMap: HashMap<String, String> = hashMapOf<String, String>("name" to "Ashu")
stringMap.put("city", "Delhi")
stringMap.put("department", "Development")
stringMap.put("hobby", "Playing")

val intMap: HashMap<Int, String> = hashMapOf<Int, String>(1 to "Ashu", 2 to "Ajeet")

println("Enter key and value")

for (i in 0..2) {
var key: Int = read.nextInt()
var value: String = read.next() //adding <key, value> pair from input by user
intMap.put(key, value)
}
println("..... intMap........")
for (key in intMap.keys) {
println(intMap[key])
}
println(stringMap.containsKey("name")) // true -> key of "name" present in stringMap
println(stringMap.containsValue("Delhi")) // true -> value of "Delhi" present in stringMap

println(stringMap) // {name=Ashu, department=Development, city=Delhi, hobby=Playing}

stringMap.replace("city", "Mumbai") // replaces value of key(if present)with new one
println(stringMap) // {name=Ashu, department=Development, city=Mumbai, hobby=Playing}

println(stringMap.size) // 4 -> size of Map

stringMap.remove("city") // remove <key,value> pair of key(city) from Map

println(stringMap) // {name=Ashu, department=Development, hobby=Playing}

stringMap.set("name", "vivek") // {name=vivek, department=Development, hobby=Playing}

println(stringMap) // set value for key(if present)

stringMap.set("skill", "Kotlin") // add <key, value> if key(not present)

println(stringMap) // {name=vivek, department=Development, hobby=Playing, skill=Kotlin}

}
Setof() -unordered collection of elements, does not support duplicate elements.

fun main(args: Array<String>) {

var intSet = setOf(2, 6, 4, 29, 4, 5)
var mySet: Set<Any> = setOf(2, 6, 4, 29, 4, 5, "Ashu", "Ajay")
//set<Any> contains value of any datatype

println(".......print Any set.........")

for (element in mySet) {
println(element) // prints elements in mySet
}

println(mySet.contains("Ashu")) // true -> set contains Ashu return true

println(mySet.containsAll(intSet)) // true -> if all elements of intSet present in any set
println(mySet.isEmpty()) // false -> if set is empty

val remainList = mySet.drop(4) // drops first 4 elements from set and copy all other to remainList
println(remainList) // [5, Ashu, Ajay]

println(mySet.elementAt(3)) // 29 -> prints element at particular index

println(mySet.first()) // 2 -> prints first element in set

println(mySet.last()) //Ajay -> prints last element in set
}
HashSetOf()

import java.util.*
import kotlin.collections.HashSet

fun main(args: Array<String>) {

var read = Scanner(System.`in`)

var hashSet = HashSet<Int>()

println("Enter elements")
for (i in 0..2) {
hashSet.add(read.nextInt()) // reading input from user
}

println("......hashSet......")
for (element in hashSet) {
println(element)
}

val intSet = setOf(6, 4, 29)

hashSet.addAll(intSet)
println(hashSet) // [1, 2, 4, 6, 8, 29] -> after adding intSet

println(hashSet.size) // 6 -> size of hashset

println(hashSet.contains(13)) // false -> if 6 presents in hashSet return true
println(hashSet.containsAll(intSet)) // true -> if all elements in intSet present in hashSet returns true

hashSet.remove(2)
hashSet.removeAll(intSet)
println(hashSet) // [1, 8] - > after removing intList and (remove(2))

println(hashSet.isEmpty()) // false -> returns true if hashSet is Empty

}