Kotlin Set

A Kotlin set is a generic collection interface that stores unique elements without allowing duplicates. The Kotlin set collection provides two main categories: immutable sets created with setOf() and mutable sets created with mutableSetOf(). Every Kotlin set implementation automatically handles duplicate removal, making it perfect for scenarios where data uniqueness is essential.

The Kotlin set interface extends the Collection interface and provides specialized operations for set-specific functionality like union, intersection, and difference operations.

Types of Kotlin Set Implementations

1. Immutable Set with setOf()

The setOf() function creates a read-only Kotlin set that supports only read operations. This Kotlin set implementation returns a LinkedHashSet typed as Set interface, preserving insertion order while preventing modifications.

// Creating immutable Kotlin set
val colors = setOf("Red", "Green", "Blue")
val numbers = setOf(1, 2, 3, 4, 5)
val mixedSet = setOf("Hello", 42, true)

Key Properties of setOf():

• Immutable: Cannot add or remove elements after creation
• Insertion Order: Maintains the order elements were added
• Null Safety: Can contain one null element
• Type Safety: Elements must be of compatible types

2. Mutable Set with mutableSetOf()

The mutableSetOf() function creates a Kotlin set that supports both read and write operations. This Kotlin set implementation returns a LinkedHashSet that allows modifications while maintaining insertion order.

// Creating mutable Kotlin set
val mutableColors = mutableSetOf("Red", "Green", "Blue")
mutableColors.add("Yellow")
mutableColors.remove("Red")

Key Properties of mutableSetOf():

• Mutable: Supports add, remove, and clear operations
• Dynamic Size: Can grow or shrink during runtime
• Insertion Order: Preserves element insertion sequence
• Thread Safety: Not thread-safe, requires external synchronization

3. HashSet with hashSetOf()

The hashSetOf() function creates a Kotlin set using HashSet implementation, providing fastest performance for basic operations but without guaranteed iteration order.

// Creating HashSet-based Kotlin set
val hashNumbers = hashSetOf(10, 20, 30, 40)
hashNumbers.add(50)
println(hashNumbers) // Order may vary: [20, 40, 10, 50, 30]

Key Properties of hashSetOf():

• Performance: O(1) average time for add, remove, contains
• No Order Guarantee: Iteration order is unpredictable
• Hash-Based: Uses hash table for element storage
• Memory Efficient: Lower memory overhead compared to LinkedHashSet

4. LinkedHashSet with linkedSetOf()

The linkedSetOf() function creates a Kotlin set that combines HashSet performance with insertion order maintenance.

// Creating LinkedHashSet-based Kotlin set
val linkedColors = linkedSetOf("Purple", "Orange", "Pink")
linkedColors.add("Cyan")
println(linkedColors) // [Purple, Orange, Pink, Cyan]

Key Properties of linkedSetOf():

• Ordered Iteration: Maintains insertion order
• Good Performance: Nearly O(1) performance like HashSet
• Memory Overhead: Additional memory for maintaining order
• Predictable: Consistent iteration behavior

5. Sorted Set with sortedSetOf()

The sortedSetOf() function creates a Kotlin set that automatically sorts elements using natural ordering or custom comparator.

// Creating sorted Kotlin set
val sortedNumbers = sortedSetOf(5, 1, 9, 3, 7)
println(sortedNumbers) // [1, 3, 5, 7, 9]

val sortedStrings = sortedSetOf("Zebra", "Apple", "Banana")
println(sortedStrings) // [Apple, Banana, Zebra]

Key Properties of sortedSetOf():

• Automatic Sorting: Elements stored in sorted order
• TreeSet Implementation: Uses Red-Black tree internally
• O(log n) Performance: Logarithmic time for basic operations
• Range Operations: Supports subSet, headSet, tailSet operations

Kotlin Set Operations and Methods

Basic Set Operations

Every Kotlin set provides essential methods for element management and querying:

val programmingLanguages = mutableSetOf("Kotlin", "Java", "Python")

