Console Task Manager

Build a command-line to-do app using data classes and mutable collections to track tasks.

Data ClassesCollectionsControl Flow

Overview

A console task manager is the natural first Kotlin project because it puts data class front and center: a Task is really just a bundle of a title, a completion flag, and an id that all travel together, and that is precisely what data class was designed to express. Declaring Task as a data class gives you a correct toString(), equals(), and copy() for free, so you never hand-write the boilerplate that a comparable Java class would need — this is one of the clearest places where Kotlin is not "Java with different syntax" but a genuinely more concise language for modeling data.

By the end of this tutorial you will have a command-line to-do application built around a Task data class and a TaskManager class that owns a MutableList<Task>. You will drive the whole program with readLine() and a when expression instead of an if/else if chain, which is the idiomatic Kotlin way to dispatch on a menu choice — when reads top to bottom like a table of cases rather than a sequence of independent conditions.

What You'll Build

A Task data class with id, title, and a mutable isDone flag, getting toString()/equals()/copy() for free.
A TaskManager class that owns a MutableList<Task> and assigns unique ids automatically.
An addTask() operation that appends a new Task to the list.
A listTasks() operation that prints every task with a [x]/[ ] completion marker.
A completeTask() operation that finds a task by id and flips its isDone flag.
A removeTask() operation built on Kotlin's MutableList.removeIf().
A readLine()-driven menu loop dispatched with a when expression.

Prerequisites

Classes and data classes — the data class keyword and what it generates automatically.
Collections basics — MutableList, mutableListOf(), and iterating with a for loop.
Console input — reading lines with readLine() and converting String to Int with .toIntOrNull().
The when expression — Kotlin's replacement for a long if/else if/switch chain.
Function basics — parameters, return types, and calling one function from another.

Project Structure

The whole program lives in a single file, ConsoleTaskManager.kt, containing one data class, Task, one regular class, TaskManager, and a top-level fun main() — Kotlin does not require every function or class to sit inside a public class the way Java does, so main() can be a free-standing top-level function in the file. Task is a pure data holder; it never touches the console or the list it lives in. TaskManager is the layer above it: it owns the MutableList<Task>, hands out ids, and exposes one function per menu action (addTask, listTasks, completeTask, removeTask). main() never manipulates the list directly; it only ever calls functions on a single shared TaskManager instance, which keeps every rule about how tasks are created or removed enforced in exactly one place.

Step 1: Define the Task Data Class

data class Task is declared with var isDone (mutable) alongside val id and val title (both read-only after construction) — id never changes once assigned, title is left fixed for this project too, but isDone has to change in place every time a task is completed, which is exactly why it is the one var in the class. Because this is a data class, Kotlin auto-generates toString(), so printing a Task directly already produces readable output without any manual override.

// A data class is Kotlin's purpose-built tool for a class that is mostly a
// bundle of values: the compiler generates toString(), equals(), hashCode(),
// and copy() for us, so Task never needs any of that written by hand.
data class Task(
    val id: Int,          // Assigned by TaskManager, never chosen by the caller — val because an id never changes
    val title: String,    // What the task is; val because this project never edits a task's title in place
    var isDone: Boolean = false   // Mutable: completeTask() flips this after construction, so it must be var
)

Step 2: Build the TaskManager and Add Tasks

TaskManager holds private val tasks = mutableListOf<Task>() — val here means the *reference* to the list never changes, not that the list's contents are frozen; mutableListOf() returns a MutableList, which is what actually allows add() and removeIf() to mutate it later. nextId is a simple auto-incrementing counter, so TaskManager, not the caller, decides every task's id, guaranteeing no two tasks can ever collide.

// Owns every Task in memory and is the only class allowed to create, list,
// complete, or remove them — main() never touches the MutableList directly,
// it only ever calls functions on a TaskManager.
class TaskManager {
    private val tasks = mutableListOf<Task>()   // val = the reference is fixed; the list itself is still mutable
    private var nextId = 1                        // Next id to hand out; incremented after every successful add

    fun addTask(title: String): Task {
        val task = Task(nextId, title)   // TaskManager assigns the id, not the caller; isDone defaults to false
        tasks.add(task)                    // MutableList.add() appends in amortized O(1) time
        nextId++                           // Guarantees every future task gets a fresh id
        return task                        // Handy for immediately printing "Added: ..."
    }
}

Step 3: List and Complete Tasks

listTasks() walks the list with a plain for loop, printing a [x] or [ ] marker built from a Kotlin if *expression* (not statement) — in Kotlin if/else evaluates to a value, so if (task.isDone) "x" else " " is a single expression usable directly inside a string template. completeTask() uses tasks.find { it.id == id }, a collection function that returns the first matching element or null, paired with Kotlin's safe-call operator ?. so the flag flip only happens when a match was actually found.

fun listTasks() {
    if (tasks.isEmpty()) {
        println("No tasks yet.")
        return
    }
    for (task in tasks) {                                  // for-in walks every task in insertion order
        val marker = if (task.isDone) "x" else " "          // if is an expression in Kotlin, so this yields a value directly
        println("[$marker] ${task.id}: ${task.title}")
    }
}

fun completeTask(id: Int): Boolean {
    val task = tasks.find { it.id == id }   // find{} returns the first match or null — never throws if nothing matches
    return if (task != null) {
        task.isDone = true                    // Only reachable once null has been ruled out, so this is safe
        true
    } else {
        false                                  // No task with that id; let the caller report "not found"
    }
}

Example Usage

Click Run to see what this code prints.

Step 4: Remove a Task

