Student Management System

Build a console app to add, update, search, and delete student records using classes and collections.

ClassesObjectsCollections

Overview

A student management system is the classic first project for seeing why Java bundles data and behavior together in a class instead of scattering related values across separate arrays. A Student is not just an id, a name, a course, and a GPA sitting next to each other in memory — it is one coherent object that should be created, read, and changed as a single unit. That is exactly what a Java class gives you: private fields that hold a student's data, and public methods that are the only sanctioned way to read or change it.

By the end of this tutorial you will have a console application built around two classes: Student, which models one record, and StudentManager, which owns an ArrayList<Student> and provides add, search, update, and delete operations over it. You will see why Java programmers reach for List<Student> typed to the ArrayList implementation almost by default — it grows automatically as students are added, and its removeIf, enhanced-for, and index-based methods cover everything a menu-driven console app like this one needs without any manual array resizing.

What You'll Build

A Student class with private id, name, course, and gpa fields plus getters/setters.
A StudentManager class that owns an ArrayList<Student> and assigns unique ids automatically.
A linear findById() search reused by the update and delete operations.
An updateStudent() method that safely edits an existing record found by id.
A deleteStudent() method built on ArrayList.removeIf().
A Scanner-based menu loop tying every operation together into one running program.

Prerequisites

Classes and objects — defining a class with private fields, a constructor, and public methods.
Collections basics — java.util.ArrayList and the List interface, plus the enhanced for loop.
Console input — reading lines and numbers with java.util.Scanner.
Method basics — parameters, return types, and calling one method from another.
The this keyword — disambiguating a field name from a constructor or setter parameter of the same name.

Project Structure

The whole program lives in a single file, StudentManagementSystem.java, containing three top-level types: Student, StudentManager, and the public class StudentManagementSystem that holds main(). Student is a pure data-and-behavior class — it never touches the console or the collection it lives in. StudentManager is the layer above it: it owns the ArrayList<Student>, hands out ids, and exposes one method per menu action (addStudent, findById, updateStudent, deleteStudent, getAll). main() never manipulates the list directly; it only ever calls methods on a single shared StudentManager instance, which keeps every rule about how students are created or removed enforced in exactly one place.

Only one Java source file may declare a public top-level class per file, and it must match the filename — that is why Student and StudentManager below are declared without the public modifier (giving them default, package-private visibility), while StudentManagementSystem, the one containing main(), is the public class that matches the file name.

Step 1: Define the Student Class

Every field starts private, which is what makes this a proper encapsulated class rather than a loose bag of public variables — code outside Student can only reach these fields through the getters and setters defined here. The constructor uses this.field = parameter throughout, since the parameter names deliberately shadow the field names for readability; this.id always refers to the field, plain id always refers to the parameter.

// Represents one student record. Fields are private so a Student can only be
// created or modified through the constructor, setters, and StudentManager
// below — never by reaching directly into its data from outside the class.
class Student {
    private int id;            // Assigned by StudentManager, never chosen by the caller
    private String name;       // Student's full name
    private String course;     // Course or major the student is enrolled in
    private double gpa;        // Grade point average; a double so partial grades like 3.75 are representable

    public Student(int id, String name, String course, double gpa) {
        this.id = id;              // "this." picks the field over the same-named constructor parameter
        this.name = name;
        this.course = course;
        this.gpa = gpa;
    }

