Author: Pooja Kotwani

Kotlin Annotations Overview

In Kotlin, annotations provide a way to attach metadata to code. This metadata can then be used by development tools, libraries, or frameworks to process the code without altering its behavior. Annotations are applied to code elements such as classes, functions, properties, or parameters and are typically evaluated at compile-time.

Annotations frequently contain the following parameters, which must be compile-time constants:

1. Primitive types (e.g., Int, Long, etc.)
2. Strings
3. Enumerations
4. Classes
5. Other annotations
6. Arrays of the types mentioned above

Applying Annotations

To apply an annotation, simply use the annotation name prefixed with the @ symbol before the code element you wish to annotate. For example:

@Positive val number: Int

If an annotation accepts parameters, these can be passed inside parentheses, much like a function call:

@AllowedLanguage("Kotlin")

When passing another annotation as a parameter to an annotation, omit the @ symbol. For instance:

@Deprecated("Use === instead", ReplaceWith("this === other"))

When using class objects as parameters, use ::class:

@Throws(IOException::class)

An annotation that requires parameters looks similar to a class with a primary constructor:

annotation class Prefix(val prefix: String)

Annotating Specific Elements

1. Annotating a Constructor : You can annotate class constructors by using the constructor keyword:

class MyClass @Inject constructor(dependency: MyDependency) {
    // ...
}

2. Annotating a Property : Annotations can be applied to properties within a class. For example:

class Language(
    @AllowedLanguages(["Java", "Kotlin"]) val name: String
)

Built-in Annotations in Kotlin

Kotlin provides several built-in annotations that offer additional functionality. These annotations are often used to annotate other annotations.

1. @Target: The @Target annotation specifies where an annotation can be applied, such as classes, functions, or parameters. For example:

@Target(AnnotationTarget.CONSTRUCTOR, AnnotationTarget.LOCAL_VARIABLE)
annotation class CustomAnnotation

class Example @CustomAnnotation constructor(val number: Int) {
    fun show() {
        println("Constructor annotated with @CustomAnnotation")
        println("Number: $number")
    }
}

fun main() {
    val example = Example(5)
    example.show()

    @CustomAnnotation val message: String
    message = "Hello Kotlin"
    println("Local variable annotated")
    println(message)
}

Output:

Constructor annotated with @CustomAnnotation
Number: 5
Local variable annotated
Hello Kotlin

2. @Retention: The @Retention annotation controls how long the annotation is retained. It can be retained in the source code, in the compiled class files, or even at runtime. The parameter for this annotation is an instance of the AnnotationRetention enum:

• SOURCE
• BINARY
• RUNTIME

Example:

@Retention(AnnotationRetention.RUNTIME)
annotation class RuntimeAnnotation

@RuntimeAnnotation
fun main() {
    println("Function annotated with @RuntimeAnnotation")
}

Output:

Function annotated with @RuntimeAnnotation

3. @Repeatable: The @Repeatable annotation allows multiple annotations of the same type to be applied to an element. This is currently limited to source retention annotations in Kotlin.

Example:

@Repeatable
@Retention(AnnotationRetention.SOURCE)
annotation class RepeatableAnnotation(val value: Int)

@RepeatableAnnotation(1)
@RepeatableAnnotation(2)
fun main() {
    println("Multiple @RepeatableAnnotation applied")
}

Output:

Multiple @RepeatableAnnotation applied

Kotlin Reflection

Reflection is a powerful feature that allows a program to inspect and modify its structure and behavior at runtime. Kotlin provides reflection through its kotlin.reflect package, allowing developers to work with class metadata, access members, and use features like functions and property references. Kotlin reflection is built on top of the Java reflection API but extends it with additional features, making it more functional and flexible.

Key Features of Kotlin Reflection

• Access to Properties and Nullable Types: Kotlin reflection enables access to both properties and nullable types.
• Enhanced Features: Kotlin reflection offers more features than Java reflection.
• Interoperability with JVM: Kotlin reflection can seamlessly access and interact with JVM code written in other languages.

Class References in Kotlin Reflection

To obtain a class reference in Kotlin, you can use the class reference operator ::class. Class references can be obtained both statically from the class itself or dynamically from an instance. When acquired from an instance, these are known as bounded class references, which point to the exact runtime type of the object.

Example: Class References

// Sample class
class ReflectionSample

fun main() {
    // Reference obtained using class name
    val classRef = ReflectionSample::class
    println("Static class reference: $classRef")

    // Reference obtained using an instance
    val instance = ReflectionSample()
    println("Bounded class reference: ${instance::class}")
}

Output:

Static class reference: class ReflectionSample
Bounded class reference: class ReflectionSample

Function References

In Kotlin, you can obtain a reference to any named function by using the :: operator. Function references can be passed as parameters or stored in variables. When dealing with overloaded functions, you may need to specify the function type explicitly.

Example: Function References

fun sum(a: Int, b: Int): Int = a + b
fun concat(a: String, b: String): String = "$a$b"

fun isEven(a: Int): Boolean = a % 2 == 0

fun main() {
    // Function reference for a single function
    val isEvenRef = ::isEven
    val numbers = listOf(1, 2, 3, 4, 5, 6)
    println(numbers.filter(isEvenRef))

    // Function reference for an overloaded function (explicit type)
    val concatRef: (String, String) -> String = ::concat
    println(concatRef("Hello, ", "Kotlin!"))

    // Implicit function reference usage
    val result = sum(3, 7)
    println(result)
}

Output:

[2, 4, 6]
Hello, Kotlin!
10

Property References

Property references allow you to work with properties just like you do with functions. You can retrieve the property value using the get function, and you can modify it using set if it’s mutable.

Example: Property References

class SampleProperty(var value: Double)

val x = 42

fun main() {
    // Property reference for a top-level property
    val propRef = ::x
    println(propRef.get()) // Output: 42
    println(propRef.name)  // Output: x

    // Property reference for a class property
    val classPropRef = SampleProperty::value
    val instance = SampleProperty(12.34)
    println(classPropRef.get(instance))  // Output: 12.34
}

Output:

42
x
12.34

Nested Class Property - Function Executed

Constructor References

Constructor references in Kotlin allow you to reference the constructor of a class in a similar manner to functions and properties. These references can be used to invoke constructors dynamically.

Example: Constructor References

class SampleClass(val value: Int)

fun main() {
    // Constructor reference
    val constructorRef = ::SampleClass
    val instance = constructorRef(10)
    println("Value: ${instance.value}")  // Output: Value: 10
}

Output:

Value: 10

Operator Overloading

In Kotlin, you have the flexibility to overload standard operators to work seamlessly with user-defined types. This means that you can provide custom behavior for operators like +, -, *, and more, making code that uses your custom types more intuitive. Kotlin allows overloading for unary, binary, relational, and other operators by defining specific functions using the operator keyword.

Unary Operators

Unary operators modify a single operand. The corresponding functions for unary operators must be defined in the class that they will operate on.

Operator Expression	Corresponding Function
+x, -x	x.unaryPlus(), x.unaryMinus()
!x	x.not()

Here, x is the instance on which the operator is applied.

Example: Unary Operator Overloading

class UnaryExample(var message: String) {
    // Overloading the unaryMinus operator
    operator fun unaryMinus() {
        message = message.reversed()
    }
}

fun main() {
    val obj = UnaryExample("KOTLIN")
    println("Original message: ${obj.message}")

    // Using the overloaded unaryMinus function
    -obj
    println("After applying unary operator: ${obj.message}")
}

Output:

Original message: KOTLIN
After applying unary operator: NILTOK

Increment and Decrement Operators

Increment (++) and decrement (--) operators can be overloaded using the following functions. These functions typically return a new instance after performing the operation.

Operator Expression	Corresponding Function
++x or x++	x.inc()
--x or x--	x.dec()

Example: Increment and Decrement Operator Overloading

class IncDecExample(var text: String) {
    // Overloading the increment function
    operator fun inc(): IncDecExample {
        return IncDecExample(text + "!")
    }

    // Overloading the decrement function
    operator fun dec(): IncDecExample {
        return IncDecExample(text.dropLast(1))
    }

    override fun toString(): String {
        return text
    }
}

fun main() {
    var obj = IncDecExample("Hello")
    println(obj++)  // Output: Hello
    println(obj)    // Output: Hello!
    println(obj--)  // Output: Hello
    println(obj)    // Output: Hello
}

Output:

Hello
Hello!
Hello
Hello

Binary Operators

Binary operators operate on two operands. The following table shows how to define functions for common binary operators.

Operator Expression	Corresponding Function
x1 + x2	x1.plus(x2)
x1 - x2	x1.minus(x2)
x1 * x2	x1.times(x2)
x1 / x2	x1.div(x2)
x1 % x2	x1.rem(x2)

Example: Overloading the + Operator

class DataHolder(var name: String) {
    // Overloading the plus operator
    operator fun plus(number: Int) {
        name = "Data: $name, Number: $number"
    }

    override fun toString(): String {
        return name
    }
}

fun main() {
    val obj = DataHolder("Info")
    obj + 42  // Calling the overloaded plus operator
    println(obj)  // Output: Data: Info, Number: 42
}

Output:

Data: Info, Number: 42

Other Operators

Kotlin provides the flexibility to overload a wide variety of operators, some of which include range, contains, indexing, and invocation.

Operator Expression	Corresponding Function
x1 in x2	x2.contains(x1)
x[i]	x.get(i)
x[i] = value	x.set(i, value)
x()	x.invoke()
x1 += x2	x1.plusAssign(x2)

Example: Overloading the get Operator for Indexing

class CustomList(val items: List<String>) {
    // Overloading the get operator to access list items
    operator fun get(index: Int): String {
        return items[index]
    }
}

fun main() {
    val myList = CustomList(listOf("Kotlin", "Java", "Python"))
    println(myList[0])  // Output: Kotlin
    println(myList[2])  // Output: Python
}

Output:

Kotlin
Python

Destructuring Declarations in Kotlin

Kotlin offers a distinctive way of handling instances of a class through destructuring declarations. A destructuring declaration lets you break down an object into multiple variables at once, making it easier to work with data.

Example:

val (id, pay) = employee

In this example, id and pay are initialized using the properties of the employee object. These variables can then be used independently in the code:

println("$id $pay")

Destructuring declarations rely on component() functions. For each variable in a destructuring declaration, the corresponding class must provide a componentN() function, where N represents the variable’s position (starting from 1). In Kotlin, data classes automatically generate these component functions.

Destructuring Declaration Compiles to:

val id = employee.component1()
val pay = employee.component2()

Example: Returning Two Values from a Function

// Data class example
data class Info(val title: String, val year: Int)

// Function returning a data class
fun getInfo(): Info {
    return Info("Inception", 2010)
}

fun main() {
    val infoObj = getInfo()
    // Accessing properties using the object
    println("Title: ${infoObj.title}")
    println("Year: ${infoObj.year}")

    // Using destructuring declaration
    val (title, year) = getInfo()
    println("Title: $title")
    println("Year: $year")
}

Output:

Title: Inception
Year: 2010
Title: Inception
Year: 2010

Underscore for Unused Variables

Sometimes you may not need all the variables in a destructuring declaration. To skip a variable, you can replace its name with an underscore (_). In this case, the corresponding component function is not called.

Destructuring in Lambdas

As of Kotlin 1.1, destructuring declarations can also be used within lambda functions. If a lambda parameter is of type Pair or any type that provides component functions, you can destructure it within the lambda.

Example: Destructuring in Lambda Parameters

fun main() {
    val people = mutableMapOf<Int, String>()
    people[1] = "Alice"
    people[2] = "Bob"
    people[3] = "Charlie"

    println("Original map:")
    println(people)

    // Destructuring map entry into key and value
    val updatedMap = people.mapValues { (_, name) -> "Hello $name" }
    println("Updated map:")
    println(updatedMap)
}

Output:

Original map:
{1=Alice, 2=Bob, 3=Charlie}
Updated map:
{1=Hello Alice, 2=Hello Bob, 3=Hello Charlie}

In this example, the mapValues function uses destructuring to extract the value and update it. The underscore (_) is used for the key, as it is not needed.

Equality evaluation

Kotlin offers a distinct feature that allows comparison of instances of a particular type in two different ways. This feature sets Kotlin apart from other programming languages. The two types of equality in Kotlin are:

Structural Equality

Structural equality is checked using the == operator and its inverse, the != operator. By default, when you use x == y, it is translated to a call of the equals() function for that type. The expression:

x?.equals(y) ?: (y === null)

It means that if x is not null, it calls the equals(y) function. If x is null, it checks whether y is also referentially equal to null. Note: When x == null, the code automatically defaults to referential equality (x === null), so there’s no need to optimize the code in this case. To use == on instances, the type must override the equals() function. For example, when comparing strings, the structural equality compares their contents.

Referential Equality

Referential equality in Kotlin is checked using the === operator and its inverse !==. This form of equality returns true only when both instances refer to the same location in memory. When used with types that are converted to primitive types at runtime, the === check is transformed into ==, and the !== check is transformed into !=.

Here is a Kotlin program to demonstrate structural and referential equality:

class Circle(val radius: Int) {
    override fun equals(other: Any?): Boolean {
        if (other is Circle) {
            return other.radius == radius
        }
        return false
    }
}

// main function
fun main(args: Array<String>) {
    val circle1 = Circle(7)
    val circle2 = Circle(7)

    // Structural equality
    if (circle1 == circle2) {
        println("Two circles are structurally equal")
    }

    // Referential equality
    if (circle1 !== circle2) {
        println("Two circles are not referentially equal")
    }
}

Output:

Two circles are structurally equal
Two circles are not referentially equal

Comparator

In programming, when defining a new type, there’s often a need to establish an order for its instances. To compare instances, Kotlin provides the Comparable interface. However, for more flexible and customizable ordering based on different parameters, Kotlin offers the Comparator interface. This interface compares two objects of the same type and arranges them in a defined order.

Functions

