Generic class declaration in Kotlin - Time & Space Complexity

Time Complexity: Generic class declaration

O(n)

Understanding Time Complexity

Let's see how the time needed to create and use a generic class changes as we add more items.

We want to know how the program's work grows when the number of stored items grows.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

class Box<T> {
    private val items = mutableListOf<T>()

    fun add(item: T) {
        items.add(item)
    }

    fun get(index: Int): T {
        return items[index]
    }
}
    

This code defines a generic Box class that can hold items of any type. It adds items and gets them by index.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Adding an item to the list and accessing an item by index.
• How many times: Each add or get is done once per call, no loops inside these methods.

How Execution Grows With Input

Adding or getting one item takes about the same time no matter how many items are in the box.

Input Size (n)	Approx. Operations
10	10 adds = 10 operations
100	100 adds = 100 operations
1000	1000 adds = 1000 operations

Pattern observation: The work grows directly with the number of items added, one operation per item.

Final Time Complexity

Time Complexity: O(n)

This means the time to add n items grows in a straight line with n; each item takes about the same time.

Common Mistake

[X] Wrong: "Adding an item takes longer as the box gets full because it has to check all items."

[OK] Correct: The list adds items at the end quickly without checking all items, so each add takes about the same time.

Interview Connect

Understanding how generic classes handle data helps you explain how your code scales when storing many items, a useful skill in many coding tasks.

Self-Check

"What if the get method searched for an item by value instead of using an index? How would the time complexity change?"

Practice

1. What is the purpose of declaring a generic class in Kotlin using <T>?

easy

A. To restrict the class to only work with integers

B. To allow the class to work with any data type without rewriting code

C. To make the class abstract

D. To create a singleton class

Solution

1. Step 1: Understand generic class declaration

   Declaring a generic class with <T> means the class can accept any type as a parameter.

2. Step 2: Identify the benefit

   This allows the class to be flexible and reusable for different data types without rewriting the code.

3. Final Answer:

   To allow the class to work with any data type without rewriting code -> Option B

4. Quick Check:

   Generics = Flexible types [OK]

Hint: Generics mean 'any type' for flexible classes [OK]

Common Mistakes:

• Thinking generics restrict types instead of generalizing
• Confusing generics with abstract classes
• Assuming generics create singletons

2. Which of the following is the correct syntax to declare a generic class named Box in Kotlin?

easy

A. class Box<T>;

B. class Box[T] { }

C. class Box<T> { }

D. class Box {<T>}

Solution

1. Step 1: Recall Kotlin generic syntax

   Kotlin uses angle brackets <> to declare generics after the class name.

2. Step 2: Check each option

   Only class Box<T> { } is correct, using angle brackets after the class name. The other options use semicolon after <T>, square brackets, or place <T> inside the braces.

3. Final Answer:

   class Box<T> { } -> Option C

4. Quick Check:

   Generics use <> brackets [OK]

Hint: Use angle brackets <T> after class name for generics [OK]

Common Mistakes:

• Using square brackets [] instead of angle brackets
• Adding semicolon after class declaration
• Placing <T> inside curly braces

3. What will be the output of the following Kotlin code?

class Box<T>(val value: T) {
    fun getValue(): T = value
}

fun main() {
    val intBox = Box(123)
    val strBox = Box("Hello")
    println(intBox.getValue())
    println(strBox.getValue())
}

medium

A. 123\nHello

B. Box@123\nBox@Hello

C. Error: Type mismatch

D. null\nnull

Solution

1. Step 1: Understand generic class usage

   The class Box holds a value of any type and returns it via getValue().

2. Step 2: Trace the main function

   Two instances are created: one with an integer 123 and one with a string "Hello". Calling getValue() returns these values.

3. Final Answer:

   123 Hello -> Option A

4. Quick Check:

   Generic class returns stored value [OK]

Hint: Generic class returns stored value as is [OK]

Common Mistakes:

• Expecting object reference output instead of value
• Confusing type inference causing errors
• Assuming null is returned

4. Identify the error in the following Kotlin generic class declaration:

class Container<T> {
    var item: T
    constructor(item: T) {
        this.item = item
    }
}

medium

A. No error, code is correct

B. Constructor syntax is incorrect

C. Generic type T is not declared properly

D. Property 'item' must be initialized or be abstract

Solution

1. Step 1: Check property initialization

   The property item is declared but not initialized and not marked as abstract or lateinit.

2. Step 2: Understand Kotlin property rules

   In Kotlin, non-null properties must be initialized or declared abstract/lateinit. Here, item is neither initialized nor marked, causing a compile error.

3. Final Answer:

   Property 'item' must be initialized or be abstract -> Option D

4. Quick Check:

   Uninitialized property causes error [OK]

Hint: Initialize properties or mark lateinit/abstract [OK]

Common Mistakes:

• Forgetting to initialize properties
• Misunderstanding constructor syntax
• Thinking generic declaration is wrong

5. You want to create a generic class PairBox that holds two values of possibly different types. Which is the correct declaration for this class in Kotlin?

hard

A. class PairBox(val first: T, val second: U)

B. class PairBox<T>(val first: T, val second: T)

C. class PairBox { val first: T; val second: T }

D. class PairBox(val first: Any, val second: Any)

Solution

1. Step 1: Understand requirement for two different types

   The class should accept two generic types, so it needs two type parameters, e.g., T and U.

2. Step 2: Check each option

   class PairBox(val first: T, val second: U) correctly declares two generic types and constructor parameters. class PairBox<T>(val first: T, val second: T) uses one type for both values, not allowing different types. class PairBox { val first: T; val second: T } has wrong property types (second is T, should be U). class PairBox(val first: Any, val second: Any) uses Any which is not generic.

3. Final Answer:

   class PairBox<T, U>(val first: T, val second: U) -> Option A

4. Quick Check:

   Two generics for two types [OK]

Hint: Use two type parameters for different types [OK]

Common Mistakes:

• Using one generic type for both values
• Confusing property types in class body
• Using Any instead of generics