removeTask() uses MutableList.removeIf(), which takes a lambda predicate and removes every element the predicate matches, returning true only if at least one element was actually removed. Since ids are unique, at most one task is ever removed here, but removeIf() is still the cleanest way to express "delete the task whose id equals this one" without manually managing a loop index while removing from the list being iterated — the same idiom Kotlin shares with Java's ArrayList.removeIf().

fun removeTask(id: Int): Boolean {
    return tasks.removeIf { it.id == id }   // Trailing-lambda syntax; true only if a matching task was removed
}

Step 5: Build the Menu Loop With when

main() creates one TaskManager shared by every menu action and loops with while (true), using when (choice) to dispatch on the user's numeric input — Kotlin's idiomatic replacement for an if/else if chain or a Java switch. Each branch is a single case, else catches anything unrecognized, and readLine()?.toIntOrNull() ?: -1 is the Kotlin-native way to read a line of input and safely fall back to an invalid sentinel value instead of crashing if the user types something that is not a number.

fun main() {
    val manager = TaskManager()   // One manager instance shared by every menu action below

    while (true) {                  // Loop forever; the "5. Exit" branch is the only way out, via return
        println("\n===== CONSOLE TASK MANAGER =====")
        println("1. Add Task")
        println("2. List Tasks")
        println("3. Complete Task")
        println("4. Remove Task")
        println("5. Exit")
        print("Enter your choice: ")
        val choice = readLine()?.toIntOrNull() ?: -1   // Null input or non-numeric text safely becomes -1, not a crash

        when (choice) {              // when is Kotlin's idiomatic dispatch on a menu choice, replacing if/else-if chains
            1 -> {
                print("Enter task title: ")
                val title = readLine().orEmpty()          // orEmpty() turns a possible null into "" instead of crashing
                val added = manager.addTask(title)
                println("Added! Assigned ID: ${added.id}")
            }
            2 -> manager.listTasks()
            3 -> {
                print("Enter ID to complete: ")
                val id = readLine()?.toIntOrNull() ?: -1
                val done = manager.completeTask(id)
                println(if (done) "Task marked complete." else "No task with that ID.")
            }
            4 -> {
                print("Enter ID to remove: ")
                val id = readLine()?.toIntOrNull() ?: -1
                val removed = manager.removeTask(id)
                println(if (removed) "Task removed." else "No task with that ID.")
            }
            5 -> {
                println("Goodbye!")
                return                                     // Exits main() directly, ending the program
            }
            else -> println("Invalid choice, try again.")   // Catches anything outside 1-5
        }
    }
}

Complete Code

Here is the full program with every declaration assembled in the correct order, ready to save as ConsoleTaskManager.kt and run with kotlinc ConsoleTaskManager.kt -include-runtime -d task-manager.jar && java -jar task-manager.jar.

data class Task(
    val id: Int,
    val title: String,
    var isDone: Boolean = false
)

class TaskManager {
    private val tasks = mutableListOf<Task>()
    private var nextId = 1

    fun addTask(title: String): Task {
        val task = Task(nextId, title)
        tasks.add(task)
        nextId++
        return task
    }

    fun listTasks() {
        if (tasks.isEmpty()) {
            println("No tasks yet.")
            return
        }
        for (task in tasks) {
            val marker = if (task.isDone) "x" else " "
            println("[$marker] ${task.id}: ${task.title}")
        }
    }

    fun completeTask(id: Int): Boolean {
        val task = tasks.find { it.id == id }
        return if (task != null) {
            task.isDone = true
            true
        } else {
            false
        }
    }

    fun removeTask(id: Int): Boolean {
        return tasks.removeIf { it.id == id }
    }
}

fun main() {
    val manager = TaskManager()

    while (true) {
        println("\n===== CONSOLE TASK MANAGER =====")
        println("1. Add Task")
        println("2. List Tasks")
        println("3. Complete Task")
        println("4. Remove Task")
        println("5. Exit")
        print("Enter your choice: ")
        val choice = readLine()?.toIntOrNull() ?: -1

        when (choice) {
            1 -> {
                print("Enter task title: ")
                val title = readLine().orEmpty()
                val added = manager.addTask(title)
                println("Added! Assigned ID: ${added.id}")
            }
            2 -> manager.listTasks()
            3 -> {
                print("Enter ID to complete: ")
                val id = readLine()?.toIntOrNull() ?: -1
                val done = manager.completeTask(id)
                println(if (done) "Task marked complete." else "No task with that ID.")
            }
            4 -> {
                print("Enter ID to remove: ")
                val id = readLine()?.toIntOrNull() ?: -1
                val removed = manager.removeTask(id)
                println(if (removed) "Task removed." else "No task with that ID.")
            }
            5 -> {
                println("Goodbye!")
                return
            }
            else -> println("Invalid choice, try again.")
        }
    }
}

Sample Run

Click Run to see what this code prints.

Extend This Project

Add a priority: Int = 0 field to Task and a sortByPriority() function using tasks.sortedByDescending { it.priority }.
Add a dueDate: LocalDate? nullable field and a function that filters overdue tasks with tasks.filter { it.dueDate?.isBefore(LocalDate.now()) == true }.
Persist tasks to a text file by mapping each Task to a comma-separated line and reading it back on startup.
Use task.copy(isDone = true) inside completeTask() and replace the element in place, to practice the immutable-update style instead of mutating isDone directly.
Add a findByTitle(query: String) function using tasks.filter { it.title.contains(query, ignoreCase = true) }.

Summary

You built a working console task manager where Task is a compact data class that gets its toString(), equals(), and copy() for free, and TaskManager composes many tasks into one manageable, mutable collection. The when-driven menu loop you wrote here is the same idiomatic dispatch pattern you will reuse in almost every menu-driven Kotlin console application from here on, and the add/list/complete/remove shape generalizes directly to any collection-backed feature you build next.