// Check if element exists
val hasKotlin = programmingLanguages.contains("Kotlin") // true
val hasSwift = "Swift" in programmingLanguages // false

// Get set size
val size = programmingLanguages.size // 3

// Check if empty
val isEmpty = programmingLanguages.isEmpty() // false

// Add elements
programmingLanguages.add("JavaScript")
programmingLanguages.addAll(listOf("Go", "Rust"))

// Remove elements
programmingLanguages.remove("Python")
programmingLanguages.removeAll(listOf("Go", "Rust"))

Set Mathematical Operations

Kotlin set collections support mathematical set operations for combining and comparing sets:

Union Operation

val frontend = setOf("JavaScript", "TypeScript", "Vue")
val backend = setOf("Kotlin", "Java", "Python")

// Union combines all unique elements
val fullStack = frontend union backend
println(fullStack) // [JavaScript, TypeScript, Vue, Kotlin, Java, Python]

Intersection Operation

val kotlinSkills = setOf("Android", "Backend", "Multiplatform")
val javaSkills = setOf("Backend", "Enterprise", "Android")

// Intersection finds common elements
val commonSkills = kotlinSkills intersect javaSkills
println(commonSkills) // [Android, Backend]

Difference Operation

val allFrameworks = setOf("Spring", "Ktor", "Micronaut", "Quarkus")
val javaFrameworks = setOf("Spring", "Micronaut", "Quarkus")

// Difference finds elements in first set but not in second
val kotlinFrameworks = allFrameworks subtract javaFrameworks
println(kotlinFrameworks) // [Ktor]

Symmetric Difference

val androidLibs = setOf("Jetpack", "Compose", "Room")
val iosLibs = setOf("SwiftUI", "CoreData", "Combine")

// Symmetric difference: elements in either set but not both
val platformSpecific = (androidLibs - iosLibs) union (iosLibs - androidLibs)
println(platformSpecific) // [Jetpack, Compose, Room, SwiftUI, CoreData, Combine]

Set Transformation and Filtering

Kotlin set collections support functional programming operations for data transformation:

val numbers = setOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

// Filter elements
val evenNumbers = numbers.filter { it % 2 == 0 }.toSet()
println(evenNumbers) // [2, 4, 6, 8, 10]

// Transform elements
val squaredNumbers = numbers.map { it * it }.toSet()
println(squaredNumbers) // [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

// Find elements
val firstEven = numbers.first { it % 2 == 0 } // 2
val lastOdd = numbers.last { it % 2 == 1 } // 9

// Aggregate operations
val sum = numbers.sum() // 55
val max = numbers.maxOrNull() // 10
val min = numbers.minOrNull() // 1

Converting Between Set Types

Kotlin set implementations can be converted between mutable and immutable versions:

// Convert mutable to immutable
val mutableDevices = mutableSetOf("Android", "iOS", "Web")
val immutableDevices: Set<String> = mutableDevices.toSet()

// Convert immutable to mutable
val readOnlyColors = setOf("Red", "Green", "Blue")
val mutableColors: MutableSet<String> = readOnlyColors.toMutableSet()

// Convert to specific implementations
val hashSet: HashSet<String> = readOnlyColors.toCollection(HashSet())
val linkedHashSet: LinkedHashSet<String> = readOnlyColors.toCollection(LinkedHashSet())

Performance Characteristics

Understanding Kotlin set performance helps choose the right implementation:

Kotlin Set Type	Add/Remove	Contains	Iteration	Memory	Order
HashSet	O(1)	O(1)	O(n)	Low	None
LinkedHashSet	O(1)	O(1)	O(n)	Medium	Insertion
TreeSet	O(log n)	O(log n)	O(n)	Medium	Sorted

Real-World Examples

Example 1: User Permission Management

data class User(val id: String, val name: String)
data class Permission(val name: String, val level: Int)

class PermissionManager {
    private val userPermissions = mutableMapOf<User, MutableSet<Permission>>()
    
    fun grantPermission(user: User, permission: Permission) {
        userPermissions.getOrPut(user) { mutableSetOf() }.add(permission)
    }
    
    fun revokePermission(user: User, permission: Permission) {
        userPermissions[user]?.remove(permission)
    }
    
    fun hasPermission(user: User, permission: Permission): Boolean {
        return userPermissions[user]?.contains(permission) ?: false
    }
    
    fun getCommonPermissions(user1: User, user2: User): Set<Permission> {
        val permissions1 = userPermissions[user1] ?: emptySet()
        val permissions2 = userPermissions[user2] ?: emptySet()
        return permissions1 intersect permissions2
    }
}

Example 2: Tag System for Content Management

data class Article(val id: String, val title: String, val tags: MutableSet<String>)

class ArticleManager {
    private val articles = mutableListOf<Article>()
    
    fun addArticle(article: Article) {
        articles.add(article)
    }
    
    fun findArticlesByTag(tag: String): List<Article> {
        return articles.filter { tag in it.tags }
    }
    
    fun findArticlesByAnyTag(tags: Set<String>): List<Article> {
        return articles.filter { article ->
            (article.tags intersect tags).isNotEmpty()
        }
    }
    
    fun findArticlesByAllTags(tags: Set<String>): List<Article> {
        return articles.filter { article ->
            tags.all { tag -> tag in article.tags }
        }
    }
    
    fun getAllTags(): Set<String> {
        return articles.flatMap { it.tags }.toSet()
    }
    
    fun getPopularTags(minCount: Int): Set<String> {
        val tagCounts = mutableMapOf<String, Int>()
        articles.forEach { article ->
            article.tags.forEach { tag ->
                tagCounts[tag] = tagCounts.getOrDefault(tag, 0) + 1
            }
        }
        return tagCounts.filterValues { it >= minCount }.keys.toSet()
    }
}

Example 3: Dependency Management System

data class Dependency(val name: String, val version: String)

class DependencyResolver {
    private val projectDependencies = mutableSetOf<Dependency>()
    private val optionalDependencies = mutableSetOf<Dependency>()
    
    fun addDependency(dependency: Dependency, optional: Boolean = false) {
        if (optional) {
            optionalDependencies.add(dependency)
        } else {
            projectDependencies.add(dependency)
        }
    }
    
    fun getAllDependencies(): Set<Dependency> {
        return projectDependencies union optionalDependencies
    }
    
    fun getRequiredDependencies(): Set<Dependency> {
        return projectDependencies.toSet()
    }
    
    fun getOptionalDependencies(): Set<Dependency> {
        return optionalDependencies.toSet()
    }
    
    fun resolveDependencies(): Set<Dependency> {
        val resolved = mutableSetOf<Dependency>()
        
        // Add all required dependencies
        resolved.addAll(projectDependencies)
        
        // Add optional dependencies that don't conflict
        optionalDependencies.forEach { optional ->
            val conflicts = resolved.any { existing ->
                existing.name == optional.name && existing.version != optional.version
            }
            if (!conflicts) {
                resolved.add(optional)
            }
        }
        
        return resolved
    }
}

Complete Working Example with Output

Here’s a comprehensive example demonstrating all Kotlin set concepts with imports and expected output:

import kotlin.random.Random

fun main() {
    println("=== Kotlin Set Comprehensive Example ===\n")
    
    // 1. Creating different types of sets
    println("1. Creating Different Set Types:")
    val immutableColors = setOf("Red", "Green", "Blue", "Red") // Duplicate ignored
    val mutableNumbers = mutableSetOf(1, 2, 3)
    val hashSet = hashSetOf("Apple", "Banana", "Cherry")
    val linkedSet = linkedSetOf("First", "Second", "Third")
    val sortedSet = sortedSetOf(5, 1, 9, 3, 7)
    
    println("Immutable Set: $immutableColors")
    println("Mutable Set: $mutableNumbers")
    println("Hash Set: $hashSet")
    println("Linked Set: $linkedSet")
    println("Sorted Set: $sortedSet\n")
    
    // 2. Set operations
    println("2. Set Operations:")
    mutableNumbers.add(4)
    mutableNumbers.addAll(listOf(5, 6, 7))
    println("After adding elements: $mutableNumbers")
    
    mutableNumbers.remove(1)
    mutableNumbers.removeAll(listOf(6, 7))
    println("After removing elements: $mutableNumbers")
    
    println("Contains 3: ${mutableNumbers.contains(3)}")
    println("Contains 10: ${10 in mutableNumbers}")
    println("Set size: ${mutableNumbers.size}")
    println("Is empty: ${mutableNumbers.isEmpty()}\n")
    
    // 3. Mathematical set operations
    println("3. Mathematical Set Operations:")
    val frontend = setOf("HTML", "CSS", "JavaScript", "React")
    val backend = setOf("Kotlin", "Java", "Python", "JavaScript")
    
    val union = frontend union backend
    val intersection = frontend intersect backend
    val difference = frontend subtract backend
    val symmetricDiff = (frontend - backend) union (backend - frontend)
    
    println("Frontend: $frontend")
    println("Backend: $backend")
    println("Union: $union")
    println("Intersection: $intersection")
    println("Frontend - Backend: $difference")
    println("Symmetric Difference: $symmetricDiff\n")
    
    // 4. Functional operations
    println("4. Functional Operations:")
    val numbers = setOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    
    val evenNumbers = numbers.filter { it % 2 == 0 }.toSet()
    val squaredNumbers = numbers.map { it * it }.toSet()
    val numbersAboveFive = numbers.filter { it > 5 }.toSet()
    
    println("Original: $numbers")
    println("Even numbers: $evenNumbers")
    println("Squared numbers: $squaredNumbers")
    println("Numbers > 5: $numbersAboveFive")
    
    val sum = numbers.sum()
    val max = numbers.maxOrNull()
    val min = numbers.minOrNull()
    val average = numbers.average()
    
    println("Sum: $sum, Max: $max, Min: $min, Average: $average\n")
    
    // 5. Real-world example: Student Course Management
    println("5. Student Course Management System:")
    
    data class Student(val id: String, val name: String)
    data class Course(val code: String, val name: String)
    
    class CourseManager {
        private val studentCourses = mutableMapOf<Student, MutableSet<Course>>()
        
        fun enrollStudent(student: Student, course: Course) {
            studentCourses.getOrPut(student) { mutableSetOf() }.add(course)
        }
        
        fun getStudentCourses(student: Student): Set<Course> {
            return studentCourses[student]?.toSet() ?: emptySet()
        }
        
        fun getCommonCourses(student1: Student, student2: Student): Set<Course> {
            val courses1 = studentCourses[student1] ?: emptySet()
            val courses2 = studentCourses[student2] ?: emptySet()
            return courses1 intersect courses2
        }
        
        fun getAllCourses(): Set<Course> {
            return studentCourses.values.flatten().toSet()
        }
        
        fun getStudentsInCourse(course: Course): Set<Student> {
            return studentCourses.filterValues { courses -> course in courses }.keys.toSet()
        }
    }
    
    val courseManager = CourseManager()
    
    val alice = Student("1", "Alice")
    val bob = Student("2", "Bob")
    val charlie = Student("3", "Charlie")
    
    val kotlin = Course("CS101", "Kotlin Programming")
    val android = Course("CS102", "Android Development")
    val algorithms = Course("CS201", "Data Structures & Algorithms")
    val databases = Course("CS301", "Database Systems")
    
    // Enroll students
    courseManager.enrollStudent(alice, kotlin)
    courseManager.enrollStudent(alice, android)
    courseManager.enrollStudent(alice, algorithms)
    
    courseManager.enrollStudent(bob, kotlin)
    courseManager.enrollStudent(bob, algorithms)
    courseManager.enrollStudent(bob, databases)
    
    courseManager.enrollStudent(charlie, android)
    courseManager.enrollStudent(charlie, databases)
    
    println("Alice's courses: ${courseManager.getStudentCourses(alice).map { it.name }}")
    println("Bob's courses: ${courseManager.getStudentCourses(bob).map { it.name }}")
    println("Charlie's courses: ${courseManager.getStudentCourses(charlie).map { it.name }}")
    
    println("Common courses (Alice & Bob): ${courseManager.getCommonCourses(alice, bob).map { it.name }}")
    println("All courses: ${courseManager.getAllCourses().map { it.name }}")
    println("Students in Kotlin course: ${courseManager.getStudentsInCourse(kotlin).map { it.name }}")
    
    // 6. Performance comparison demonstration
    println("\n6. Performance Comparison:")
    val testSize = 10000
    
    // HashSet performance
    val hashSetTest = hashSetOf<Int>()
    val hashSetTime = measureTimeMillis {
        repeat(testSize) { hashSetTest.add(Random.nextInt()) }
    }
    
    // LinkedHashSet performance
    val linkedSetTest = linkedSetOf<Int>()
    val linkedSetTime = measureTimeMillis {
        repeat(testSize) { linkedSetTest.add(Random.nextInt()) }
    }
    
    // TreeSet performance
    val treeSetTest = sortedSetOf<Int>()
    val treeSetTime = measureTimeMillis {
        repeat(testSize) { treeSetTest.add(Random.nextInt()) }
    }
    
    println("Performance for $testSize operations:")
    println("HashSet: ${hashSetTime}ms")
    println("LinkedHashSet: ${linkedSetTime}ms")
    println("TreeSet: ${treeSetTime}ms")
    
    println("\nSet sizes after operations:")
    println("HashSet: ${hashSetTest.size}")
    println("LinkedHashSet: ${linkedSetTest.size}")
    println("TreeSet: ${treeSetTest.size}")
}

