The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Collections and Generics

Next ►
►

Introduction

In this module, we will explore two powerful features of Kotlin: Collections and Generics. Collections are used to store groups of related objects, while Generics allow you to write flexible and reusable code. Understanding these concepts is crucial for writing efficient and type-safe Kotlin programs.

Collections

Kotlin provides a rich set of collection types, including lists, sets, and maps. These collections can be either mutable or immutable.

Lists

A list is an ordered collection of elements. Kotlin provides both mutable and immutable lists.

Immutable List

val fruits = listOf("Apple", "Banana", "Cherry")
println(fruits) // Output: [Apple, Banana, Cherry]

Mutable List

val fruits = mutableListOf("Apple", "Banana")
fruits.add("Cherry")
println(fruits) // Output: [Apple, Banana, Cherry]

Sets

A set is an unordered collection of unique elements.

Immutable Set

val numbers = setOf(1, 2, 3, 2)
println(numbers) // Output: [1, 2, 3]

Mutable Set

val numbers = mutableSetOf(1, 2, 3)
numbers.add(4)
println(numbers) // Output: [1, 2, 3, 4]

Maps

A map is a collection of key-value pairs.

Immutable Map

val map = mapOf("name" to "John", "age" to 30)
println(map) // Output: {name=John, age=30}

Mutable Map

val map = mutableMapOf("name" to "John")
map["age"] = 30
println(map) // Output: {name=John, age=30}

Generics

Generics allow you to define classes, interfaces, and functions with type parameters. This makes your code more flexible and type-safe.

Generic Classes

class Box<T>(t: T) {
    var value = t
}

val intBox = Box(1)
val stringBox = Box("Hello")
println(intBox.value) // Output: 1
println(stringBox.value) // Output: Hello

Generic Functions

fun <T> singletonList(item: T): List<T> {
    return listOf(item)
}

val list = singletonList(42)
println(list) // Output: [42]

Type Constraints

You can restrict the types that can be used as type arguments.

fun <T : Comparable<T>> sort(list: List<T>) {
    // Sorting logic
}

sort(listOf(3, 1, 2)) // Valid
// sort(listOf("a", 1)) // Error: Type mismatch

Practical Exercises

Exercise 1: Create a Mutable List

Create a mutable list of integers and add five numbers to it. Then, print the list.

Solution

val numbers = mutableListOf<Int>()
numbers.add(1)
numbers.add(2)
numbers.add(3)
numbers.add(4)
numbers.add(5)
println(numbers) // Output: [1, 2, 3, 4, 5]

Exercise 2: Use a Generic Function

Write a generic function that takes a list of any type and returns the first element.

Solution

fun <T> firstElement(list: List<T>): T {
    return list[0]
}

val numbers = listOf(1, 2, 3)
val firstNumber = firstElement(numbers)
println(firstNumber) // Output: 1

val words = listOf("apple", "banana", "cherry")
val firstWord = firstElement(words)
println(firstWord) // Output: apple

Common Mistakes and Tips

  • Immutable vs Mutable Collections: Ensure you understand the difference between immutable and mutable collections. Immutable collections cannot be modified after creation, while mutable collections can.
  • Type Safety with Generics: Use generics to ensure type safety and avoid runtime errors. Always specify type parameters when defining generic classes or functions.
  • Type Constraints: Use type constraints to restrict the types that can be used as type arguments, ensuring that your generic functions and classes work as expected.

Conclusion

In this module, we covered the basics of collections and generics in Kotlin. We learned about different types of collections (lists, sets, and maps) and how to use them. We also explored generics, including generic classes, functions, and type constraints. Understanding these concepts will help you write more flexible, reusable, and type-safe code. In the next module, we will delve into higher-order functions and functional programming in Kotlin.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved