Java - Developing a console-based a to-do list manager application

 Developing a Console-Based To-Do List Manager Application in Java

This detailed document explains how to build a Java console-based To-Do List Manager Application using concepts like ArrayList, file handling, object-oriented programming, serialization, Scanner input handling, and CRUD operations. A console to-do list manager is one of the most important beginner-friendly Java project topics because it teaches essential skills: class design, input validation, looping constructs, collections, exception handling, and saving/loading data. The following sections provide deeply explained notes, structured code, outputs, and best practices. All explanations are intentionally long and keyword-rich to increase reach for search terms such as “Java to-do list project”, “console-based applications in Java”, “Java CRUD examples”, “Java OOP project for beginners”, and “Java file handling project”.

Introduction to Console-Based To-Do List Applications in Java

A console-based To-Do List Manager in Java is a lightweight application that allows users to add tasks, list tasks, update tasks, and delete tasks directly from the terminal. This project demonstrates foundational Java programming skills, including menu-driven programs, Scanner input handling, ArrayList manipulation, loops, conditions, and exception handling. Unlike GUI applications built using Swing or JavaFX, a console application uses text-based interaction and is extremely suitable for beginners learning problem-solving in Java.

In Java, a console application is executed through the JVM, and input can be received using the Scanner class. A to-do list manager makes the user experience interactive by showing menus, asking for user choices, verifying them, and performing CRUD (Create, Read, Update, Delete) operations on tasks. One of the main goals is to structure tasks using classes and objects, demonstrating object-oriented design. The application can also support persistence by saving tasks in files using serialization, file writing, or JSON. Throughout this document, we highlight best practices, design strategies, modularization, input validation, and project expansion guidelines.

Understanding the Task Class in Java

The Task class is the core component of the to-do list project. It represents a single task item with fields such as id, title, description, and completion status. The Task class helps demonstrate object-oriented programming principles, such as encapsulation and constructors. By creating a model class, we structure the data clearly instead of working with raw strings. This makes the application maintainable, scalable, and easy to extend. Developers may later add due dates, priority levels, creation timestamps, and categories without rewriting other parts of the code.

Java Code for the Task Class

import java.io.Serializable;

public class Task implements Serializable {
    private int id;
    private String title;
    private String description;
    private boolean completed;

    public Task(int id, String title, String description) {
        this.id = id;
        this.title = title;
        this.description = description;
        this.completed = false;
    }

    public int getId() {
        return id;
    }

    public String getTitle() {
        return title;
    }

    public String getDescription() {
        return description;
    }

    public boolean isCompleted() {
        return completed;
    }

    public void markCompleted() {
        this.completed = true;
    }

    public String toString() {
        return id + " | " + title + " | " + description + " | Completed: " + completed;
    }
}

Output of Task Class Example

Task Example:
1 | Buy groceries | Milk, eggs, bread | Completed: false

Creating the TodoManager Class for CRUD Operations

The TodoManager class handles the core logic of managing tasks. It stores tasks inside an ArrayList, which provides dynamic resizing, indexing, and easy traversal. The CRUD operations—Add, Read, Update, Delete—are implemented inside this class. The TodoManager acts as a business logic layer, separating data handling from user interaction. This ensures modularity and clean architecture, following the separation of concerns principle.

The class also demonstrates how to manage IDs, search for tasks efficiently, and perform operations conditionally. This Java component is essential for building console-based applications that manipulate lists of objects. It supports listing tasks, adding new tasks, marking tasks as completed, and removing tasks. Later, file handling can be added to persist data between executions.

Java Code for TodoManager Class

import java.util.ArrayList;

public class TodoManager {
    private ArrayList<Task> tasks;
    private int currentId;

    public TodoManager() {
        tasks = new ArrayList<>();
        currentId = 1;
    }

    public Task addTask(String title, String description) {
        Task t = new Task(currentId, title, description);
        tasks.add(t);
        currentId++;
        return t;
    }

    public ArrayList<Task> getAllTasks() {
        return tasks;
    }

    public boolean markTaskCompleted(int id) {
        for (Task t : tasks) {
            if (t.getId() == id) {
                t.markCompleted();
                return true;
            }
        }
        return false;
    }

    public boolean deleteTask(int id) {
        return tasks.removeIf(t -> t.getId() == id);
    }
}

Output of TodoManager Basic Operations

Adding tasks...
Task added: 1 | Study Java | OOP concepts | Completed: false
Task added: 2 | Clean room | Organize desk | Completed: false

Listing tasks...
1 | Study Java | OOP concepts | Completed: false
2 | Clean room | Organize desk | Completed: false

Marking task 1 as completed...
Success

Deleting task 2...
Deleted Successfully

Building the Console-Based Menu System

The console menu is the core interactive part of the application. It displays options and reads user choices. The menu uses loops, specifically a while loop, to keep the program running until the user decides to exit. Scanner is used for input, and switch-case or if-else conditions are used to execute specific operations. A well-designed menu is user-friendly and guides the user step-by-step through available actions.

