Kotlin Data Class

When working with Kotlin development, Kotlin data class represents one of the most powerful features for creating clean, efficient code. A Kotlin data class automatically generates essential methods like toString(), equals(), hashCode(), and copy(), making it perfect for holding data structures in your applications. Whether you’re building Android apps or backend services, understanding Kotlin data class fundamentals will significantly improve your code quality and reduce boilerplate.

What is a Kotlin Data Class?

A Kotlin data class is a special type of class designed primarily to hold data. Unlike regular classes, a Kotlin data class automatically provides implementations for common object methods, eliminating the need to write repetitive boilerplate code. The Kotlin data class is declared using the data keyword before the class declaration.

Basic Kotlin Data Class Syntax

data class Student(val name: String, val age: Int, val grade: Double)

In this Kotlin data class example, the compiler automatically generates:

• toString() method for readable string representation
• equals() and hashCode() methods for object comparison
• copy() method for creating modified copies
• componentN() functions for destructuring declarations

Kotlin Data Class Requirements

To create a valid Kotlin data class, you must follow these essential requirements:

Primary Constructor Parameters

The Kotlin data class primary constructor must have at least one parameter. All parameters must be marked as val (read-only) or var (mutable):

// Valid Kotlin data class
data class Product(val id: Long, var name: String, val price: Double)

// Invalid - no parameters
// data class Empty() // Compilation error

Class Modifiers Restrictions

A Kotlin data class cannot be:

• abstract
• open
• sealed
• inner

// Valid Kotlin data class
data class BookInfo(val title: String, val author: String)

// Invalid examples
// abstract data class AbstractBook() // Error
// open data class OpenBook() // Error

Essential Kotlin Data Class Properties

Automatic toString() Generation

Every Kotlin data class automatically generates a toString() method that displays all primary constructor properties:

data class Vehicle(val brand: String, val model: String, val year: Int)

fun demonstrateToString() {
    val car = Vehicle("Toyota", "Camry", 2023)
    println(car.toString()) // Vehicle(brand=Toyota, model=Camry, year=2023)
}

Automatic equals() and hashCode() Generation

Kotlin data class instances support structural equality comparison through automatically generated equals() and hashCode() methods:

data class Employee(val id: Int, val name: String, val department: String)

fun demonstrateEquality() {
    val emp1 = Employee(101, "Alice Johnson", "Engineering")
    val emp2 = Employee(101, "Alice Johnson", "Engineering")
    val emp3 = Employee(102, "Bob Smith", "Marketing")
    
    println(emp1 == emp2) // true - same content
    println(emp1 == emp3) // false - different content
    println(emp1.hashCode() == emp2.hashCode()) // true
}

Copy Function in Kotlin Data Class

The copy() function allows creating new Kotlin data class instances with modified properties while keeping others unchanged:

data class GameCharacter(val name: String, val level: Int, val health: Int, val mana: Int)

fun demonstrateCopy() {
    val wizard = GameCharacter("Gandalf", 50, 100, 200)
    
    // Create copy with modified level and health
    val leveledWizard = wizard.copy(level = 55, health = 120)
    
    println("Original: $wizard")
    println("Leveled: $leveledWizard")
    
    // Only change one property
    val healedWizard = wizard.copy(health = 150)
    println("Healed: $healedWizard")
}

Destructuring Declarations with Kotlin Data Class

Kotlin data class supports destructuring declarations through automatically generated componentN() functions, allowing you to unpack objects into separate variables:

data class Coordinate(val x: Double, val y: Double, val z: Double)

fun demonstrateDestructuring() {
    val point = Coordinate(10.5, 20.3, 5.7)
    
    // Destructure all components
    val (xPos, yPos, zPos) = point
    println("X: $xPos, Y: $yPos, Z: $zPos")
    
    // Destructure only some components
    val (x, y) = point
    println("2D Position: ($x, $y)")
    
    // Skip components using underscore
    val (_, _, z) = point
    println("Z coordinate only: $z")
}

Destructuring in Function Parameters

Kotlin data class destructuring works seamlessly with function parameters:

data class Rectangle(val width: Double, val height: Double)

fun calculateArea(rect: Rectangle): Double {
    val (w, h) = rect
    return w * h
}

fun calculatePerimeter(rect: Rectangle): Double {
    val (width, height) = rect
    return 2 * (width + height)
}

fun demonstrateParameterDestructuring() {
    val rectangle = Rectangle(15.0, 10.0)
    
    println("Area: ${calculateArea(rectangle)}")
    println("Perimeter: ${calculatePerimeter(rectangle)}")
}

Advanced Kotlin Data Class Features

Data Class with Default Values

Kotlin data class properties can have default values, making object creation more flexible:

data class UserProfile(
    val username: String,
    val email: String,
    val isActive: Boolean = true,
    val score: Int = 0,
    val registrationDate: String = "2025-01-01"
)

fun demonstrateDefaults() {
    // Create with all parameters
    val user1 = UserProfile("alice_dev", "alice@example.com", true, 1500, "2025-01-15")
    
    // Create with some defaults
    val user2 = UserProfile("bob_user", "bob@example.com")
    
    // Create with named parameters
    val user3 = UserProfile(
        username = "charlie_pro", 
        email = "charlie@example.com", 
        score = 2500
    )
    
    println("User1: $user1")
    println("User2: $user2")
    println("User3: $user3")
}

Data Class Inheritance

While Kotlin data class cannot be open, they can extend other classes and implement interfaces:

interface Identifiable {
    val id: String
}

open class BaseEntity(open val createdAt: String)

data class DatabaseRecord(
    override val id: String,
    val data: String,
    override val createdAt: String
) : BaseEntity(createdAt), Identifiable

fun demonstrateInheritance() {
    val record = DatabaseRecord("REC001", "Sample data", "2025-07-07")
    println("Record: $record")
    println("ID: ${record.id}")
    println("Created: ${record.createdAt}")
}

Nested Data Classes

Kotlin data class can contain other data classes as properties:

data class Address(val street: String, val city: String, val zipCode: String)
data class Contact(val phone: String, val email: String)
data class Person(val name: String, val age: Int, val address: Address, val contact: Contact)

fun demonstrateNested() {
    val address = Address("123 Main St", "Springfield", "12345")
    val contact = Contact("+1-555-0123", "john.doe@email.com")
    val person = Person("John Doe", 30, address, contact)
    
    println("Person: $person")
    
    // Access nested properties
    println("City: ${person.address.city}")
    println("Phone: ${person.contact.phone}")
    
    // Copy with modified nested data
    val newAddress = address.copy(street = "456 Oak Ave")
    val movedPerson = person.copy(address = newAddress)
    println("Moved person: $movedPerson")
}

Working with Collections and Kotlin Data Class

Kotlin data class objects work excellently with collections due to their proper equals() and hashCode() implementations:

data class Book(val isbn: String, val title: String, val author: String, val pages: Int)

fun demonstrateCollections() {
    val library = listOf(
        Book("978-1234567890", "Kotlin in Action", "Dmitry Jemerov", 360),
        Book("978-0987654321", "Android Development", "Jane Smith", 450),
        Book("978-1111111111", "Clean Code", "Robert Martin", 464),
        Book("978-2222222222", "Design Patterns", "Gang of Four", 395)
    )
    
    // Filter books by page count
    val thickBooks = library.filter { it.pages > 400 }
    println("Books with more than 400 pages:")
    thickBooks.forEach { println("  ${it.title} - ${it.pages} pages") }
    
    // Group books by author
    val booksByAuthor = library.groupBy { it.author }
    println("\nBooks grouped by author:")
    booksByAuthor.forEach { (author, books) ->
        println("  $author: ${books.map { it.title }}")
    }
    
    // Find specific book
    val searchIsbn = "978-1234567890"
    val foundBook = library.find { it.isbn == searchIsbn }
    println("\nFound book: $foundBook")
}

Map Operations with Kotlin Data Class

data class Student(val id: Int, val name: String, val grade: Double)

fun demonstrateMapOperations() {
    val students = listOf(
        Student(1, "Emma Wilson", 92.5),
        Student(2, "Michael Brown", 88.0),
        Student(3, "Sarah Davis", 95.2),
        Student(4, "James Miller", 87.8)
    )
    
    // Transform to map
    val studentMap = students.associateBy { it.id }
    println("Student map: $studentMap")
    
    // Calculate statistics
    val averageGrade = students.map { it.grade }.average()
    println("Average grade: $averageGrade")
    
    // Find top performer
    val topStudent = students.maxByOrNull { it.grade }
    println("Top student: $topStudent")
    
    // Destructuring in forEach
    students.forEach { (id, name, grade) ->
        println("Student $id: $name scored $grade")
    }
}

Best Practices for Kotlin Data Class

Use Immutable Properties

Prefer val over var in Kotlin data class for thread safety and predictable behavior:

// Recommended: Immutable data class
data class ImmutableOrder(val orderId: String, val amount: Double, val timestamp: Long)

// Use copy() for modifications
fun processOrder(order: ImmutableOrder): ImmutableOrder {
    val processedAmount = order.amount * 1.1 // Add 10% processing fee
    return order.copy(amount = processedAmount)
}

Validate Data in Init Block

Add validation logic using init blocks in Kotlin data class:

data class ValidatedUser(val username: String, val email: String, val age: Int) {
    init {
        require(username.isNotBlank()) { "Username cannot be blank" }
        require(email.contains("@")) { "Invalid email format" }
        require(age >= 0) { "Age cannot be negative" }
    }
}

fun demonstrateValidation() {
    try {
        val validUser = ValidatedUser("alice123", "alice@example.com", 25)
        println("Valid user created: $validUser")
        
        // This will throw an exception
        val invalidUser = ValidatedUser("", "invalid-email", -5)
    } catch (e: IllegalArgumentException) {
        println("Validation error: ${e.message}")
    }
}

Complete Example: Building a Library Management System

Here’s a comprehensive example demonstrating Kotlin data class usage in a real-world scenario:

import java.time.LocalDate
import java.time.format.DateTimeFormatter

// Data classes for library system
data class Author(val id: Int, val name: String, val nationality: String)

data class Book(
    val isbn: String,
    val title: String,
    val authors: List<Author>,
    val publicationYear: Int,
    val genre: String,
    val pageCount: Int,
    val isAvailable: Boolean = true
)

data class Member(
    val memberId: String,
    val name: String,
    val email: String,
    val joinDate: LocalDate,
    val membershipType: String = "REGULAR"
)

data class BorrowRecord(
    val recordId: String,
    val book: Book,
    val member: Member,
    val borrowDate: LocalDate,
    val dueDate: LocalDate,
    val returnDate: LocalDate? = null
) {
    val isOverdue: Boolean
        get() = returnDate == null && LocalDate.now().isAfter(dueDate)
    
    val isReturned: Boolean
        get() = returnDate != null
}

class LibrarySystem {
    private val books = mutableListOf<Book>()
    private val members = mutableListOf<Member>()
    private val borrowRecords = mutableListOf<BorrowRecord>()
    
    fun addBook(book: Book) {
        books.add(book)
        println("Added book: ${book.title}")
    }
    
    fun addMember(member: Member) {
        members.add(member)
        println("Added member: ${member.name}")
    }
    
    fun borrowBook(isbn: String, memberId: String): BorrowRecord? {
        val book = books.find { it.isbn == isbn && it.isAvailable }
        val member = members.find { it.memberId == memberId }
        
        if (book != null && member != null) {
            val borrowDate = LocalDate.now()
            val dueDate = borrowDate.plusWeeks(2)
            val recordId = "BR${System.currentTimeMillis()}"
            
            val borrowRecord = BorrowRecord(recordId, book, member, borrowDate, dueDate)
            borrowRecords.add(borrowRecord)
            
            // Update book availability
            val updatedBook = book.copy(isAvailable = false)
            books.removeIf { it.isbn == isbn }
            books.add(updatedBook)
            
            println("Book borrowed successfully!")
            return borrowRecord
        }
        
        println("Unable to borrow book. Check availability and member ID.")
        return null
    }
    
    fun returnBook(recordId: String): Boolean {
        val record = borrowRecords.find { it.recordId == recordId && !it.isReturned }
        
        if (record != null) {
            val returnDate = LocalDate.now()
            val updatedRecord = record.copy(returnDate = returnDate)
            
            borrowRecords.removeIf { it.recordId == recordId }
            borrowRecords.add(updatedRecord)
            
            // Update book availability
            val book = record.book
            val availableBook = book.copy(isAvailable = true)
            books.removeIf { it.isbn == book.isbn }
            books.add(availableBook)
            
            println("Book returned successfully!")
            return true
        }
        
        println("Invalid record ID or book already returned.")
        return false
    }
    