• compare: This method compares two instances of a type. It returns 0 if both are equal, a negative number if the second instance is greater, or a positive number if the first instance is greater.

abstract fun compare(a: T, b: T): Int

Extension Functions

• reversed: This function takes a comparator and reverses its sorting order.

fun <T> Comparator<T>.reversed(): Comparator<T>

• then: Combines two comparators. The second comparator is only used when the first comparator considers the two values to be equal.

infix fun <T> Comparator<T>.then(comparator: Comparator<in T>): Comparator<T>

Example demonstrating compare, then, and reversed functions:

// A simple class representing a car
class Car(val make: String, val year: Int) {
    override fun toString(): String {
        return "$make ($year)"
    }
}

// Comparator to compare cars by make
class MakeComparator : Comparator<Car> {
    override fun compare(o1: Car?, o2: Car?): Int {
        if (o1 == null || o2 == null) return 0
        return o1.make.compareTo(o2.make)
    }
}

// Comparator to compare cars by year
class YearComparator : Comparator<Car> {
    override fun compare(o1: Car?, o2: Car?): Int {
        if (o1 == null || o2 == null) return 0
        return o1.year.compareTo(o2.year)
    }
}

fun main() {
    val cars = arrayListOf(
        Car("Toyota", 2020),
        Car("Ford", 2018),
        Car("Toyota", 2015),
        Car("Ford", 2022),
        Car("Tesla", 2021)
    )

    println("Original list:")
    println(cars)

    val makeComparator = MakeComparator()
    // Sorting cars by make
    cars.sortWith(makeComparator)
    println("List sorted by make:")
    println(cars)

    val yearComparator = YearComparator()
    val combinedComparator = makeComparator.then(yearComparator)
    // Sorting cars by make, then by year
    cars.sortWith(combinedComparator)
    println("List sorted by make and year:")
    println(cars)

    val reverseComparator = combinedComparator.reversed()
    // Reverse sorting the cars
    cars.sortWith(reverseComparator)
    println("List reverse sorted:")
    println(cars)
}

Output:

Original list:
[Toyota (2020), Ford (2018), Toyota (2015), Ford (2022), Tesla (2021)]
List sorted by make:
[Ford (2018), Ford (2022), Tesla (2021), Toyota (2015), Toyota (2020)]
List sorted by make and year:
[Ford (2018), Ford (2022), Tesla (2021), Toyota (2015), Toyota (2020)]
List reverse sorted:
[Toyota (2020), Toyota (2015), Tesla (2021), Ford (2022), Ford (2018)]

Additional Extension Functions

• thenBy: This function converts the instances of a type to a Comparable and compares them using the transformed values.

fun <T> Comparator<T>.thenBy(selector: (T) -> Comparable<*>?): Comparator<T>

• thenByDescending: Similar to thenBy, but sorts the instances in descending order.

inline fun <T> Comparator<T>.thenByDescending(crossinline selector: (T) -> Comparable<*>?): Comparator<T>

Example demonstrating thenBy and thenByDescending functions:

class Product(val price: Int, val rating: Int) {
    override fun toString(): String {
        return "Price = $price, Rating = $rating"
    }
}

fun main() {
    val comparator = compareBy<Product> { it.price }
    val products = listOf(
        Product(100, 4),
        Product(200, 5),
        Product(150, 3),
        Product(100, 3),
        Product(200, 4)
    )

    println("Sorted first by price, then by rating:")
    val priceThenRatingComparator = comparator.thenBy { it.rating }
    println(products.sortedWith(priceThenRatingComparator))

    println("Sorted by rating, then by descending price:")
    val ratingThenPriceDescComparator = compareBy<Product> { it.rating }
        .thenByDescending { it.price }
    println(products.sortedWith(ratingThenPriceDescComparator))
}

Output:

Sorted first by price, then by rating:
[Price = 100, Rating = 3, Price = 100, Rating = 4, Price = 150, Rating = 3, Price = 200, Rating = 4, Price = 200, Rating = 5]
Sorted by rating, then by descending price:
[Price = 150, Rating = 3, Price = 100, Rating = 3, Price = 100, Rating = 4, Price = 200, Rating = 4, Price = 200, Rating = 5]

Additional Functions

• thenComparator: Combines a primary comparator with a custom comparison function.

fun <T> Comparator<T>.thenComparator(comparison: (a: T, b: T) -> Int): Comparator<T>

• thenDescending: Combines two comparators and sorts the elements in descending order based on the second comparator if the values are equal according to the first.

infix fun <T> Comparator<T>.thenDescending(comparator: Comparator<in T>): Comparator<T>

Example demonstrating thenComparator and thenDescending functions:

fun main() {
    val pairs = listOf(
        Pair("Apple", 5),
        Pair("Banana", 2),
        Pair("Apple", 3),
        Pair("Orange", 2),
        Pair("Banana", 5)
    )

    val comparator = compareBy<Pair<String, Int>> { it.first }
        .thenComparator { a, b -> compareValues(a.second, b.second) }

    println("Pairs sorted by first element, then by second:")
    println(pairs.sortedWith(comparator))

    val descendingComparator = compareBy<Pair<String, Int>> { it.second }
        .thenDescending(compareBy { it.first })

    println("Pairs sorted by second element, then by first in descending order:")
    println(pairs.sortedWith(descendingComparator))
}

Output:

Pairs sorted by first element, then by second:
[(Apple, 3), (Apple, 5), (Banana, 2), (Banana, 5), (Orange, 2)]
Pairs sorted by second element, then by first in descending order:
[(Banana, 5), (Apple, 5), (Banana, 2), (Orange, 2), (Apple, 3)]

Triple

In programming, functions are invoked to perform specific tasks. A key benefit of using functions is their ability to return values after computation. For instance, an add() function consistently returns the sum of the input numbers. However, a limitation of functions is that they typically return only one value at a time. When there’s a need to return multiple values of different types, one approach is to define a class with the desired variables and then return an object of that class. This method, though effective, can lead to increased verbosity, especially when dealing with multiple functions requiring multiple return values.

To simplify this process, Kotlin provides a more elegant solution through the use of Pair and Triple.

What is Triple?

Kotlin offers a simple way to store three values in a single object using the Triple class. This is a generic data class that can hold any three values. The values in a Triple have no inherent relationship beyond being stored together. Two Triple objects are considered equal if all three of their components are identical.

Class Definition:

data class Triple<out A, out B, out C> : Serializable

Parameters:

• A: The type of the first value.
• B: The type of the second value.
• C: The type of the third value.

Constructor:

In Kotlin, constructors initialize variables or properties of a class. To create an instance of Triple, you use the following syntax:

Triple(first: A, second: B, third: C)

Example: Creating a Triple

fun main() {
    val (a, b, c) = Triple(42, "Hello", true)
    println(a)
    println(b)
    println(c)
}

Output:

42
Hello
true

Properties:

You can either deconstruct the values of a Triple into separate variables (as shown above), or you can access them using the properties first, second, and third:

• first: Holds the first value.
• second: Holds the second value.
• third: Holds the third value.

Example: Accessing Triple Values Using Properties

fun main() {
    val triple = Triple("Kotlin", 1.6, listOf(100, 200, 300))
    println(triple.first)
    println(triple.second)
    println(triple.third)
}

Output:

Kotlin
1.6
[100, 200, 300]

Functions:

• toString(): This function returns a string representation of the Triple.Example: Using toString()

fun main() {
    val triple1 = Triple(10, 20, 30)
    println("Triple as string: " + triple1.toString())

    val triple2 = Triple("A", listOf("X", "Y", "Z"), 99)
    println("Another Triple as string: " + triple2.toString())
}

Output:

Triple as string: (10, 20, 30)
Another Triple as string: (A, [X, Y, Z], 99)

Extension Functions:

Kotlin also allows you to extend existing classes with new functionality through extension functions.

• toList(): This extension function converts the Triple into a list. Example: Using toList()

fun main() {
    val triple1 = Triple(1, 2, 3)
    val list1 = triple1.toList()
    println(list1)

    val triple2 = Triple("Apple", 3.1415, listOf(7, 8, 9))
    val list2 = triple2.toList()
    println(list2)
}

Output:

[1, 2, 3]
[Apple, 3.1415, [7, 8, 9]]

Pair

In programming, we often use functions to perform specific tasks. One of the advantages of functions is their ability to be called multiple times, consistently returning a result after computation. For example, an add() function always returns the sum of two given numbers.

However, functions typically return only one value at a time. When there’s a need to return multiple values of different data types, one common approach is to create a class containing the required variables, then instantiate an object of that class to hold the returned values. While effective, this approach can make the code verbose and complex, especially when many functions return multiple values.

To simplify this, Kotlin provides the Pair and Triple data classes.

What is Pair?

Kotlin offers a simple way to store two values in a single object using the Pair class. This generic class can hold two values, which can be of the same or different data types. The two values may or may not have a relationship. Comparison between two Pair objects is based on their values: two Pair objects are considered equal if both of their values are identical.

Class Definition:

data class Pair<out A, out B> : Serializable

Parameters:

• A: The type of the first value.
• B: The type of the second value.

Constructor:

Kotlin constructors are special functions that are called when an object is created, primarily to initialize variables or properties. To create an instance of Pair, use the following syntax:

Pair(first: A, second: B)

Example: Creating a Pair

fun main() {
    val (a, b) = Pair(42, "World")
    println(a)
    println(b)
}

Output:

42
World

Properties:

You can either destructure a Pair into separate variables (as shown above), or access the values using the properties first and second:

• first: Holds the first value.
• second: Holds the second value.

Example: Accessing Pair Values Using Properties

fun main() {
    val pair = Pair("Hello Kotlin", "This is a tutorial")
    println(pair.first)
    println(pair.second)
}

Output:

Hello Kotlin
This is a tutorial

Functions:

• toString(): This function returns a string representation of the Pair. Example: Using toString()

fun main() {
    val pair1 = Pair(10, 20)
    println("Pair as string: " + pair1.toString())

    val pair2 = Pair("Alpha", listOf("Beta", "Gamma", "Delta"))
    println("Another Pair as string: " + pair2.toString())
}

Output:

Pair as string: (10, 20)
Another Pair as string: (Alpha, [Beta, Gamma, Delta])

Extension Functions:

Kotlin allows extending existing classes with new functionality using extension functions.

• toList(): This extension function converts the Pair into a list.

Example: Using toList()

fun main() {
    val pair1 = Pair(3, 4)
    val list1 = pair1.toList()
    println(list1)

    val pair2 = Pair("Apple", "Orange")
    val list2 = pair2.toList()
    println(list2)
}

Output:

[3, 4]
[Apple, Orange]

apply vs with

In Kotlin, apply is an extension function that operates within the context of the object it is invoked on. It allows you to configure or manipulate the object’s properties within its scope and returns the same object after performing the desired changes. The primary use of apply is not limited to just setting properties; it can execute more complex logic before returning the modified object.

Key characteristics of apply:

• It is an extension function on a type.
• It requires an object reference to execute within an expression.
• After completing its operation, it returns the modified object.

Definition of apply:

inline fun T.apply(block: T.() -> Unit): T {
    block()
    return this
}

Example of apply:

fun main() {
    data class Example(var value1: String, var value2: String, var value3: String)

    // Creating an instance of Example class
    var example = Example("Hello", "World", "Before")

    // Using apply to change the value3
    example.apply { this.value3 = "After" }

    println(example)
}

Example Demonstrating Interface Implementation:

interface Machine {
    fun powerOn()
    fun powerOff()
}

class Computer : Machine {
    override fun powerOn() {
        println("Computer is powered on.")
    }

    override fun powerOff() {
        println("Computer is shutting down.")
    }
}

fun main() {
    val myComputer = Computer()
    myComputer.powerOn()
    myComputer.powerOff()
}

Output:

Example(value1=Hello, value2=World, value3=After)

In this example, the third property value3 of the Example class is modified from "Before" to "After" using apply.

Kotlin: with

Similar to apply, the with function in Kotlin is used to modify properties of an object. However, unlike apply, with does not require the object reference explicitly. Instead, the object is passed as an argument, and the operations are performed without using the dot operator for the object reference.

Definition of with:

inline fun <T, R> with(receiver: T, block: T.() -> R): R {
    return receiver.block()
}

Example of with:

fun main() {
    data class Example(var value1: String, var value2: String, var value3: String)

    var example = Example("Hello", "World", "Before")

    // Using with to modify value1 and value3
    with(example) {
        value1 = "Updated"
        value3 = "After"
    }

    println(example)
}

Output:

Example(value1=Updated, value2=World, value3=After)

In this case, using with, we update the values of value1 and value3 without needing to reference the object with a dot operator.

Difference Between apply and with

• apply is invoked on an object and runs within its context, requiring the object reference.
• with does not require an explicit object reference and simply passes the object as an argument.
• apply returns the object itself, while with can return a result of the block’s execution.

Regular Expression

Kotlin provides robust support for regular expressions through the Regex class, which allows for efficient string pattern matching. A Regex object represents a regular expression and can be used for various string-matching purposes.

Constructors:

• Regex(pattern: String): Creates a regular expression from the provided pattern.
• Regex(pattern: String, option: RegexOption): Creates a regular expression with a specific option from the RegexOption enum.
• Regex(pattern: String, options: Set<RegexOption>): Creates a regular expression with a set of options.

Properties:

• val options: Set<RegexOption>: Contains the set of options used for regex creation.
• val pattern: String: Stores the pattern as a string.

Functions in Regex

1. containsMatchIn(): This function checks if there is a match for the regex pattern within a given input and returns a boolean.

fun main() {
    val pattern = Regex("^a")  // Matches any string starting with 'a'
    println(pattern.containsMatchIn("abc"))  // true
    println(pattern.containsMatchIn("bac"))  // false
}

Output:

fun main() {
    val pattern = Regex("^a")  // Matches any string starting with 'a'
    println(pattern.containsMatchIn("abc"))  // true
    println(pattern.containsMatchIn("bac"))  // false
}

