Kotlin hashSetOf Function | Create HashSet in Kotlin

The hashSetOf function in Kotlin is used to create a mutable HashSet of elements. This function belongs to the Kotlin standard library and provides a straightforward way to create hash sets that can be modified after their creation.

Table of Contents

1. Introduction
2. hashSetOf Function Syntax
3. Examples
   • Basic Usage
   • Adding and Removing Elements
   • Checking for Element Presence
4. Real-World Use Case
5. Conclusion

Introduction

The hashSetOf function allows you to create a mutable HashSet containing specified elements. A HashSet is a collection that does not allow duplicate elements and uses hash-based storage for fast lookups and modifications.

The hashSetOf function creates a HashSet that can be modified after its creation. This allows you to perform operations such as adding, removing, and checking for elements in the set, making it suitable for dynamic collections of unique items.

hashSetOf Function Syntax

The syntax for the hashSetOf function is as follows:

fun <T> hashSetOf(vararg elements: T): HashSet<T>

Parameters:

• elements: A variable number of elements to be included in the set.

Returns:

• A mutable HashSet containing the specified elements.

Examples

Basic Usage

To demonstrate the basic usage of hashSetOf, we will create a mutable HashSet of integers.

Example

fun main() {
    val numbers = hashSetOf(1, 2, 3, 4, 5)
    println("HashSet of numbers: $numbers")
}

Output:

HashSet of numbers: [1, 2, 3, 4, 5]

Adding and Removing Elements

This example shows how to add and remove elements in a HashSet.

Example

fun main() {
    val fruits = hashSetOf("Apple", "Banana", "Cherry")
    println("Original set: $fruits")

    fruits.add("Date")
    println("After adding an element: $fruits")

    fruits.remove("Banana")
    println("After removing an element: $fruits")
}

Output:

Original set: [Apple, Banana, Cherry]
After adding an element: [Apple, Banana, Cherry, Date]
After removing an element: [Apple, Cherry, Date]

Checking for Element Presence

This example demonstrates how to check for the presence of an element in a HashSet.

Example

fun main() {
    val animals = hashSetOf("Dog", "Cat", "Horse")

    val isDogPresent = animals.contains("Dog")
    val isElephantPresent = animals.contains("Elephant")

    println("Is Dog present: $isDogPresent")
    println("Is Elephant present: $isElephantPresent")
}

Output:

Is Dog present: true
Is Elephant present: false

Real-World Use Case

Managing a Dynamic Set of Users

In real-world applications, the hashSetOf function can be used to manage a dynamic set of users, such as tracking active users in a system.

Example

fun main() {
    val activeUsers = hashSetOf("Alice", "Bob", "Charlie")
    println("Active users: $activeUsers")

    activeUsers.add("Dave")
    println("After adding a user: $activeUsers")

    activeUsers.remove("Charlie")
    println("After removing a user: $activeUsers")
}

Output:

Active users: [Alice, Bob, Charlie]
After adding a user: [Alice, Bob, Charlie, Dave]
After removing a user: [Alice, Bob, Dave]

Conclusion

The hashSetOf function in Kotlin is a powerful and convenient way to create mutable HashSets. It allows you to define a collection of unique elements that can be dynamically updated, making it suitable for various applications, including managing dynamic data collections.