    public int getId() {                     // No setId(): an id is assigned once and never changes afterward
        return id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {       // Setters exist only for the fields update() is allowed to change
        this.name = name;
    }

    public String getCourse() {
        return course;
    }

    public void setCourse(String course) {
        this.course = course;
    }

    public double getGpa() {
        return gpa;
    }

    public void setGpa(double gpa) {
        this.gpa = gpa;
    }

    @Override
    public String toString() {                // Overriding toString() means println(student) prints something useful
        return String.format("ID: %-4d | Name: %-20s | Course: %-15s | GPA: %.2f", id, name, course, gpa);
    }
}

Step 2: Build the StudentManager and Add Students

StudentManager is where the collection actually lives. It is declared as List<Student> but instantiated as new ArrayList<>() — programming to the List interface rather than the concrete ArrayList type is a Java convention that keeps the field's declared type flexible if the backing implementation ever needs to change. nextId is a simple auto-incrementing counter, so StudentManager, not the caller, decides every student's id, guaranteeing no two records can ever collide.

import java.util.ArrayList;   // Concrete, growable list implementation used to back the students collection
import java.util.List;        // Programming against the List interface, not ArrayList directly, is the Java idiom

// Owns every Student record in memory and is the only class allowed to
// create, search, update, or remove them — main() never touches the
// ArrayList directly, it only ever calls methods on a StudentManager.
class StudentManager {
    private List<Student> students = new ArrayList<>();   // Grows automatically as students are added; no manual resizing
    private int nextId = 1;                                 // Next id to hand out; incremented after every successful add