2. find(): This function returns the first match of the regex in the input starting from a specified index.

fun main() {
    val pattern = Regex("ll")  // Matches "ll"
    val match: MatchResult? = pattern.find("HelloHello", 5)
    println(match?.value)  // ll
}

Output:

ll

3. findAll() : This function finds all the matches for a regex in the input starting from a specified index and returns them as a sequence.

fun main() {
    val pattern = Regex("ab.")
    val matches: Sequence<MatchResult> = pattern.findAll("abcabdeabf", 0)
    matches.forEach { match -> println(match.value) }
}

Output:

abc
abd

4. matches(): This function checks if the entire input string matches the regular expression.

fun main() {
    val pattern = Regex("g([ee]+)ks?")
    println(pattern.matches("geeks"))  // true
    println(pattern.matches("geeeeeeks"))  // true
    println(pattern.matches("geeksforgeeks"))  // false
}

Output:

true
true
false

5. matchEntire(): This function tries to match the entire input string to the regex pattern and returns the match if successful, otherwise returnsnull.

fun main() {
    val pattern = Regex("geeks?")
    println(pattern.matchEntire("geeks")?.value)  // geeks
    println(pattern.matchEntire("geeeeeks")?.value)  // null
}

Output:

geeks
null

6. replace(): This function replaces all occurrences of the pattern in the input string with a replacement string.

7.replaceFirst(): Replaces only the first occurrence.

fun main() {
    val pattern = Regex("xyz")
    println(pattern.replace("xyzxyz", "abc"))  // abcabc
    println(pattern.replaceFirst("xyzxyz", "abc"))  // abcxyz
}

Output:

abcabc
abcxyz

8. split(): This function splits the input string into parts based on the regular expression pattern.

fun main() {
    val pattern = Regex("\\s+")  // Split by whitespace
    val result = pattern.split("Kotlin is great")
    result.forEach { println(it) }
}

Output:

Kotlin
is
great

Ranges

In Kotlin, a range is a collection of values defined by a start point, an end point, and a step. The range includes both the start and stop values, and the step value, which is the increment or decrement, is 1 by default. Kotlin’s range can work with comparable types like numbers and characters.

Creating Ranges in Kotlin

There are three primary ways to create a range:

1. Using the .. operator
2. Using the rangeTo() function
3. Using the downTo() function

1. Using the .. Operator: The .. operator creates a range from the start to the end value, including both.

Example 1: Integer Range

fun main() {
    println("Integer range:")
    for (num in 1..5) {
        println(num)
    }
}

Output:

Integer range:
1
2
3
4
5

Example 2: Character Range

fun main() {
    println("Character range:")
    for (ch in 'a'..'e') {
        println(ch)
    }
}

Output:

Character range:
a
b
c
d
e

2. Using the rangeTo() Function : The rangeTo() function is another way to create ranges, similar to using the .. operator.

Example 1: Integer Range

fun main() {
    println("Integer range:")
    for (num in 1.rangeTo(5)) {
        println(num)
    }
}

Output:

Integer range:
1
2
3
4
5

Example 2: Character Range

fun main() {
    println("Character range:")
    for (ch in 'a'.rangeTo('e')) {
        println(ch)
    }
}

Output:

Character range:
a
b
c
d
e

3. Using the downTo() Function: The downTo() function creates a range that decreases from the starting value to the ending value.

Example 1: Integer Range in Descending Order

fun main() {
    println("Integer range in descending order:")
    for (num in 5.downTo(1)) {
        println(num)
    }
}

Output:

Integer range in descending order:
5
4
3
2
1

Example 2: Character Range in Descending Order

fun main() {
    println("Character range in reverse order:")
    for (ch in 'e'.downTo('a')) {
        println(ch)
    }
}

Output:

Character range in reverse order:
e
d
c
b
a

Using the forEach Loop

The forEach loop can also be used to traverse over a range.

fun main() {
    println("Integer range:")
    (2..5).forEach(::println)
}

Output:

Integer range:
2
3
4
5

step(): Customizing the Increment:

The step() function allows you to specify the increment or step value in the range. By default, the step value is 1.

Example: Step Usage

fun main() {
    // Custom step value
    for (i in 3..10 step 2) {
        print("$i ")
    }
    println()
    println((11..20 step 2).first)  // Print first value
    println((11..20 step 4).last)   // Print last value
    println((11..20 step 5).step)   // Print step value
}

Output:

3 5 7 9
11
19
5

reversed(): Reversing the Range:

The reversed() function reverses the range.

fun main() {
    val range = 2..8
    for (x in range.reversed()) {
        print("$x ")
    }
}

Output:

8 7 6 5 4 3 2

Predefined Functions for Ranges

Kotlin offers predefined functions like min(), max(), sum(), and average() to work with ranges.

fun main() {
    val predefined = (15..20)
    println("The minimum value of range is: ${predefined.minOrNull()}")
    println("The maximum value of range is: ${predefined.maxOrNull()}")
    println("The sum of all values of range is: ${predefined.sum()}")
    println("The average value of range is: ${predefined.average()}")
}

Output:

The minimum value of range is: 15
The maximum value of range is: 20
The sum of all values of range is: 105
The average value of range is: 17.5

Checking if a Value Lies in a Range

You can check if a value lies within a range using the in keyword.

fun main() {
    val i = 2
    if (i in 5..10) {
        println("$i lies within the range")
    } else {
        println("$i does not lie within the range")
    }
}

Output:

2 does not lie within the range

Kotlin’s type system is designed to eliminate the risk of null reference errors from the code. NullPointerExceptions (NPE) often cause unexpected runtime crashes and application failures. Kotlin aims to prevent this billion-dollar mistake by handling null references at compile-time.

If you’re coming from Java or another language with null references, you’ve likely experienced NullPointerExceptions. Kotlin’s compiler throws a NullPointerException if it detects an unhandled null reference without proceeding with further execution.

Common causes of NullPointerException:

• Explicitly calling throw NullPointerException()
• Using the !! operator
• Uninitialized data, such as passing an uninitialized this reference as an argument
• Java interoperability issues, such as trying to access a member on a null reference, or using generics with incorrect nullability

Nullable and Non-Nullable Types in Kotlin

In Kotlin, references are either nullable or non-nullable. Non-nullable references cannot hold null values. If you attempt to assign null to a non-nullable reference, the compiler will raise an error.

var s1: String = "Hello"
s1 = null  // Error: compilation issue

However, to declare a variable that can hold null, we use a nullable type by appending ? to the type:

var s2: String? = "Hello Kotlin"
s2 = null  // No compilation error

If you want to access the length of a nullable string, you must use safe calls or handle the possibility of a null value:

val length = s2?.length  // Safe call, returns null if s2 is null

Example: Non-Nullable Type in Kotlin

fun main() {
    var s1: String = "Kotlin"

    println("The length of the string s1 is: ${s1.length}")
}

Output:

The length of the string s1 is: 6

In this case, assigning null to s1 would result in a compilation error.

Example: Nullable Type in Kotlin

null

Output:

var s2: String? = "Hello Kotlin"
s2 = null  // No compilation error

Here, Kotlin allows assigning null to s2 since it is a nullable type, but accessing its properties requires safe calls.

Checking for null in Conditions

You can use if-else blocks to check if a variable is null:

fun main() {
    var s: String? = "Kotlin"

    if (s != null) {
        println("String length is ${s.length}")
    } else {
        println("Null string")
    }

    s = null
    if (s != null) {
        println("String length is ${s.length}")
    } else {
        println("Null string")
    }
}

Output:

String length is 6
Null string

Safe Call Operator ?.

The ?. operator simplifies null checks. If the value before the ?. is null, the expression after ?. is not evaluated, and null is returned.

fun main() {
    var firstName: String? = "Alice"
    var lastName: String? = null

    println(firstName?.toUpperCase())  // Output: ALICE
    println(lastName?.toUpperCase())   // Output: null
}

let() Function with Safe Call

The let() function executes only when the reference is not null:

fun main() {
    var firstName: String? = "Alice"

    firstName?.let { println(it.toUpperCase()) }  // Output: ALICE
}

Example using let() with Nullable Values

fun main() {
    val stringList: List<String?> = listOf("Hello", "World", null, "Kotlin")
    val filteredList = stringList.filterNotNull()

    filteredList.forEach { println(it) }
}

Output:

Hello
World
Kotlin

The Elvis Operator ?:

The Elvis operator returns a default value when the expression on the left is null:

fun main() {
    var str: String? = null
    val length = str?.length ?: -1
    println(length)  // Output: -1
}

Example using the Elvis Operator

fun main() {
    var str: String? = "Kotlin"
    println(str?.length ?: "-1")  // Output: 6

    str = null
    println(str?.length ?: "-1")  // Output: -1
}

Not Null Assertion Operator !!

The !! operator forces Kotlin to treat a nullable type as non-null. It will throw a KotlinNullPointerException if the value is null.

fun main() {
    var str: String? = "Kotlin"
    println(str!!.length)

    str = null
    println(str!!.length)  // Throws KotlinNullPointerException
}

Output:

6
Exception in thread "main" kotlin.KotlinNullPointerException

Explicit Type Casting

In Kotlin, smart casting allows us to use the is or !is operator to check the type of a variable. Once the type is confirmed, the compiler automatically casts the variable to the desired type. However, in explicit type casting, we use the as operator.

Explicit type casting can be performed in two ways:

• Unsafe cast operator: as
• Safe cast operator: as?

• Unsafe Cast Operator: as : When using the as operator, we manually cast a variable to the target type. However, if the casting fails, it results in a runtime exception. This is why it’s considered unsafe. Example

fun main() {
    val text: String = "This works!"
    val result: String = text as String  // Successful cast
    println(result)
}

Output:

This works!

While this example works fine, using the as operator to cast an incompatible type will throw a ClassCastException at runtime.

For instance, attempting to cast an Integer to a String:

fun main() {
    val number: Any = 42
    val result: String = number as String  // Throws exception
    println(result)
}

Output:

Exception in thread "main" java.lang.ClassCastException: class java.lang.Integer cannot be cast to class java.lang.String

Similarly, trying to cast a nullable type to a non-nullable type will result in a TypeCastException:

fun main() {
    val text: String? = null
    val result: String = text as String  // Throws exception
    println(result)
}

Output:

This works!

Similarly, trying to cast a nullable type to a non-nullable type will result in a TypeCastException:

fun main() {
    val text: String? = null
    val result: String = text as String  // Throws exception
    println(result)
}

Output:

Exception in thread "main" kotlin.TypeCastException: null cannot be cast to non-null type kotlin.String

To prevent this, we should cast to a nullable target type:

fun main() {
    val text: String? = null
    val result: String? = text as String?  // Successful cast
    println(result)
}

Output:

null

Safe Cast Operator: as?: Kotlin provides a safer option with the as? operator, which returns null if the casting fails, instead of throwing an exception.

Here’s an example of using as? for safe typecasting:

Safe Cast Operator: as?
Kotlin provides a safer option with the as? operator, which returns null if the casting fails, instead of throwing an exception.

Here’s an example of using as? for safe typecasting:

Output:

Safe casting
null
99

Classes and Object

In Kotlin, classes and objects are key constructs to represent real-world entities. A class serves as a blueprint for creating objects, defining their structure (properties) and behavior (functions). Each object created from a class holds its own state and behavior. Multiple objects can be instantiated from a single class, each having unique values.

A class in Kotlin may define properties and methods, which can later be accessed by creating objects of that class.

Example of a Kotlin Class:

class Animal {
    var name: String = ""
    var type: String = ""
    var age: Int = 0

    fun getDetails(): String {
        return "Animal: $name, Type: $type, Age: $age years"
    }
}

fun main() {
    val myPet = Animal()
    myPet.name = "Bella"
    myPet.type = "Dog"
    myPet.age = 3

    println(myPet.getDetails())
}

Output:

Animal: Bella, Type: Dog, Age: 3 years

Object-Oriented Programming in Kotlin:

Kotlin combines both functional and object-oriented paradigms. Earlier, we’ve explored functional aspects such as higher-order functions and lambdas. Now, let’s dive into the object-oriented nature of Kotlin.

Core OOP Concepts in Kotlin:

• Class: A class acts as a blueprint for objects, defining similar properties and methods. In Kotlin, classes are declared using the class keyword. Syntax:

class ClassName {  // class header
    // properties
    // member functions
}

• Class Name: Every class must have a name.
• Class Header: Includes parameters and constructors.
• Class Body: Enclosed by curly braces {}, containing properties and methods. Both the class header and body are optional, and the body can be omitted if empty.

class EmptyClass

Creating a Constructor:

class ClassName constructor(parameters) {
    // properties
    // member functions
}

Example of a Kotlin Class with Constructor:

val obj = ClassName()

Output:

class Employee {
    var name: String = ""
    var age: Int = 0
    var gender: Char = 'M'
    var salary: Double = 0.0

    fun setDetails(n: String, a: Int, g: Char, s: Double) {
        name = n
        age = a
        gender = g
        salary = s
    }

    fun displayInfo() {
        println("Employee Name: $name")
        println("Age: $age")
        println("Gender: $gender")
        println("Salary: $salary")
    }
}

Objects in Kotlin:

An object is an instance of a class, allowing access to the class properties and methods. You can create multiple objects from a class, each representing unique instances.

• State: Defined by object attributes (properties).
• Behavior: Defined by object methods.
• Identity: Each object has a unique identity allowing interaction with other objects.

Creating an Object:

val obj = ClassName()

Accessing Class Properties:

obj.propertyName

Accessing Class Methods:

obj.methodName()

Accessing Class Properties:

obj.methodName()

Kotlin Program with Multiple Objects:

class Employee {
    var name: String = ""
    var age: Int = 0
    var gender: Char = 'M'
    var salary: Double = 0.0

    fun setDetails(n: String, a: Int, g: Char, s: Double) {
        name = n
        age = a
        gender = g
        salary = s
    }

    fun setName(n: String) {
        this.name = n
    }

    fun displayDetails() {
        println("Employee Name: $name")
        println("Age: $age")
        println("Gender: $gender")
        println("Salary: $salary")
    }
}

fun main(args: Array<String>) {
    // Creating multiple objects of Employee class
    val emp1 = Employee()
    val emp2 = Employee()

    // Setting and displaying details for the first employee
    emp1.setDetails("John", 35, 'M', 55000.0)
    emp1.displayDetails()

    // Setting and displaying name for the second employee
    emp2.setName("Emily")
    println("Second Employee Name: ${emp2.name}")
}

Output:

Employee Name: John
Age: 35
Gender: M
Salary: 55000.0
Second Employee Name: Emily

Nested Class and Inner Class

In Kotlin, you can declare a class within another class. This is known as a nested class. Nested classes are useful when you want to logically group classes that are only used in one place. A nested class by default does not have access to the members of the outer class, unless declared as an inner class using the inner keyword, which allows it to access outer class properties and methods.

Example:

class Vehicle {
    var brand: String
    var model: String
    var year: Int

    inner class Engine {
        var horsepower: Int = 0
        var type: String = ""

        fun getEngineDetails(): String {
            return "$horsepower HP $type engine in a $brand $model"
        }
    }

    fun getVehicleInfo(): String {
        return "$brand $model, Year: $year"
    }
}

fun main() {
    val myVehicle = Vehicle()
    myVehicle.brand = "Honda"
    myVehicle.model = "Civic"
    myVehicle.year = 2022

    val vehicleEngine = myVehicle.Engine()
    vehicleEngine.horsepower = 180
    vehicleEngine.type = "V6"

    println(vehicleEngine.getEngineDetails())
}

Output:

180 HP V6 engine in a Honda Civic

Understanding Nested Classes:

In Kotlin, a class can be declared inside another class, forming a nested class. By default, a nested class does not have access to the outer class’s members. To access a nested class’s properties, you must create an instance of the nested class.

Syntax of a Nested Class:

class OuterClass {
    // Outer class properties or methods

    class NestedClass {
        // Nested class properties or methods
    }
}

Example of Accessing Nested Class Properties:

class OuterClass {
    val message = "Outer Class"

    class NestedClass {
        val firstName = "John"
        val lastName = "Doe"
    }
}

fun main() {
    // Accessing properties of the Nested Class
    println(OuterClass.NestedClass().firstName)
    println(OuterClass.NestedClass().lastName)
}

Output:

John
Doe

Example of Accessing Nested Class Functions:

class OuterClass {
    var outerProperty = "Outer Class Property"

    class NestedClass {
        var nestedProperty = "Nested Class Property"

        fun combineProperties(suffix: String): String {
            return nestedProperty + suffix
        }
    }
}

fun main() {
    val nestedObj = OuterClass.NestedClass()
    val result = nestedObj.combineProperties(" - Function Executed")
    println(result)
}

Output:

Nested Class Property - Function Executed

Inner Classes in Kotlin:

An inner class is a type of nested class that has access to the outer class’s members. You can declare an inner class using the inner keyword. This gives the inner class the ability to access members of the outer class.

Example of an Inner Class:

class Person {
    var name = "John"
    var age = 30

    inner class Address {
        var city = "New York"
        var street = "5th Avenue"

        fun getFullAddress(): String {
            return "$name lives at $street, $city"
        }
    }
}

fun main() {
    val personAddress = Person().Address()
    println(personAddress.getFullAddress())
}

Output:

John lives at 5th Avenue, New York

Differences Between Nested and Inner Classes:

• Nested Classes: Cannot access outer class members unless passed explicitly.
• Inner Classes: Have access to all members (properties and methods) of the outer class.

Example of Inner Class Accessing Outer Class Property:

class Organization {
    var company = "Tech Corp"

    inner class Department {
        var departmentName = "IT"

        fun getDepartmentDetails(): String {
            return "Company: $company, Department: $departmentName"
        }
    }
}

fun main() {
    val department = Organization().Department()
    println(department.getDepartmentDetails())
}

Output:

Company: Tech Corp, Department: IT

Pros and Cons of Using Nested and Inner Classes in Kotlin:

Advantages:

1. Encapsulation: Helps in grouping related functionality together, improving code clarity and organization.
2. Reusability: You can reuse nested and inner classes within the outer class or across other classes, making the code more maintainable.
3. Accessibility: Inner classes have access to the outer class’s members, which facilitates data sharing between the inner and outer classes.

Disadvantages:

1. Increased Complexity: Using nested and inner classes can make the code more complex, especially when used extensively or with multiple layers of nesting.
2. Performance Overhead: Excessive usage of nested and inner classes might impact performance, particularly when the classes are deeply nested.
3. Difficult Debugging: Debugging can be more challenging when using multiple levels of nesting in classes.

Setters and Getters

In Kotlin, you can customize how properties are set and retrieved by defining custom setters and getters. By default, Kotlin generates these functions for you, but you can override them for additional behavior.

Example of a Property with Default Setter and Getter:

class Company {
    var name: String = "Default"
}

fun main() {
    val c = Company()
    c.name = "KotlinGeeks"  // Invokes the setter
    println(c.name)         // Invokes the getter (Output: KotlinGeeks)
}

The above code is implicitly generating the getter and setter for the name property. However, if we want to customize this behavior, we can manually define the getter and setter functions.

Custom Getter and Setter

In Kotlin, we can define custom logic for setting and getting a property’s value. Below is an example of how to create a custom getter and setter for a property:

class Company {
    var name: String = ""
        get() = field.toUpperCase()  // Custom getter
        set(value) {                 // Custom setter
            field = value
        }
}

fun main() {
    val c = Company()
    c.name = "Kotlin World"
    println(c.name)  // Output: KOTLIN WORLD
}

In this example, the getter converts the name to uppercase when retrieving it, while the setter stores the name as-is.

Private Setter Example

You can also use private setters to restrict modifications to a property only from within the class:

class Company {
    var name: String = "TechGeeks"
        private set

    fun updateName(newName: String) {
        name = newName
    }
}

fun main() {
    val company = Company()
    println("Company Name: ${company.name}")

    company.updateName("GeeksforGeeks")
    println("Updated Company Name: ${company.name}")
}

Output:

Company Name: TechGeeks
Updated Company Name: GeeksforGeeks

Custom Getter and Setter with Validation

You can also add validation logic inside custom setters. For instance, we can enforce restrictions on certain properties like email or age:

class User(val email: String, pwd: String, userAge: Int, gender: Char) {
    var password: String = pwd
        set(value) {
            field = if (value.length > 6) value else throw IllegalArgumentException("Password is too short")
        }

    var age: Int = userAge
        set(value) {
            field = if (value >= 18) value else throw IllegalArgumentException("Age must be at least 18")
        }

    var gender: Char = gender
        set(value) {
            field = if (value == 'M' || value == 'F') value else throw IllegalArgumentException("Invalid gender")
        }
}

fun main() {
    val user = User("user@example.com", "Kotlin@123", 25, 'M')
    println("User email: ${user.email}")
    println("User age: ${user.age}")

    // Uncommenting these will throw exceptions
    // user.password = "123"
    // user.age = 17
    // user.gender = 'X'
}

Output:

User email: user@example.com
User age: 25

Advantages of Custom Setters and Getters:

• Validation: Enforce rules like password length or valid age.
• Encapsulation: Hide the actual implementation of how a property is set or retrieved.
• Customization: Customize how a property behaves when it is accessed or modified.

By utilizing getters and setters effectively, Kotlin allows you to implement encapsulation, validation, and data manipulation while keeping your code clean and intuitive.

Class Properties and Custom Accessors

Encapsulation in Kotlin

Encapsulation is one of the core principles of object-oriented programming (OOP). It refers to bundling the data (fields) and the methods (functions) that operate on the data into a single unit called a class. In Kotlin, encapsulation is implemented using properties, where data is stored in private fields, and access to this data is controlled through public getter and setter methods.

Properties in Kotlin

In Kotlin, properties are a key language feature, replacing fields and accessor methods commonly used in Java. A property in Kotlin can be declared as either mutable or immutable using the var or val keyword, respectively.

• Mutable Property (var): A property that can be modified after initialization.
• Immutable Property (val): A property that cannot be changed after initialization.

Defining a Class with Properties:

In Kotlin, defining properties in a class is straightforward, and Kotlin auto-generates the accessor methods (getter and setter) for you.

class Person(
    val name: String,
    val isEmployed: Boolean
)

• Readable Property: A getter is automatically generated to retrieve the value.
• Writable Property: Both a getter and a setter are generated for mutable properties.

Example of a Class in Kotlin:

class Person(
    val name: String,
    val isEmployed: Boolean
)

fun main() {
    val person = Person("Alice", true)
    println(person.name)
    println(person.isEmployed)
}

Output:

Alice
true

In Kotlin, the constructor is invoked without the new keyword, and instead of explicitly calling getter methods, properties are accessed directly. This approach makes the code more concise and easier to read. The setter for a mutable property works similarly, allowing direct assignment.

Custom Accessors in Kotlin

In Kotlin, you can customize the behavior of property accessors by providing your own implementations for the getter and setter methods.

Example of a Custom Getter:

class Rectangle(val height: Int, val width: Int) {
    val isSquare: Boolean
        get() = height == width
}

fun main() {
    val rectangle = Rectangle(41, 43)
    println(rectangle.isSquare)  // Output: false
}

In this example, the property isSquare has a custom getter that calculates whether the rectangle is a square. There’s no need for a backing field because the value is computed on demand.

Key Points:

• Kotlin automatically generates getters and setters for properties.
• Immutable properties (val) only have a getter.
• Mutable properties (var) have both a getter and setter.
• You can define custom getters and setters if needed.

Changing the Program

Here’s a modified version of the program, keeping the same functionality but with different variable names and a different context:

class Box(val length: Int, val breadth: Int) {
    val isCube: Boolean
        get() = length == breadth
}

fun main() {
    val box = Box(10, 20)
    println("Is the box a cube? ${box.isCube}")
}

Output:

Is the box a cube? false

Explanation:

In this program:

• A class Box is defined with properties length and breadth.
• A custom getter for the isCube property checks whether the box has equal sides.
• In the main function, we create an object of the Box class and check if the box is a cube.

This approach shows how you can encapsulate data and functionality within a class in Kotlin while providing customized behavior through accessors.

Constructor

A constructor in Kotlin is a special member function invoked when an object of a class is created, mainly used to initialize variables or properties. Kotlin provides two types of constructors:

1. Primary Constructor
2. Secondary Constructor

A class can have one primary constructor and multiple secondary constructors. The primary constructor is responsible for basic initialization, while secondary constructors allow additional logic or overloads.

1. Primary Constructor: The primary constructor is defined in the class header and typically initializes class properties. It’s optional, and if no constructor is declared, Kotlin provides a default constructor.

class Sum(val a: Int, val b: Int) {
    // code
}

In cases where no annotations or access modifiers are used, the constructor keyword can be omitted.

class Sum(val a: Int, val b: Int) {
    // code
}

Example of Primary Constructor

// main function
fun main() {
    val sum = Sum(5, 6)
    println("The total of 5 and 6 is: ${sum.result}")
}

// primary constructor
class Sum(a: Int, b: Int) {
    var result = a + b
}

Output:

The total of 5 and 6 is: 11

Primary Constructor with Initialization Block

In Kotlin, the primary constructor can’t contain logic directly. Initialization code must be placed in an init block, which executes when an object is created.

Example with init Block

class Person(val name: String) {
    init {
        println("Initialization block running...")
        println("Name is: $name")
    }
}

fun main() {
    val person = Person("John")
}

Output:

Initialization block running...
Name is: John

Default Values in Primary Constructor

Similar to default parameters in functions, you can define default values for primary constructor parameters.

class Employee(val id: Int = 101, val name: String = "Unknown") {
    init {
        println("Employee ID: $id, Name: $name")
    }
}

fun main() {
    val emp1 = Employee(102, "Alice")
    val emp2 = Employee(103)
    val emp3 = Employee()
}

Output:

Employee ID: 102, Name: Alice
Employee ID: 103, Name: Unknown
Employee ID: 101, Name: Unknown

2. Secondary Constructor: A secondary constructor is useful for additional logic or creating multiple overloads. It’s defined with the constructor keyword, and you can have multiple secondary constructors.

Example of Secondary Constructor

class Add {
    constructor(a: Int, b: Int) {
        val sum = a + b
        println("The sum of $a and $b is: $sum")
    }
}

fun main() {
    Add(5, 6)
}

Output:

The sum of 5 and 6 is: 11

Default Values in Primary Constructor

Similar to default parameters in functions, you can define default values for primary constructor parameters.

class Employee {
    constructor(id: Int, name: String) {
        println("Employee ID: $id, Name: $name")
    }

    constructor(id: Int, name: String, salary: Double) {
        println("Employee ID: $id, Name: $name, Salary: $salary")
    }
}

fun main() {
    Employee(102, "Alice")
    Employee(103, "Bob", 60000.0)
}

Output:

Employee ID: 102, Name: Alice
Employee ID: 103, Name: Bob, Salary: 60000.0

Calling One Secondary Constructor from Another

A secondary constructor can call another secondary constructor using the this() keyword.

fun main() {
    Child(101, "John")
}

open class Parent {
    constructor(id: Int, name: String, salary: Double) {
        println("Parent - ID: $id, Name: $name, Salary: $salary")
    }
}

class Child : Parent {
    constructor(id: Int, name: String) : super(id, name, 50000.0) {
        println("Child - ID: $id, Name: $name")
    }
}

Output:

Parent - ID: 101, Name: John, Salary: 50000.0
Child - ID: 101, Name: John

Modifiers

In Kotlin, visibility modifiers control access to classes, their members (properties, methods, and nested classes), and constructors. The following visibility modifiers are available:

1. private: Limits access to the containing class only. A private member cannot be accessed outside the class.
2. internal: Restricts access to the same module. A module in Kotlin refers to a set of files compiled together.
3. protected: Allows access within the containing class and its subclasses.
4. public: The default modifier in Kotlin. A public member is accessible from anywhere in the code.

These modifiers are used to restrict the accessibility of class members and their setters, ensuring encapsulation. Setters can be modified, but the visibility of getters remains the same as that of the property.

1. Public Modifier : In Kotlin, the public modifier is the default visibility modifier and is used for members that should be accessible from anywhere in the code. Unlike Java, in Kotlin, if no visibility modifier is specified, it defaults to public.

// by default public
class Car {
    var model = "Sedan"
}

// explicitly public
public class Truck {
    var capacity = 2000
    fun showCapacity() {
        println("This truck has a capacity of $capacity tons")
    }
}

fun main() {
    val car = Car()
    println(car.model)  // Accessible anywhere

    val truck = Truck()
    truck.showCapacity()  // Accessible anywhere
}

Output:

open class Base {
    open fun greet() {
        println("Hello from Base")
    }
}

class Derived : Base() {
    override fun greet() {
        println("Hello from Derived")
    }
}

fun main() {
    val base: Base = Derived()
    base.greet()  // Output: Hello from Derived
}

2. Private Modifier : The private modifier restricts access to the containing class or file. Members declared private in a class cannot be accessed from outside the class. In Kotlin, multiple top-level declarations are allowed in the same file, and a private top-level declaration can be accessed by other members within the same file.

// Accessible only in this file
private class Plane {
    private val range = 1500

    fun showRange() {
        println("The plane has a range of $range miles")
    }
}

fun main() {
    val plane = Plane()
    plane.showRange() // OK, accessible within the same file
    // println(plane.range) // Error: 'range' is private
}

Output:

The plane has a range of 1500 miles

3. Internal Modifier: The internal modifier ensures that a class or member is accessible only within the same module. It is useful for controlling visibility across modules but not exposing certain members outside the module.

internal class Computer {
    internal var brand = "TechBrand"

    internal fun showDetails() {
        println("This is a $brand computer")
    }
}

fun main() {
    val computer = Computer()
    computer.showDetails()  // Accessible within the same module
}

4. Protected Modifier: The protected modifier allows access to members within the class and its subclasses but not from outside the class. Unlike Java, in Kotlin, protected members are not accessible to other classes in the same package.

open class Device {
    protected val batteryLife = 24  // accessible in subclasses
}

class Smartphone : Device() {
    fun getBatteryLife(): Int {
        return batteryLife  // OK, accessed from subclass
    }
}

fun main() {
    val phone = Smartphone()
    println("Battery life is: ${phone.getBatteryLife()} hours")
}

Output:

Battery life is: 24 hours

Overriding Protected Members

To override a protected member, it must be declared open in the base class. The derived class can then override the member.

open class Appliance {
    open protected val power = 1500  // Can be overridden
}

class Microwave : Appliance() {
    override val power = 1200

    fun showPower(): Int {
        return power  // Accessing overridden value
    }
}

fun main() {
    val microwave = Microwave()
    println("Power of the microwave: ${microwave.showPower()} watts")
}

Output:

Power of the microwave: 1200 watts

Advantages of Visibility Modifiers in Kotlin:

1. Encapsulation: Visibility modifiers help encapsulate and hide the internal workings of a class, ensuring that only relevant parts are exposed.
2. Modularity: By controlling member visibility, you can create self-contained modules that are easier to maintain and reuse.
3. Abstraction: Exposing only necessary details creates a clearer abstraction and makes code easier to manage and debug.

Disadvantages of Visibility Modifiers in Kotlin:

1. Increased Complexity: Using multiple visibility levels in a project can make the code more difficult to understand.
2. Overhead: The compiler may perform additional checks to enforce visibility, leading to minimal performance overhead.

Inheritance

Kotlin supports inheritance, allowing you to define a new class based on an existing one. The existing class is referred to as the superclass or base class, while the new class is called the subclass or derived class. The subclass inherits properties and methods from the superclass, and can also add new functionality or override the properties and methods inherited from the superclass.

Inheritance is a core feature in object-oriented programming that promotes code reusability. It enables a new class to inherit the properties and behaviors of an existing class while also adding or modifying features.

Syntax of Inheritance:

open class BaseClass(val x: Int) {
    // Class body
}

class DerivedClass(x: Int) : BaseClass(x) {
    // Derived class body
}

In Kotlin, classes are final by default, meaning they cannot be inherited. To allow inheritance, you need to use the open keyword before the class declaration of the base class.

Breakdown of Key Components:

• Superclass (Base Class): This is the class from which properties and methods are inherited. It defines behaviors that can be overridden in its subclasses.
• Subclass (Derived Class): This is the class that inherits properties and methods from the superclass. The subclass can enhance or modify the behavior of the base class by adding new properties and methods or overriding inherited ones.

Example of Inheriting Properties and Methods:

When a class inherits another class, it can use its properties and methods. The subclass can also call methods of the base class via an instance of the derived class.

open class Base(val name: String) {
    init {
        println("Initialized in Base class")
    }

    open val size: Int = name.length.also { println("Size in Base: $it") }
}

class Derived(name: String, val lastName: String) : Base(name.capitalize().also { println("Base argument: $it") }) {
    init {
        println("Initialized in Derived class")
    }

    override val size: Int = (super.size + lastName.length).also { println("Size in Derived: $it") }
}

fun main() {
    val obj = Derived("john", "doe")
}

Output:

Base argument: John
Initialized in Base class
Size in Base: 4
Initialized in Derived class
Size in Derived: 7

Explanation:

• The base class Base contains an init block and a property size, which gets initialized when an object is created.
• The derived class Derived inherits Base, overrides the size property, and adds a new property lastName.
• When we create an object of the Derived class, it initializes both the base and derived classes, and overrides the size property in the derived class.

Use of Inheritance in a Practical Example:

Suppose we have different types of employees, like WebDeveloper, iOSDeveloper, and AndroidDeveloper. Each has common attributes like name and age, but different specific skills. Using inheritance, we can avoid code duplication by placing common attributes in a base class Employee.

Without Inheritance:

If you create separate classes for each type of employee, you would have to repeat the common properties (like name and age) in each class. This leads to redundant code, and if you want to add new properties (like salary), you’d need to modify each class.

With Inheritance:

You can create a base class Employee with common properties, and the specific classes WebDeveloper, iOSDeveloper, and AndroidDeveloper can inherit from it, adding their unique features.

Kotlin Program Demonstrating Inheritance:

// Base class
open class Employee(val name: String, val age: Int, val salary: Int) {
    init {
        println("Employee: Name = $name, Age = $age, Salary = $salary per month")
    }
}

// Derived class
class WebDeveloper(name: String, age: Int, salary: Int) : Employee(name, age, salary) {
    fun developWebsite() {
        println("I develop websites.")
    }
}

// Derived class
class AndroidDeveloper(name: String, age: Int, salary: Int) : Employee(name, age, salary) {
    fun developAndroidApp() {
        println("I develop Android apps.")
    }
}

// Derived class
class iOSDeveloper(name: String, age: Int, salary: Int) : Employee(name, age, salary) {
    fun developIOSApp() {
        println("I develop iOS apps.")
    }
}

fun main() {
    val webDev = WebDeveloper("Alice", 28, 4000)
    webDev.developWebsite()

    val androidDev = AndroidDeveloper("Bob", 26, 4500)
    androidDev.developAndroidApp()

    val iosDev = iOSDeveloper("Charlie", 30, 5000)
    iosDev.developIOSApp()
}

Output:

Employee: Name = Alice, Age = 28, Salary = 4000 per month
I develop websites.
Employee: Name = Bob, Age = 26, Salary = 4500 per month
I develop Android apps.
Employee: Name = Charlie, Age = 30, Salary = 5000 per month
I develop iOS apps.

Inheritance with Primary Constructors:

If a subclass has a primary constructor, it must initialize the base class constructor using parameters. Below is an example where the base class has two parameters, and the subclass has three parameters.

// Base class
open class Person(val name: String, val age: Int) {
    init {
        println("Person's Name: $name, Age: $age")
    }
}

// Derived class
class Manager(name: String, age: Int, val salary: Double) : Person(name, age) {
    init {
        println("Manager's Salary: $salary per year")
    }
}

fun main() {
    Manager("Jane", 35, 120000.0)
}

Output:

Person's Name: Jane, Age: 35
Manager's Salary: 120000.0 per year

Secondary Constructors:

Secondary constructors are useful for providing additional logic or different ways to create objects.

open class Animal(val name: String) {
    init {
        println("Animal: $name")
    }
}

class Dog : Animal {
    constructor(name: String, breed: String) : super(name) {
        println("Dog Breed: $breed")
    }
}

fun main() {
    Dog("Buddy", "Golden Retriever")
}

Output:

Animal: Buddy
Dog Breed: Golden Retriever

Calling Secondary Constructors from Another:

You can call one secondary constructor from another using this().

class Product {
    constructor(name: String) : this(name, 100) {
        println("Product Name: $name")
    }

    constructor(name: String, price: Int) {
        println("Product Name: $name, Price: $price")
    }
}

fun main() {
    Product("Laptop")
}

Output:

Product Name: Laptop, Price: 100
Product Name: Laptop

Interfaces

In Kotlin, an interface is a collection of abstract methods and properties that define a contract for the classes implementing it. Interfaces allow a class to conform to specific behavior without enforcing the class to inherit an implementation. Unlike abstract classes, interfaces cannot hold state, but they can have methods with default implementations.

Interfaces in Kotlin serve as custom types that cannot be instantiated on their own. They define behaviors that implementing classes must provide, promoting polymorphism and reusability.

Defining an Interface:

You define an interface using the interface keyword, followed by the interface name and a set of abstract methods or properties that any implementing class must fulfill.

Example:

interface Machine {
    fun powerOn()
    fun powerOff()
}

Implementing an Interface:

Classes or objects can implement an interface by providing definitions for all its abstract members. To implement an interface, the class name is followed by a colon and the interface name.

class Computer: Machine {
    override fun powerOn() {
        println("Computer is powered on.")
    }

    override fun powerOff() {
        println("Computer is shutting down.")
    }
}

Example Demonstrating Interface Implementation:

interface Machine {
    fun powerOn()
    fun powerOff()
}

class Computer : Machine {
    override fun powerOn() {
        println("Computer is powered on.")
    }

    override fun powerOff() {
        println("Computer is shutting down.")
    }
}

fun main() {
    val myComputer = Computer()
    myComputer.powerOn()
    myComputer.powerOff()
}

Output:

Computer is powered on.
Computer is shutting down.

Default Methods and Parameters in Interfaces:

Interfaces can also define default implementations for methods and provide default parameter values. This allows classes to inherit functionality from the interface without needing to override every method.

interface Calculator {
    fun add(a: Int, b: Int = 10)
    fun display() {
        println("This is a default method.")
    }
}

class CalculatorImpl : Calculator {
    override fun add(a: Int, b: Int) {
        println("The sum is ${a + b}")
    }

    override fun display() {
        super.display()
        println("This method has been overridden.")
    }
}

fun main() {
    val calc = CalculatorImpl()
    calc.add(5)
    calc.display()
}

Output:

The sum is 15
This is a default method.
This method has been overridden.

Properties in Interfaces:

Just like methods, interfaces can also define properties. Since interfaces cannot maintain state, they either leave properties abstract or provide custom getters.

interface VehicleProperties {
    val speed: Int
    val type: String
        get() = "Unknown"
}

class CarProperties : VehicleProperties {
    override val speed: Int = 120
    override val type: String = "Sedan"
}

fun main() {
    val car = CarProperties()
    println(car.speed)
    println(car.type)
}

Output:

120
Sedan

Interface Inheritance:

Interfaces can also inherit other interfaces, allowing you to build more complex structures by combining multiple interfaces.

interface Dimensions {
    val length: Double
    val width: Double
}

interface Shape : Dimensions {
    fun area(): Double
}

class Rectangle(override val length: Double, override val width: Double) : Shape {
    override fun area(): Double = length * width
}

fun main() {
    val rect = Rectangle(5.0, 3.0)
    println("Area of rectangle: ${rect.area()}")
}

Output:

Area of rectangle: 15.0

Multiple Interface Implementation:

Kotlin allows classes to implement multiple interfaces, which is a form of multiple inheritance. A class must provide implementations for all abstract members of the interfaces it implements.

interface Speed {
    val maxSpeed: Int
}

interface Features {
    fun describe()
}

class SportsCar : Speed, Features {
    override val maxSpeed: Int = 200

    override fun describe() {
        println("This is a sports car with a maximum speed of $maxSpeed km/h.")
    }
}

fun main() {
    val car = SportsCar()
    car.describe()
}

Output:

This is a sports car with a maximum speed of 200 km/h.

Advantages of Using Interfaces in Kotlin:

1. Abstraction: Interfaces enable the definition of a common contract for different classes, improving modularity and abstraction.
2. Polymorphism: Multiple classes can implement the same interface, enabling polymorphic behavior and flexibility.
3. Code Reusability: Interfaces allow different classes to share common behavior, reducing code duplication and promoting reusability.

Disadvantages of Using Interfaces in Kotlin:

1. Limited Implementation: Interfaces cannot maintain state and can only define abstract methods and properties.
2. Increased Complexity: Implementing multiple interfaces can make code more complex, especially when dealing with large hierarchies.

Sealed Classes

Kotlin introduces a special kind of class that does not exist in Java: sealed classes. The purpose of sealed classes is to define a restricted class hierarchy where the set of possible subclasses is known and fixed at compile time. This feature allows more control and type safety when dealing with multiple types. A sealed class defines a group of subclasses within the same file.

Declaration of Sealed Class

The syntax to declare a sealed class is straightforward: it uses the sealed keyword before the class definition.

Syntax:

sealed class Example

When a class is marked as sealed, its subclasses must be defined in the same file. A sealed class cannot be instantiated directly because its constructor is protected by default.