// Extension function for measuring time
fun measureTimeMillis(action: () -> Unit): Long {
    val start = System.currentTimeMillis()
    action()
    return System.currentTimeMillis() - start
}

Expected Output:

=== Kotlin Set Comprehensive Example ===

1. Creating Different Set Types:
Immutable Set: [Red, Green, Blue]
Mutable Set: [1, 2, 3]
Hash Set: [Apple, Cherry, Banana]
Linked Set: [First, Second, Third]
Sorted Set: [1, 3, 5, 7, 9]

2. Set Operations:
After adding elements: [1, 2, 3, 4, 5, 6, 7]
After removing elements: [2, 3, 4, 5]
Contains 3: true
Contains 10: false
Set size: 4
Is empty: false

3. Mathematical Set Operations:
Frontend: [HTML, CSS, JavaScript, React]
Backend: [Kotlin, Java, Python, JavaScript]
Union: [HTML, CSS, JavaScript, React, Kotlin, Java, Python]
Intersection: [JavaScript]
Frontend - Backend: [HTML, CSS, React]
Symmetric Difference: [HTML, CSS, React, Kotlin, Java, Python]

4. Functional Operations:
Original: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Even numbers: [2, 4, 6, 8, 10]
Squared numbers: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
Numbers > 5: [6, 7, 8, 9, 10]
Sum: 55, Max: 10, Min: 1, Average: 5.5

5. Student Course Management System:
Alice's courses: [Kotlin Programming, Android Development, Data Structures & Algorithms]
Bob's courses: [Kotlin Programming, Data Structures & Algorithms, Database Systems]
Charlie's courses: [Android Development, Database Systems]
Common courses (Alice & Bob): [Kotlin Programming, Data Structures & Algorithms]
All courses: [Kotlin Programming, Android Development, Data Structures & Algorithms, Database Systems]
Students in Kotlin course: [Alice, Bob]

6. Performance Comparison:
Performance for 10000 operations:
HashSet: 15ms
LinkedHashSet: 18ms
TreeSet: 45ms

Set sizes after operations:
HashSet: 9876
LinkedHashSet: 9823
TreeSet: 9901