    public Student addStudent(String name, String course, double gpa) {
        Student student = new Student(nextId, name, course, gpa);   // The manager assigns the id, not the caller
        students.add(student);                                        // ArrayList.add() appends in amortized O(1) time
        nextId++;                                                     // Guarantees every future student gets a fresh id
        return student;                                               // Handy for immediately printing "Added: ..."
    }
}

Step 3: List and Search Students

getAll() exposes the collection for listing, and findById() is a plain linear scan using an enhanced for loop — with a class list realistically holding dozens to a few hundred students, a linear search is more than fast enough, and it keeps the code readable. findById() is written once here and reused by both updateStudent() and deleteStudent() in the next two steps, instead of duplicating the same lookup logic three times.

public List<Student> getAll() {
    return students;   // Safe to return the live list here since StudentManager is the only class that mutates it
}

public Student findById(int id) {
    for (Student s : students) {      // Enhanced for-loop walks every student in insertion order
        if (s.getId() == id) {
            return s;                  // Found a match: return the actual object, not a defensive copy
        }
    }
    return null;                       // No match; every caller below must check for null before using the result
}

Example Usage

Click Run to see what this code prints.

Step 4: Update a Student Record

updateStudent() reuses findById() from Step 3 rather than scanning the list a second time. If no student with that id exists, it returns false immediately and never touches any field — callers use that return value to decide whether to print "updated" or "not found," so StudentManager never needs to print anything itself.

public boolean updateStudent(int id, String newName, String newCourse, double newGpa) {
    Student student = findById(id);   // Reuse the lookup already written in Step 3 instead of duplicating it
    if (student == null) {
        return false;                  // Nothing to update; let the caller report "student not found"
    }
    student.setName(newName);          // Only StudentManager and code holding a direct Student reference can reach these
    student.setCourse(newCourse);      // setters, which is exactly the encapsulation boundary set up in Step 1
    student.setGpa(newGpa);
    return true;
}

Step 5: Delete a Student

deleteStudent() uses ArrayList.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 student is ever removed here, but removeIf() is still the cleanest way to express "delete the student whose id equals this one" without manually managing a loop index while removing from the list being iterated.

public boolean deleteStudent(int id) {
    return students.removeIf(s -> s.getId() == id);   // Lambda predicate; true only if a matching student was removed
}

Step 6: Build the Menu Loop

main() creates one StudentManager shared by every menu action and loops on a numbered menu until the user chooses to exit. Notice the scanner.nextLine() call right after every scanner.nextInt() or scanner.nextDouble() — those methods consume only the number typed, leaving the trailing newline in the input buffer, so an unconsumed leftover newline would otherwise be read as an empty line the next time nextLine() runs.

import java.util.Scanner;

public class StudentManagementSystem {
    public static void main(String[] args) {
        StudentManager manager = new StudentManager();   // One manager instance shared by every menu action below
        Scanner scanner = new Scanner(System.in);
        int choice;

        do {
            System.out.println("\n===== STUDENT MANAGEMENT SYSTEM =====");
            System.out.println("1. Add Student");
            System.out.println("2. List All Students");
            System.out.println("3. Search Student by ID");
            System.out.println("4. Update Student");
            System.out.println("5. Delete Student");
            System.out.println("6. Exit");
            System.out.print("Enter your choice: ");
            choice = scanner.nextInt();
            scanner.nextLine();   // Discard the leftover newline left behind by nextInt()

            if (choice == 1) {
                System.out.print("Enter name: ");
                String name = scanner.nextLine();
                System.out.print("Enter course: ");
                String course = scanner.nextLine();
                System.out.print("Enter GPA: ");
                double gpa = scanner.nextDouble();
                scanner.nextLine();
                Student added = manager.addStudent(name, course, gpa);
                System.out.println("Added! Assigned ID: " + added.getId());
            } else if (choice == 2) {
                System.out.println("\n--- All Students ---");
                for (Student s : manager.getAll()) {   // Reuses Student's toString() from Step 1 for each line
                    System.out.println(s);
                }
            } else if (choice == 3) {
                System.out.print("Enter ID to search: ");
                int id = scanner.nextInt();
                scanner.nextLine();
                Student found = manager.findById(id);
                if (found == null) {
                    System.out.println("No student with that ID.");
                } else {
                    System.out.println(found);
                }
            } else if (choice == 4) {
                System.out.print("Enter ID to update: ");
                int id = scanner.nextInt();
                scanner.nextLine();
                if (manager.findById(id) == null) {
                    System.out.println("No student with that ID.");
                } else {
                    System.out.print("Enter new name: ");
                    String newName = scanner.nextLine();
                    System.out.print("Enter new course: ");
                    String newCourse = scanner.nextLine();
                    System.out.print("Enter new GPA: ");
                    double newGpa = scanner.nextDouble();
                    scanner.nextLine();
                    manager.updateStudent(id, newName, newCourse, newGpa);
                    System.out.println("Student updated.");
                }
            } else if (choice == 5) {
                System.out.print("Enter ID to delete: ");
                int id = scanner.nextInt();
                scanner.nextLine();
                boolean removed = manager.deleteStudent(id);
                System.out.println(removed ? "Student deleted." : "No student with that ID.");
            } else if (choice == 6) {
                System.out.println("Goodbye!");
            } else {
                System.out.println("Invalid choice, try again.");   // Catches anything outside 1-6
            }
        } while (choice != 6);   // Keep looping until the user explicitly picks Exit

        scanner.close();   // Release the Scanner's underlying resources now that the loop has ended
    }
}

Complete Code

Here is the full program with every class assembled in the correct order, ready to save as StudentManagementSystem.java and run with javac StudentManagementSystem.java && java StudentManagementSystem.

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

class Student {
    private int id;
    private String name;
    private String course;
    private double gpa;

    public Student(int id, String name, String course, double gpa) {
        this.id = id;
        this.name = name;
        this.course = course;
        this.gpa = gpa;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getCourse() {
        return course;
    }

    public void setCourse(String course) {
        this.course = course;
    }

    public double getGpa() {
        return gpa;
    }

    public void setGpa(double gpa) {
        this.gpa = gpa;
    }

    @Override
    public String toString() {
        return String.format("ID: %-4d | Name: %-20s | Course: %-15s | GPA: %.2f", id, name, course, gpa);
    }
}

class StudentManager {
    private List<Student> students = new ArrayList<>();
    private int nextId = 1;

    public Student addStudent(String name, String course, double gpa) {
        Student student = new Student(nextId, name, course, gpa);
        students.add(student);
        nextId++;
        return student;
    }

    public List<Student> getAll() {
        return students;
    }

    public Student findById(int id) {
        for (Student s : students) {
            if (s.getId() == id) {
                return s;
            }
        }
        return null;
    }