Menu-driven applications are extremely common in Java programming assignments, examinations, interviews, and projects. They strengthen logical thinking and help learners understand flow control structures. The following example shows how to build a simple but functional menu for the to-do list manager. The menu supports adding tasks, listing tasks, marking tasks completed, deleting tasks, and exiting.

Java Code: Main Class with Menu

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        TodoManager manager = new TodoManager();
        int choice;

        while (true) {
            System.out.println("\\n===== TO-DO LIST MANAGER =====");
            System.out.println("1. Add Task");
            System.out.println("2. View All Tasks");
            System.out.println("3. Mark Task as Completed");
            System.out.println("4. Delete Task");
            System.out.println("5. Exit");
            System.out.print("Enter choice: ");

            choice = Integer.parseInt(sc.nextLine());

            switch (choice) {
                case 1:
                    System.out.print("Enter title: ");
                    String title = sc.nextLine();
                    System.out.print("Enter description: ");
                    String description = sc.nextLine();
                    Task t = manager.addTask(title, description);
                    System.out.println("Task added: " + t);
                    break;

                case 2:
                    System.out.println("\\nAll Tasks:");
                    for (Task task : manager.getAllTasks()) {
                        System.out.println(task);
                    }
                    break;

                case 3:
                    System.out.print("Enter task ID: ");
                    int id1 = Integer.parseInt(sc.nextLine());
                    if (manager.markTaskCompleted(id1))
                        System.out.println("Task marked completed.");
                    else
                        System.out.println("Task not found.");
                    break;

                case 4:
                    System.out.print("Enter task ID: ");
                    int id2 = Integer.parseInt(sc.nextLine());
                    if (manager.deleteTask(id2))
                        System.out.println("Task deleted.");
                    else
                        System.out.println("Task not found.");
                    break;

                case 5:
                    System.out.println("Exiting...");
                    return;

                default:
                    System.out.println("Invalid choice. Try again.");
            }
        }
    }
}

Output of the Menu-Driven Application

===== TO-DO LIST MANAGER =====
1. Add Task
2. View All Tasks
3. Mark Task as Completed
4. Delete Task
5. Exit
Enter choice: 1
Enter title: Finish Assignment
Enter description: Complete the Java project
Task added: 1 | Finish Assignment | Complete the Java project | Completed: false

Enter choice: 2
1 | Finish Assignment | Complete the Java project | Completed: false

Enter choice: 3
Enter task ID: 1
Task marked completed.

Enter choice: 4
Enter task ID: 1
Task deleted.

Enter choice: 5
Exiting...

File Handling and Saving Tasks in Java

File handling allows the to-do list to persist after the program closes. Without persistence, all tasks would be lost after the application exits. Java offers multiple ways to save data: text files, CSV, object serialization, and JSON. Serialization is one of the fastest ways because it allows saving entire objects in a single line without manually formatting the data. The following code demonstrates how to add save and load functionalities using ObjectOutputStream and ObjectInputStream.

Java Code: File Persistence for To-Do List

import java.io.*;
import java.util.ArrayList;

public class Storage {

    public static void save(ArrayList<Task> tasks) {
        try {
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("tasks.dat"));
            oos.writeObject(tasks);
            oos.close();
            System.out.println("Tasks saved successfully.");
        } catch (Exception e) {
            System.out.println("Error saving tasks: " + e.getMessage());
        }
    }

    @SuppressWarnings("unchecked")
    public static ArrayList<Task> load() {
        try {
            File f = new File("tasks.dat");
            if (!f.exists()) return new ArrayList<>();

            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("tasks.dat"));
            ArrayList<Task> tasks = (ArrayList<Task>) ois.readObject();
            ois.close();
            System.out.println("Tasks loaded successfully.");
            return tasks;
        } catch (Exception e) {
            System.out.println("Error loading tasks: " + e.getMessage());
            return new ArrayList<>();
        }
    }
}

Output of Saving and Loading Tasks

Tasks saved successfully.
Tasks loaded successfully.
Loaded 3 tasks.

 Developing a Console-Based To-Do List Manager

Developing this application strengthens skills in Java logic structuring, OOP design, collections, loops, conditions, and exception handling. It also provides real-world experience in managing data through CRUD operations. Students preparing for interviews or examinations benefit from working on such practical Java projects. The structure introduced here helps in transitioning toward GUI applications and later web applications.

The console-based To-Do List Manager is an excellent beginner-friendly Java project that covers essential topics such as object-oriented programming, ArrayList operations, menu-driven control flow, file handling, and modular class design. By following this guide, learners can build their own functional Java project and later expand it with GUI tools, JSON storage, sorting, filtering, or database connectivity. This document has provided detailed explanations, structured code, and clear outputs to ensure complete understanding and practical application.