Example of Sealed Class:

sealed class Shape {
    class Circle(val radius: Double): Shape() {
        fun display() {
            println("Circle with radius $radius")
        }
    }

    class Rectangle(val length: Double, val width: Double): Shape() {
        fun display() {
            println("Rectangle with length $length and width $width")
        }
    }
}

fun main() {
    val circle = Shape.Circle(3.0)
    circle.display()

    val rectangle = Shape.Rectangle(4.0, 5.0)
    rectangle.display()
}

Output:

Circle with radius 3.0
Rectangle with length 4.0 and width 5.0

Key Points about Sealed Classes:

1. Subclassing in the Same File: All subclasses of a sealed class must be defined in the same Kotlin file. However, they don’t need to be defined inside the sealed class itself.
2. Implicitly Abstract: Sealed classes are abstract by default, which means you cannot create an instance of a sealed class directly.

Example: Defining a Subclass Outside of Sealed Class

You can define subclasses of a sealed class outside of the sealed class body, but within the same file.

sealed class Transport

class Car(val brand: String): Transport() {
    fun details() {
        println("Car brand: $brand")
    }
}

class Bike(val model: String): Transport() {
    fun details() {
        println("Bike model: $model")
    }
}

fun main() {
    val car = Car("Toyota")
    val bike = Bike("Harley Davidson")

    car.details()
    bike.details()
}

Sealed Class with when Expression

The when expression is commonly used with sealed classes because it allows you to handle all possible cases exhaustively, without the need for an else clause.

sealed class Animal {
    class Dog : Animal()
    class Cat : Animal()
    class Elephant : Animal()
}

fun animalSound(animal: Animal) {
    when (animal) {
        is Animal.Dog -> println("Barks")
        is Animal.Cat -> println("Meows")
        is Animal.Elephant -> println("Trumpets")
    }
}

fun main() {
    animalSound(Animal.Dog())
    animalSound(Animal.Cat())
    animalSound(Animal.Elephant())
}

Output:

Barks
Meows
Trumpets

Sealed Class with External Subclass

Sealed classes can also work with subclasses defined outside their body, but they must reside in the same file.

sealed class Fruit(val name: String)

class Apple : Fruit("Apple")
class Banana : Fruit("Banana")

fun fruitInfo(fruit: Fruit) {
    when (fruit) {
        is Apple -> println("${fruit.name} is crunchy.")
        is Banana -> println("${fruit.name} is soft.")
    }
}

fun main() {
    val apple = Apple()
    val banana = Banana()

    fruitInfo(apple)
    fruitInfo(banana)
}

Output:

Apple is crunchy.
Banana is soft.

Advantages of Sealed Classes:

1. Type Safety: Sealed classes allow Kotlin to perform exhaustive when checks at compile-time, ensuring all cases are covered.
2. Control over Inheritance: Sealed classes restrict subclassing to the same file, giving more control over the hierarchy.
3. Better Design for Hierarchies: By restricting subclass creation, sealed classes allow for more predictable and structured designs

Enum Classes

In programming, enum classes are used to define a set of constants under one type. In Kotlin, enums are much more than just a collection of constants. They can also contain properties, methods, and can implement interfaces. In contrast to Java, where enums are limited, Kotlin treats enums as full-fledged classes.

Key Features of Kotlin Enums:

1. Enum constants are objects that can have properties and methods.
2. Each enum constant behaves like a separate instance of the enum class.
3. Enum constants improve code readability by assigning meaningful names to values.
4. You cannot create an instance of an enum class using a constructor.

Defining an Enum Class:

The syntax for declaring an enum class starts with the enum keyword, followed by the class name and the constants:

enum class Season {
    SPRING,
    SUMMER,
    AUTUMN,
    WINTER
}

Initializing Enums with Parameters

Enums in Kotlin can have constructors just like regular classes. These constructors can be used to initialize the constants with specific values.

Example: Initializing Enum Constants with Parameters

enum class Animal(val sound: String) {
    DOG("Bark"),
    CAT("Meow"),
    COW("Moo")
}

fun main() {
    val animalSound = Animal.DOG.sound
    println("The sound a dog makes: $animalSound")
}

Properties and Methods of Enum Classes

Enums in Kotlin have two built-in properties:

• ordinal: This gives the position of the enum constant, starting from 0.
• name: This returns the name of the constant.

They also have two methods:

• values(): Returns a list of all the constants in the enum.
• valueOf(): Returns the enum constant corresponding to the input string.

Example: Enum Class with Properties and Methods

enum class TrafficLight(val color: String) {
    RED("Red"),
    YELLOW("Yellow"),
    GREEN("Green")
}

fun main() {
    for (light in TrafficLight.values()) {
        println("${light.ordinal} = ${light.name} with color ${light.color}")
    }

    println(TrafficLight.valueOf("GREEN"))
}

Output:

0 = RED with color Red
1 = YELLOW with color Yellow
2 = GREEN with color Green
GREEN

Adding Methods to Enum Classes

Enum classes can have their own properties and methods, allowing you to provide behavior for each constant.

Example: Enum Class with Properties and Companion Object

enum class Days(val isHoliday: Boolean = false) {
    SUNDAY(true),
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY(true);

    companion object {
        fun isWeekend(day: Days): Boolean {
            return day == SUNDAY || day == SATURDAY
        }
    }
}

fun main() {
    for (day in Days.values()) {
        println("${day.name} is a holiday: ${day.isHoliday}")
    }

    val today = Days.FRIDAY
    println("Is today a weekend? ${Days.isWeekend(today)}")
}

Output:

SUNDAY is a holiday: true
MONDAY is a holiday: false
TUESDAY is a holiday: false
WEDNESDAY is a holiday: false
THURSDAY is a holiday: false
FRIDAY is a holiday: false
SATURDAY is a holiday: true
Is today a weekend? false

Enum Constants as Anonymous Classes

Each enum constant can override methods and behave like an anonymous class. This feature allows each constant to have different behavior.

Example: Enum with Anonymous Classes

enum class Device(val type: String) {
    LAPTOP("Portable Device") {
        override fun description() {
            println("A laptop is a ${this.type}")
        }
    },
    MOBILE("Handheld Device") {
        override fun description() {
            println("A mobile phone is a ${this.type}")
        }
    };

    abstract fun description()
}

fun main() {
    Device.LAPTOP.description()
    Device.MOBILE.description()
}

Output:

A laptop is a Portable Device
A mobile phone is a Handheld Device

Enum Class with when Expression

The when expression works very well with enum classes since all the possible values are already known. This eliminates the need for the else clause.

Example: Using Enum Class with when Expression

enum class Weather {
    SUNNY,
    CLOUDY,
    RAINY,
    WINDY
}

fun describeWeather(weather: Weather) {
    when (weather) {
        Weather.SUNNY -> println("The weather is sunny!")
        Weather.CLOUDY -> println("It's cloudy today.")
        Weather.RAINY -> println("It's raining outside.")
        Weather.WINDY -> println("Hold onto your hats, it's windy!")
    }
}

fun main() {
    describeWeather(Weather.SUNNY)
    describeWeather(Weather.RAINY)
}

Output:

The weather is sunny!
It's raining outside.

Advantages of Using Enum Classes:

1. Code Readability: Enum classes make the code more readable by assigning meaningful names to constants.
2. Type Safety: They restrict the possible values a variable can have, ensuring type safety.
3. Maintainability: Enum classes help organize related constants and behaviors in one place, improving maintainability.

Extension Functions

In Kotlin, you have the ability to enhance existing classes with new functionality without inheriting from them. This is made possible through extension functions. An extension function allows you to add methods to a class without modifying its source code. You define an extension function by appending the function to the class name, like so:

package kotlin1.com.programmingKotlin.chapter1

// A simple class demonstrating an extension function

class Rectangle(val length: Double, val width: Double) {
    // A member function that calculates the area of the rectangle
    fun area(): Double {
        return length * width
    }
}
fun main() {
    // Extension function to calculate the perimeter of the rectangle
    fun Rectangle.perimeter(): Double {
        return 2 * (length + width)
    }

    // Creating an instance of Rectangle
    val rect = Rectangle(5.0, 4.0)
    // Calling the member function
    println("Area of the rectangle is ${rect.area()}")
    // Calling the extension function
    println("Perimeter of the rectangle is ${rect.perimeter()}")
}

Output:

Area of the rectangle is 20.0
Perimeter of the rectangle is 18.0

Kotlin not only allows extension of user-defined classes but also library classes. You can easily extend classes from the Kotlin or Java standard libraries with custom methods.

Example: Extending a Standard Library Class

fun main() {
    // Extension function defined for String type
    fun String.lastChar(): Char {
        return this[this.length - 1]
    }

    println("Hello".lastChar()) // Output: 'o'
    println("World".lastChar()) // Output: 'd'
}

Generics

In Kotlin, you have the ability to enhance existing classes with new functionality without inheriting from them. This is made possible through extension functions. An extension function allows you to add methods to a class without modifying its source code. You define an extension function by appending the function to the class name, like so:

package kotlin1.com.programmingKotlin.chapter1

// A simple class demonstrating an extension function

class Rectangle(val length: Double, val width: Double) {
    // A member function that calculates the area of the rectangle
    fun area(): Double {
        return length * width
    }
}
fun main() {
    // Extension function to calculate the perimeter of the rectangle
    fun Rectangle.perimeter(): Double {
        return 2 * (length + width)
    }

    // Creating an instance of Rectangle
    val rect = Rectangle(5.0, 4.0)
    // Calling the member function
    println("Area of the rectangle is ${rect.area()}")
    // Calling the extension function
    println("Perimeter of the rectangle is ${rect.perimeter()}")
}

Output:

Area of the rectangle is 20.0
Perimeter of the rectangle is 18.0

Extending Library Classes

Kotlin not only allows extension of user-defined classes but also library classes. You can easily extend classes from the Kotlin or Java standard libraries with custom methods.

Example: Extending a Standard Library Class

fun main() {
    // Extension function defined for String type
    fun String.lastChar(): Char {
        return this[this.length - 1]
    }

    println("Hello".lastChar()) // Output: 'o'
    println("World".lastChar()) // Output: 'd'
}

Static Resolution of Extensions

It’s important to understand that extension functions are resolved statically, meaning the actual type of the object does not influence which extension function is called.

Example: Static Resolution of Extensions

open class Animal(val sound: String)

class Dog : Animal("Bark")

fun Animal.makeSound(): String {
    return "Animal sound: $sound"
}

fun Dog.makeSound(): String {
    return "Dog sound: $sound"
}

fun displaySound(animal: Animal) {
    println(animal.makeSound())
}

fun main() {
    displaySound(Dog())  // Will call Animal's makeSound(), not Dog's
}

Output:

Animal sound: Bark

Here, although the object passed is of type Dog, the extension function for Animal is called because extensions are statically resolved.

Nullable Receiver in Extension Functions

Kotlin allows you to define extension functions that can be invoked on nullable types.

Example: Extension Function with Nullable Receiver

class User(val name: String)

fun User?.greet() {
    if (this == null) {
        println("No user found")
    } else {
        println("Hello, ${this.name}")
    }
}

fun main() {
    val user: User? = User("John")
    user.greet()  // Output: Hello, John

    val noUser: User? = null
    noUser.greet()  // Output: No user found
}

Companion Object Extensions

In Kotlin, if a class has a companion object, you can also extend the companion object with new functions or properties.

Example: Extending Companion Object

class Utility {
    companion object {
        fun show() {
            println("Companion object method in Utility")
        }
    }
}

// Extension function for companion object
fun Utility.Companion.printInfo() {
    println("Extended companion object function")
}

fun main() {
    Utility.show()
    Utility.printInfo()
}

Output:

Companion object method in Utility
Extended companion object function

Advantages of Extension Functions

1. Code Reusability: By extending existing classes, you can avoid modifying original classes or creating new classes just for the purpose of adding more functionality.
2. Cleaner Code: Instead of creating utility methods, you can directly add functions to the class that improves readability.
3. No Inheritance Needed: You don’t need to inherit the class to add more methods

In Kotlin, collections are a key feature used to store and manage groups of data. Kotlin offers several types of collections, such as Lists, Sets, Maps, Arrays, and Sequences, each with distinct characteristics for handling data efficiently.

Types of Kotlin Collections

1. List: An ordered collection that allows duplicate elements. Elements can be accessed by their index.
2. Set: An unordered collection that holds unique elements, ensuring no duplicates.
3. Map: A collection of key-value pairs where each key is unique, but values can be duplicated.
4. Array: A fixed-size collection of elements of the same type.
5. Sequence: A lazily evaluated collection that can be processed step-by-step.

Example of Using a List in Kotlin:

val cities = listOf("New York", "London", "Paris", "Tokyo")

// Access elements
println("First city: ${cities[0]}")
println("Last city: ${cities.last()}")

// Iterate over the list
for (city in cities) {
    println(city)
}

// Filter the list
val filteredCities = cities.filter { it.startsWith("L") }
println("Filtered cities: $filteredCities")

Output:

First city: New York
Last city: Tokyo
New York
London
Paris
Tokyo
Filtered cities: [London]

Explanation: In this example, we create an immutable list of fruits, access elements, iterate over the list, and filter elements that start with the letter “a”.

ArrayList

Explanation: In this example, we create an immutable list of fruits, access elements, iterate over the list, and filter elements that start with the letter “a”.

Types of Collections in Kotlin

1. Immutable Collections : Immutable collections are read-only and cannot be modified after creation. Some common functions include:

• listOf(), setOf(), and mapOf().

Example of Immutable List:

val immutableList = listOf("John", "Sarah", "Emma")
for (person in immutableList) {
    println(person)
}

Output:

John
Sarah
Emma

Example of Immutable Set:

val immutableSet = setOf(3, 5, 3, "Alice", "Bob")
for (item in immutableSet) {
    println(item)
}

Output:

3
5
Alice
Bob

Example of Immutable Map:

val immutableMap = mapOf(1 to "Alice", 2 to "Bob", 3 to "Charlie")
for (key in immutableMap.keys) {
    println(immutableMap[key])
}

Output:

Alice
Bob
Charlie

Key Characteristics of Immutable Collections:

• Immutable lists, sets, and maps are fixed, and elements cannot be added, removed, or modified.

2. Mutable Collections : Mutable collections support both read and write operations, allowing modification of the collection. Common methods include:

• mutableListOf(), mutableSetOf(), mutableMapOf().

Example of Mutable List:

val mutableList = mutableListOf("John", "Sarah", "Emma")
mutableList[1] = "Mike"
mutableList.add("Lisa")
for (person in mutableList) {
    println(person)
}

Output:

John
Mike
Emma
Lisa

Example of Mutable Set:

val mutableSet = mutableSetOf(8, 12)
mutableSet.add(5)
mutableSet.add(10)
for (item in mutableSet) {
    println(item)
}

Output:

8
12
5
10

Example of Mutable Map:

val mutableMap = mutableMapOf(1 to "Alice", 2 to "Bob", 3 to "Charlie")
mutableMap[1] = "Dave"
mutableMap[4] = "Eve"
for (value in mutableMap.values) {
    println(value)
}

Output:

Dave
Bob
Charlie
Eve

Advantages of Kotlin Collections:

• Improved Readability: The use of collections makes code more readable by abstracting complex operations on data.
• Efficient Memory Management: Collections handle memory automatically, reducing the need for manual intervention.
• Efficient Data Operations: Kotlin’s collections are designed to work efficiently with large datasets.
• Type Safety: Collections enforce type safety, ensuring that only the correct type of data can be stored.

Disadvantages of Kotlin Collections:

• Performance Overhead: Using collections can add overhead, particularly when compared to working directly with primitive types or arrays.
• Increased Memory Usage: Larger collections may consume more memory than necessary for simple operations.
• Additional Complexity: In some cases, collections may add unnecessary complexity when performing advanced operations on data.

The ArrayList class in Kotlin is a dynamic array that allows you to increase or decrease its size as needed. It provides both read and write operations and allows duplicate elements. Since it is not synchronized, ArrayList is not thread-safe, but it is efficient for single-threaded operations.

Key Features of ArrayList:

• Dynamic resizing: The array size grows or shrinks as required.
• Read/write functionality: You can modify elements after creation.
• Non-synchronized: It is not thread-safe, but efficient in single-threaded environments.
• Duplicate elements: It allows duplicates, unlike Set.
• Index-based access: You can access and manipulate elements via their index.

Constructors

1. ArrayList<E>(): Creates an empty ArrayList.
2. ArrayList(capacity: Int): Creates an ArrayList of specified capacity.
3. ArrayList(elements: Collection<E>): Fills an ArrayList with elements from a collection.

Important Methods

1. add(index: Int, element: E): Inserts an element at the specified index.

Example:

fun main() {
    val arrayList = ArrayList<String>()
    arrayList.add("Lion")
    arrayList.add("Tiger")

    println("Array list --->")
    for (item in arrayList) println(item)

    arrayList.add(1, "Elephant")
    println("Array list after insertion --->")
    for (item in arrayList) println(item)
}

Output:

Array list --->
Lion
Tiger
Array list after insertion --->
Lion
Elephant
Tiger

2. addAll(index: Int, elements: Collection<E>) : Adds all elements from a specified collection to the current list.

Example:

fun main() {
    val arrayList = ArrayList<String>()
    arrayList.add("Red")
    arrayList.add("Blue")

    val additionalColors = arrayListOf("Green", "Yellow")

    println("Original ArrayList -->")
    for (item in arrayList) println(item)

    arrayList.addAll(1, additionalColors)
    println("ArrayList after adding new colors -->")
    for (item in arrayList) println(item)
}

Output:

Original ArrayList -->
Red
Blue
ArrayList after adding new colors -->
Red
Green
Yellow
Blue

3. get(index: Int): Returns the element at the specified index.

Example:

fun main() {
    val arrayList = ArrayList<Int>()
    arrayList.add(100)
    arrayList.add(200)
    arrayList.add(300)

    println("All elements:")
    for (item in arrayList) print("$item ")

    println("\nElement at index 1: ${arrayList.get(1)}")
}

Output:

All elements:
100 200 300
Element at index 1: 200

4. set(index: Int, element: E):Replaces the element at the specified index with the given element.

Example:

fun main() {
    val arrayList = ArrayList<String>()
    arrayList.add("Dog")
    arrayList.add("Cat")
    arrayList.add("Rabbit")

    println("Before update:")
    for (item in arrayList) println(item)

    arrayList.set(2, "Horse")
    println("After update:")
    for (item in arrayList) println(item)
}

Output:

Before update:
Dog
Cat
Rabbit
After update:
Dog
Cat
Horse

5. indexOf(element: E): Returns the index of the first occurrence of the specified element, or -1 if the element is not found.

Example:

fun main() {
    val arrayList = ArrayList<String>()
    arrayList.add("Apple")
    arrayList.add("Banana")
    arrayList.add("Apple")

    for (item in arrayList) print("$item ")
    println("\nFirst occurrence of 'Apple': ${arrayList.indexOf("Apple")}")
}

Output:

Apple Banana Apple
First occurrence of 'Apple': 0

6. remove(element: E): Removes the first occurrence of the specified element.

Example:

fun main() {
    val arrayList = ArrayList<String>()
    arrayList.add("Car")
    arrayList.add("Bike")
    arrayList.add("Bus")

    println("Before removal:")
    for (item in arrayList) println(item)

    arrayList.remove("Bike")
    println("After removal:")
    for (item in arrayList) println(item)
}

Output:

Before removal:
Car
Bike
Bus
After removal:
Car
Bus

7. clear():Removes all elements from the ArrayList.

Example:

fun main() {
    val arrayList = ArrayList<Int>()
    arrayList.add(1)
    arrayList.add(2)
    arrayList.add(3)
    arrayList.add(4)

    println("Before clearing:")
    for (item in arrayList) print("$item ")

    arrayList.clear()
    println("\nArrayList size after clear: ${arrayList.size}")
}

Output:

Before clearing:
1 2 3 4
ArrayList size after clear: 0

Full Example Using ArrayList:

fun main() {
    val list = arrayListOf(5, 10, 15)

    println("Initial list: $list")

    // Add elements to the list
    list.add(20)
    list.add(1, 25) // Adds 25 at index 1

    println("After adding elements: $list")

    // Remove elements from the list
    list.remove(10)
    list.removeAt(0) // Removes element at index 0

    println("After removing elements: $list")

    // Update elements in the list
    list[1] = 30

    println("After updating elements: $list")

    // Access elements in the list
    val first = list[0]
    val last = list.last()

    println("First element: $first")
    println("Last element: $last")

    // Iterate over the list
    for (element in list) {
        println(element)
    }
}

Output:

Initial list: [5, 10, 15]
After adding elements: [5, 25, 10, 15, 20]
After removing elements: [25, 15, 20]
After updating elements: [25, 30, 20]
First element: 25
Last element: 20
25
30
20

listOf()

In Kotlin, listOf() is used to create immutable lists, meaning once the list is created, its elements cannot be modified. The listOf() function takes a variable number of arguments and returns a new list containing those elements.

Example:

val numbers = listOf(10, 20, 30, 40, 50)

In this example, the list numbers is immutable, and contains five integers. Since the list is immutable, you cannot change its contents once it is created.

Accessing Elements in a List:

Elements can be accessed using indices.

Example:

val firstNumber = numbers[0]  // returns 10
val lastNumber = numbers[numbers.size - 1]  // returns 50

In this example, we use indexing to access the first and last elements of the list. Note that indexing starts at 0.

Iterating Over a List:

You can iterate over the list using a for loop or other iteration methods.

Example:

for (number in numbers) {
    println(number)
}

This will print each element of the numbers list to the console.

Advantages of Using listOf() in Kotlin:

1. Immutability: Once created, the list cannot be modified, which makes it safer for multi-threaded environments.
2. Type Safety: Since Kotlin is statically typed, the elements of the list will always be of the same type.
3. Convenience: You can easily create a list with multiple elements using a single function.

Disadvantages of Using listOf():

1. Immutability: If you need to modify the list during runtime, you should use mutableListOf() instead.
2. Performance Overhead: Since immutable lists cannot be modified, operations that modify the list (like adding or removing elements) require creating new lists, which can be inefficient.
3. Limited Functionality: listOf() does not support operations like adding or removing elements. For these, you need a mutable list.

Kotlin Program with listOf() Containing Integers:

val set = setOf("Apple", "Banana", "Cherry", "Apple")
println(set)  // Output: [Apple, Banana, Cherry]

// set.add("Date")  // Error: Cannot add element to immutable set

Output:

List size: 3
Index of 22: 1
Element at index 2: 33

Indexing Elements of a List:

In Kotlin, elements of a list are indexed starting from 0.

Example:

fun main() {
    val numbers = listOf(5, 10, 15, 20, 25, 30, 35)

    val firstElement = numbers[0]
    println("First element: $firstElement")

    val seventhElement = numbers[6]
    println("Element at index 6: $seventhElement")

    val firstIndex = numbers.indexOf(5)
    println("Index of first occurrence of 5: $firstIndex")

    val lastIndex = numbers.lastIndexOf(5)
    println("Last index of 5: $lastIndex")

    val lastIndexOverall = numbers.lastIndex
    println("Last index of the list: $lastIndexOverall")
}

Output:

First element: 5
Element at index 6: 35
Index of first occurrence of 5: 0
Last index of 5: 0
Last index of the list: 6

Retrieving First and Last Elements:

You can retrieve the first and last elements of the list without using the get() method.

Example:

fun main() {
    val numbers = listOf(3, 6, 9, 12, 15)
    println("First element: ${numbers.first()}")
    println("Last element: ${numbers.last()}")
}

Output:

First element: 3
Last element: 15

List Iteration Methods:

Kotlin provides several ways to iterate over lists.

Example:

fun main() {
    val fruits = listOf("Apple", "Banana", "Cherry", "Date", "Elderberry")

    // Method 1: Simple for loop
    for (fruit in fruits) {
        print("$fruit, ")
    }
    println()

    // Method 2: Using index
    for (i in fruits.indices) {
        print("${fruits[i]} ")
    }
    println()

    // Method 3: Using forEachIndexed
    fruits.forEachIndexed { index, fruit -> println("fruits[$index] = $fruit") }

    // Method 4: Using ListIterator
    val iterator: ListIterator<String> = fruits.listIterator()
    while (iterator.hasNext()) {
        val fruit = iterator.next()
        print("$fruit ")
    }
    println()
}

Output:

Apple, Banana, Cherry, Date, Elderberry,
Apple Banana Cherry Date Elderberry
fruits[0] = Apple
fruits[1] = Banana
fruits[2] = Cherry
fruits[3] = Date
fruits[4] = Elderberry
Apple Banana Cherry Date Elderberry

Sorting Elements in a List:

You can sort the elements in ascending or descending order using sorted() and sortedDescending().

Example:

fun main() {
    val numbers = listOf(42, 12, 7, 99, 23, 1)

    val ascendingOrder = numbers.sorted()
    println("Sorted in ascending order: $ascendingOrder")

    val descendingOrder = numbers.sortedDescending()
    println("Sorted in descending order: $descendingOrder")
}

Output:

Sorted in ascending order: [1, 7, 12, 23, 42, 99]
Sorted in descending order: [99, 42, 23, 12, 7, 1]

contains() and containsAll() Functions:

These methods check if a list contains certain elements.

Example:

fun main() {
    val numbers = listOf(3, 5, 7, 9, 11)

    val containsSeven = numbers.contains(7)
    if (containsSeven) {
        println("The list contains 7")
    } else {
        println("The list does not contain 7")
    }

    val containsThreeAndTen = numbers.containsAll(listOf(3, 10))
    if (containsThreeAndTen) {
        println("The list contains 3 and 10")
    } else {
        println("The list does not contain 3 and 10")
    }
}

Output:

The list contains 7
The list does not contain 3 and 10

Kotlin Set Interface

The Set interface in Kotlin represents an unordered collection of unique elements. Sets are particularly useful when you need to store data without duplicates. Kotlin supports two types of sets:

1. Immutable Sets: These are created using setOf() and only support read-only operations.
2. Mutable Sets: These are created using mutableSetOf() and support both read and write operations.

Syntax for setOf():

fun <T> setOf(vararg elements: T): Set<T>

1. Immutable Set Using setOf(): This function creates an immutable set that can hold any number of elements of the same type, and it returns a set that does not contain duplicate elements.

Example:

fun main() {
    val setA = setOf("Kotlin", "Java", "Python")
    val setB = setOf('A', 'B', 'C')
    val setC = setOf(10, 20, 30, 40)

    // Traverse through the sets
    for (item in setA) print(item + " ")
    println()
    for (item in setB) print(item + " ")
    println()
    for (item in setC) print(item.toString() + " ")
}

Output:

Kotlin Java Python
A B C
10 20 30 40

2. Mutable Sets in Kotlin (using mutableSetOf()): A mutable set is a collection that allows modifications after it is created. You can add, remove, or update elements in a mutable set. This is particularly useful when you need a set with dynamic content.

Example:

val colors = mutableSetOf("Red", "Green", "Blue")

// Adding elements
colors.add("Yellow")
println(colors) // Output: [Red, Green, Blue, Yellow]

// Removing elements
colors.remove("Green")
println(colors) // Output: [Red, Blue, Yellow]

// Checking for an element
println("Contains Blue? ${"Blue" in colors}") // Output: Contains Blue? true

// Adding duplicate elements
colors.add("Red") // Ignored, as "Red" already exists
println(colors) // Output: [Red, Blue, Yellow]

Set Indexing

You can access elements at specific indexes in a set using functions like elementAt(), indexOf(), and lastIndexOf().

Example: Using Index in Set