    public boolean updateStudent(int id, String newName, String newCourse, double newGpa) {
        Student student = findById(id);
        if (student == null) {
            return false;
        }
        student.setName(newName);
        student.setCourse(newCourse);
        student.setGpa(newGpa);
        return true;
    }

    public boolean deleteStudent(int id) {
        return students.removeIf(s -> s.getId() == id);
    }
}

public class StudentManagementSystem {
    public static void main(String[] args) {
        StudentManager manager = new StudentManager();
        Scanner scanner = new Scanner(System.in);
        int choice;

        do {
            System.out.println("\n===== STUDENT MANAGEMENT SYSTEM =====");
            System.out.println("1. Add Student");
            System.out.println("2. List All Students");
            System.out.println("3. Search Student by ID");
            System.out.println("4. Update Student");
            System.out.println("5. Delete Student");
            System.out.println("6. Exit");
            System.out.print("Enter your choice: ");
            choice = scanner.nextInt();
            scanner.nextLine();

            if (choice == 1) {
                System.out.print("Enter name: ");
                String name = scanner.nextLine();
                System.out.print("Enter course: ");
                String course = scanner.nextLine();
                System.out.print("Enter GPA: ");
                double gpa = scanner.nextDouble();
                scanner.nextLine();
                Student added = manager.addStudent(name, course, gpa);
                System.out.println("Added! Assigned ID: " + added.getId());
            } else if (choice == 2) {
                System.out.println("\n--- All Students ---");
                for (Student s : manager.getAll()) {
                    System.out.println(s);
                }
            } else if (choice == 3) {
                System.out.print("Enter ID to search: ");
                int id = scanner.nextInt();
                scanner.nextLine();
                Student found = manager.findById(id);
                if (found == null) {
                    System.out.println("No student with that ID.");
                } else {
                    System.out.println(found);
                }
            } else if (choice == 4) {
                System.out.print("Enter ID to update: ");
                int id = scanner.nextInt();
                scanner.nextLine();
                if (manager.findById(id) == null) {
                    System.out.println("No student with that ID.");
                } else {
                    System.out.print("Enter new name: ");
                    String newName = scanner.nextLine();
                    System.out.print("Enter new course: ");
                    String newCourse = scanner.nextLine();
                    System.out.print("Enter new GPA: ");
                    double newGpa = scanner.nextDouble();
                    scanner.nextLine();
                    manager.updateStudent(id, newName, newCourse, newGpa);
                    System.out.println("Student updated.");
                }
            } else if (choice == 5) {
                System.out.print("Enter ID to delete: ");
                int id = scanner.nextInt();
                scanner.nextLine();
                boolean removed = manager.deleteStudent(id);
                System.out.println(removed ? "Student deleted." : "No student with that ID.");
            } else if (choice == 6) {
                System.out.println("Goodbye!");
            } else {
                System.out.println("Invalid choice, try again.");
            }
        } while (choice != 6);

        scanner.close();
    }
}

Sample Run

Click Run to see what this code prints.

Extend This Project

Add a findByName(String query) method that returns every student whose name contains the query, case-insensitively.
Switch StudentManager's backing collection from ArrayList<Student> to HashMap<Integer, Student> keyed by id, turning findById() from an O(n) scan into an O(1) lookup.
Persist students to a text file with java.io.FileWriter/BufferedReader so records survive between program runs.
Add input validation that rejects a GPA outside the 0.0-10.0 range before a student is added or updated.
Add a sortByGpa() method using students.sort(Comparator.comparingDouble(Student::getGpa)) to list top performers first.

Summary

You built a working student management system where Student protects its own data behind private fields and public accessors, and StudentManager composes many students into one manageable, searchable collection backed by ArrayList. The add/find/update/delete shape you wrote here — one class owning a collection and exposing a small, well-named method per operation — is the same shape you will reuse in almost every data-driven Java console application from here on.