    fun getOverdueBooks(): List<BorrowRecord> {
        return borrowRecords.filter { it.isOverdue }
    }
    
    fun getMemberBorrowHistory(memberId: String): List<BorrowRecord> {
        return borrowRecords.filter { it.member.memberId == memberId }
    }
    
    fun searchBooksByGenre(genre: String): List<Book> {
        return books.filter { it.genre.equals(genre, ignoreCase = true) }
    }
    
    fun getPopularAuthors(): Map<Author, Int> {
        return borrowRecords
            .flatMap { it.book.authors }
            .groupingBy { it }
            .eachCount()
    }
}

fun main() {
    val library = LibrarySystem()
    
    // Create authors
    val author1 = Author(1, "J.K. Rowling", "British")
    val author2 = Author(2, "George Orwell", "British")
    val author3 = Author(3, "Agatha Christie", "British")
    
    // Create books
    val book1 = Book(
        isbn = "978-0-439-70818-6",
        title = "Harry Potter and the Philosopher's Stone",
        authors = listOf(author1),
        publicationYear = 1997,
        genre = "Fantasy",
        pageCount = 309
    )
    
    val book2 = Book(
        isbn = "978-0-452-28423-4",
        title = "1984",
        authors = listOf(author2),
        publicationYear = 1949,
        genre = "Dystopian Fiction",
        pageCount = 328
    )
    
    val book3 = Book(
        isbn = "978-0-06-207348-4",
        title = "Murder on the Orient Express",
        authors = listOf(author3),
        publicationYear = 1934,
        genre = "Mystery",
        pageCount = 256
    )
    
    // Add books to library
    library.addBook(book1)
    library.addBook(book2)
    library.addBook(book3)
    
    // Create members
    val member1 = Member(
        memberId = "M001",
        name = "Alice Johnson",
        email = "alice.johnson@email.com",
        joinDate = LocalDate.of(2024, 1, 15),
        membershipType = "PREMIUM"
    )
    
    val member2 = Member(
        memberId = "M002",
        name = "Bob Smith",
        email = "bob.smith@email.com",
        joinDate = LocalDate.of(2024, 3, 20)
    )
    
    // Add members to library
    library.addMember(member1)
    library.addMember(member2)
    
    // Demonstrate borrowing
    println("\n--- Borrowing Books ---")
    val borrowRecord1 = library.borrowBook("978-0-439-70818-6", "M001")
    val borrowRecord2 = library.borrowBook("978-0-452-28423-4", "M002")
    
    // Show borrow records using destructuring
    borrowRecord1?.let { (recordId, book, member, borrowDate, dueDate) ->
        println("Record: $recordId")
        println("Book: ${book.title}")
        println("Member: ${member.name}")
        println("Borrowed: $borrowDate, Due: $dueDate")
    }
    
    // Demonstrate searching
    println("\n--- Searching Books ---")
    val fantasyBooks = library.searchBooksByGenre("Fantasy")
    fantasyBooks.forEach { book ->
        val (isbn, title, authors, year, genre, pages) = book
        println("$title by ${authors.map { it.name }.joinToString(", ")} ($year)")
    }
    
    // Demonstrate member history
    println("\n--- Member History ---")
    val aliceHistory = library.getMemberBorrowHistory("M001")
    aliceHistory.forEach { record ->
        println("${record.book.title} - Borrowed: ${record.borrowDate}")
    }
    
    // Return a book
    println("\n--- Returning Books ---")
    borrowRecord1?.let { library.returnBook(it.recordId) }
    
    // Check overdue books
    println("\n--- Overdue Books ---")
    val overdueBooks = library.getOverdueBooks()
    if (overdueBooks.isEmpty()) {
        println("No overdue books!")
    } else {
        overdueBooks.forEach { record ->
            println("${record.book.title} - Due: ${record.dueDate}, Member: ${record.member.name}")
        }
    }
}