fun main() {
    val players = setOf("Virat", "Smith", "Root", "Kane", "Rohit")

    println("Element at index 2: " + players.elementAt(2))
    println("Index of 'Smith': " + players.indexOf("Smith"))
    println("Last index of 'Rohit': " + players.lastIndexOf("Rohit"))
}

Output:

Element at index 2: Root
Index of 'Smith': 1
Last index of 'Rohit': 4

Set First and Last Elements

You can retrieve the first and last elements using first() and last() functions.

Example: First and Last Element in Set

fun main() {
    val elements = setOf(1, 2, 3, "A", "B", "C")

    println("First element: " + elements.first())
    println("Last element: " + elements.last())
}

Output:

First element: 1
Last element: C

Set Basic Functions

Basic functions like count(), max(), min(), sum(), and average() help perform arithmetic operations on sets of numbers.

Example: Basic Functions with Set

fun main() {
    val numbers = setOf(5, 10, 15, 20, 25)

    println("Count of elements: " + numbers.count())
    println("Maximum element: " + numbers.maxOrNull())
    println("Minimum element: " + numbers.minOrNull())
    println("Sum of elements: " + numbers.sum())
    println("Average of elements: " + numbers.average())
}

Output:

Count of elements: 5
Maximum element: 25
Minimum element: 5
Sum of elements: 75
Average of elements: 15.0

Checking Elements with contains() and containsAll()

The contains() function checks if a set contains a specific element, and containsAll() checks if a set contains all specified elements.

Example: Using contains() and containsAll()

fun main() {
    val captains = setOf("Kohli", "Smith", "Root", "Rohit")

    val element = "Rohit"
    println("Does the set contain $element? " + captains.contains(element))

    val elementsToCheck = setOf("Kohli", "Smith")
    println("Does the set contain all elements? " + captains.containsAll(elementsToCheck))
}

Output:

Does the set contain Rohit? true
Does the set contain all elements? true

hashSetOf()

hashSetOf creates a mutable set of unique elements backed by a hash table.

Example:

fun main() {
    val emptySetA = setOf<String>()
    val emptySetB = setOf<Int>()

    println("Is setA empty? " + emptySetA.isEmpty())
    println("Are both sets equal? " + (emptySetA == emptySetB))
}

Output:

Is setA empty? true
Are both sets equal? true

Example: Set Operations Using setOf()

fun main() {
    val fruits = setOf("Apple", "Banana", "Cherry")

    val containsApple = fruits.contains("Apple")
    val containsOrange = fruits.contains("Orange")

    println("Fruits: $fruits")
    println("Contains Apple: $containsApple")
    println("Contains Orange: $containsOrange")

    for (fruit in fruits) {
        println(fruit)
    }
}

Output:

Fruits: [Apple, Banana, Cherry]
Contains Apple: true
Contains Orange: false
Apple
Banana
Cherry

Advantages of setOf() in Kotlin:

• Immutability: The contents cannot be modified once created, making the set safe for use in multithreaded environments.
• No Duplicates: The set automatically ensures that no duplicates are present, which reduces bugs.
• Convenience: Creating a set with setOf() is simple and concise.

Disadvantages of setOf() in Kotlin:

• Immutability: You cannot modify the set after its creation, which may limit its use in situations where you need to add or remove elements dynamically.
• No Advanced Features: For more advanced operations (like adding or removing elements), you will need to use a mutable set via mutableSetOf().

mapOf()

In Kotlin, a Map is a collection that stores data as key-value pairs. Each pair associates a unique key with a corresponding value, and the keys in a map must be distinct. A map can hold only one value per key.

Kotlin distinguishes between immutable maps, which are created using mapOf(), and mutable maps, created using mutableMapOf(). An immutable map is read-only, while a mutable map allows both reading and writing.

Syntax:

fun <K, V> mapOf(vararg pairs: Pair<K, V>): Map<K, V>

In each pair, the first value represents the key, and the second value represents the corresponding value. If multiple pairs have the same key, the map will store only the last value associated with that key. The entries in the map are traversed in the specified order.

Example: Using mapOf()

fun main() {
    // Creating a map of integer to string
    val map = mapOf(10 to "Apple", 20 to "Banana", 30 to "Cherry")
    // Printing the map
    println(map)
}

Output:

{10=Apple, 20=Banana, 30=Cherry}

Accessing Map Keys, Values, and Entries

fun main() {
    // Creating a map of integers to strings
    val fruits = mapOf(1 to "Mango", 2 to "Orange", 3 to "Peach", 4 to "Grape")

    println("Map Entries: $fruits")
    println("Map Keys: ${fruits.keys}")
    println("Map Values: ${fruits.values}")
}

Output:

Map Entries: {1=Mango, 2=Orange, 3=Peach, 4=Grape}
Map Keys: [1, 2, 3, 4]
Map Values: [Mango, Orange, Peach, Grape]

Determining the Map Size

You can determine the size of a map using either the size property or the count() method:

fun main() {
    val countries = mapOf(1 to "USA", 2 to "Canada", 3 to "Japan", 4 to "Germany")

    // Method 1
    println("The size of the map is: ${countries.size}")

    // Method 2
    println("The size of the map is: ${countries.count()}")
}

Output:

The size of the map is: 4
The size of the map is: 4

Creating an Empty Map

You can create an empty map using mapOf():

fun main() {
    // Creating an empty map
    val emptyMap = mapOf<String, Int>()

    println("Entries: ${emptyMap.entries}")
    println("Keys: ${emptyMap.keys}")
    println("Values: ${emptyMap.values}")
}

Output:

Entries: []
Keys: []
Values: []

Retrieving Values from a Map

Here are several ways to retrieve values from a map:

fun main() {
    val capitals = mapOf(1 to "Tokyo", 2 to "Paris", 3 to "London", 4 to "Berlin")

    // Method 1
    println("The capital at rank #1 is: ${capitals[1]}")

    // Method 2
    println("The capital at rank #3 is: ${capitals.getValue(3)}")

    // Method 3
    println("The capital at rank #4 is: ${capitals.getOrDefault(4, "Unknown")}")

    // Method 4
    val city = capitals.getOrElse(2) { "No City" }
    println(city)
}

Output:

The capital at rank #1 is: Tokyo
The capital at rank #3 is: London
The capital at rank #4 is: Berlin
Paris

Checking if a Map Contains a Key or Value

You can check if a map contains a specific key or value using the containsKey() and containsValue() methods:

fun main() {
    val numbers = mapOf("one" to 1, "two" to 2, "three" to 3)

    val key = "two"
    if (numbers.containsKey(key)) {
        println("Yes, the map contains key $key")
    } else {
        println("No, it doesn't contain key $key")
    }

    val value = 4
    if (numbers.containsValue(value)) {
        println("Yes, the map contains value $value")
    } else {
        println("No, it doesn't contain value $value")
    }
}

Output:

Yes, the map contains key two
No, it doesn't contain value 4

Handling Duplicate Keys

If two pairs have the same key, the map will retain only the last value:

fun main() {
    // Two pairs with the same key
    val map = mapOf(1 to "Alpha", 2 to "Beta", 1 to "Gamma")
    println("Entries in the map: ${map.entries}")
}

Output:

Entries in the map: [1=Gamma, 2=Beta]

Advantages of mapOf():

• Provides a straightforward way to create a key-value mapping.
• Read-only maps are safe for use across functions and threads without the risk of concurrent modification.

Disadvantages of mapOf():

• Immutable, meaning the map cannot be altered after creation. For modifiable maps, mutableMapOf() should be used.
• May become inefficient with a large number of entries, as lookup times can degrade. For more frequent lookups, a data structure like a hash table or binary tree may be more appropriate.

HashMap

A Kotlin HashMap is a collection that holds key-value pairs, implemented using a hash table. It implements the MutableMap interface, meaning that you can modify its contents. Each key within a HashMap is unique, and the map will store only one value per key. The HashMap is declared as HashMap<key, value> or HashMap<K, V>. This hash table-based implementation does not guarantee the order of the keys, values, or entries in the map.

Constructors of Kotlin HashMap Class:

Kotlin provides four constructors for the HashMap class, all of which have a public access modifier:

• HashMap(): The default constructor, which creates an empty HashMap.
• HashMap(initialCapacity: Int, loadFactor: Float = 0f): This constructor initializes a HashMap with a specified capacity and an optional load factor. If neither is provided, the default values are used.
• HashMap(initialCapacity: Int): Constructs a HashMap with the specified initial capacity. If the capacity isn’t used, it is ignored.
• HashMap(original: Map<out K, V>): Creates a new HashMap instance that contains the same mappings as the provided map.

fun main(args: Array<String>) {
    // Define an empty HashMap with <String, Int>
    val heroesMap: HashMap<String, Int> = HashMap()

    // Printing the empty HashMap
    printMap(heroesMap)

    // Adding elements to the HashMap using put() function
    heroesMap["CaptainAmerica"] = 1940
    heroesMap["Hulk"] = 5000
    heroesMap["BlackWidow"] = 1000
    heroesMap["DoctorStrange"] = 1500
    heroesMap["AntMan"] = 700

    // Printing the non-empty HashMap
    printMap(heroesMap)

    // Using Kotlin's print function to get the same result
    println("heroesMap: $heroesMap\n")

    // Traversing the HashMap using a for loop
    for (key in heroesMap.keys) {
        println("Element at key $key : ${heroesMap[key]}")
    }

    // Creating another HashMap with the previous heroesMap object
    val copyOfHeroesMap: HashMap<String, Int> = HashMap(heroesMap)

    println("\nCopy of HeroesMap:")
    for (key in copyOfHeroesMap.keys) {
        println("Element at key $key : ${copyOfHeroesMap[key]}")
    }

    // Clearing the HashMap
    println("heroesMap.clear()")
    heroesMap.clear()

    println("After Clearing: $heroesMap")
}

// Function to print the HashMap
fun printMap(map: HashMap<String, Int>) {
    if (map.isEmpty()) {
        println("The HashMap is empty")
    } else {
        println("HashMap: $map")
    }
}

Output:

val hashMap = HashMap<Int, String>()
hashMap[1] = "Apple"
hashMap[2] = "Banana"
hashMap[3] = "Cherry"

println(hashMap)  // Output: {1=Apple, 2=Banana, 3=Cherry}

hashMap[4] = "Date"
println(hashMap)  // Output: {1=Apple, 2=Banana, 3=Cherry, 4=Date}

hashMap.remove(2)
println(hashMap)  // Output: {1=Apple, 3=Cherry, 4=Date}

Explanation of Changes:

1. Updated Key-Value Pairs: Changed the keys to other superhero names like “CaptainAmerica”, “Hulk”, etc., and assigned different values.
2. Renamed Variables: Renamed the hashMap variable to heroesMap for better readability, and secondHashMap to copyOfHeroesMap.
3. Simplified Code: Improved readability and kept the method calls the same while modifying variable names and values.

Output:

The HashMap is empty

HashMap: {CaptainAmerica=1940, Hulk=5000, BlackWidow=1000, DoctorStrange=1500, AntMan=700}
heroesMap: {CaptainAmerica=1940, Hulk=5000, BlackWidow=1000, DoctorStrange=1500, AntMan=700}

Element at key CaptainAmerica : 1940
Element at key Hulk : 5000
Element at key BlackWidow : 1000
Element at key DoctorStrange : 1500
Element at key AntMan : 700

Copy of HeroesMap:
Element at key CaptainAmerica : 1940
Element at key Hulk : 5000
Element at key BlackWidow : 1000
Element at key DoctorStrange : 1500
Element at key AntMan : 700

heroesMap.clear()
After Clearing: {}

Kotlin Program Using HashMap Functions (get(), replace(), put())

fun main(args: Array<String>) {
    // Create an empty HashMap with <String, Int>
    val heroesMap: HashMap<String, Int> = HashMap()

    // Adding elements to the HashMap using put() function
    heroesMap.put("Batman", 5000)
    heroesMap.put("Superman", 2000)
    heroesMap.put("WonderWoman", 3000)
    heroesMap.put("Flash", 1500)

    // Printing the initial HashMap
    for (key in heroesMap.keys) {
        println("Element at key $key : ${heroesMap[key]}")
    }

    // Accessing elements using hashMap[key]
    println("\nheroesMap[\"Batman\"]: ${heroesMap["Batman"]}")

    // Updating a value using put() function
    heroesMap["Superman"] = 4000
    println("heroesMap.get(\"Superman\"): ${heroesMap.get("Superman")}\n")

    // Replacing values using replace() and put()
    heroesMap.replace("Flash", 1800)
    heroesMap.put("Superman", 4000)

    println("After replacing 'Flash' and updating 'Superman':")

    // Printing the updated HashMap
    for (key in heroesMap.keys) {
        println("Element at key $key : ${heroesMap[key]}")
    }
}

Output:

Element at key Batman : 5000
Element at key Superman : 2000
Element at key WonderWoman : 3000
Element at key Flash : 1500

heroesMap["Batman"]: 5000
heroesMap.get("Superman"): 4000

After replacing 'Flash' and updating 'Superman':
Element at key Batman : 5000
Element at key Superman : 4000
Element at key WonderWoman : 3000
Element at key Flash : 1800

Advantages of HashMap:

• HashMap offers a versatile way to store key-value pairs, making it simple and convenient to use.
• It provides highly efficient O(1) time complexity for common operations like adding, removing, and retrieving elements.
• HashMap is capable of storing various types of data, including custom objects, making it adaptable to different scenarios.

Disadvantages of HashMap:

• HashMap tends to consume more memory than other data structures because it holds both keys and values.
• By default, HashMap is not thread-safe, meaning concurrent access without proper synchronization can lead to data corruption or unexpected behavior. For multi-threaded access, a thread-safe alternative or synchronization mechanisms should be implemented.
• HashMap does not guarantee the order of elements, which can be a drawback if the order of entries is important. In such cases, you may want to consider using a different structure like LinkedHashMap that maintains the order of insertion.