---
title: "25 Java Project Ideas for Students (With Starter Code)"
description: "25 Java project ideas for beginners, students and final year, with resume tips and starter code for 10, each compiled with javac and run."
slug: java-project-ideas-for-students
canonical: https://learn.modernagecoders.com/blog/java-project-ideas-for-students/
date: 2026-11-15
dateModified: 2026-11-15
category: "Java"
tags: ["Java", "Projects", "Final Year", "Resume"]
keywords: ["java project ideas", "java project ideas for beginners", "java project ideas for students", "java projects for final year", "java projects for resume", "java mini projects", "java projects with source code"]
readTime: "18 min read"
author: "Modern Age Coders Team"
---
# 25 Java Project Ideas for Students, Beginner to Final Year

> Three levels of ideas, ten starters compiled and run on Java 21 with their real output, and how to turn a project into a resume line.

![Java project ideas for students: 25 ideas from beginner to final year with tested starter code](/images/blog/java-project-ideas-for-students/00-hero.png)

*By Modern Age Coders Team · 2026-11-15 · 18 min read*

**Quick answer:** Java project ideas in three levels: beginners build a grade calculator, bank account, tic-tac-toe and word counter; intermediate students build library, inventory, parking lot, employee and to-do systems; final year and resume projects include a Spring Boot REST API, multithreaded crawler, URL shortener, rate limiter and LRU cache. Ten have starter code compiled with javac 21 and run, with real output, plus a method for modelling systems and tips for presenting projects on a resume.

Good Java project ideas for students start small and grow with you: a grade calculator, a bank account and tic-tac-toe for beginners; library, inventory, parking lot and employee systems once you know classes and collections; and for final year or your resume, a Spring Boot REST API, a multithreaded crawler or an LRU cache. Below are **25 Java project ideas in three levels**, and 10 of them come with starter code that we compiled with `javac` and ran on Java 21, with the real output pasted.

Each starter is the working core of the project, small enough to read in a few minutes, not a finished app. The stretch goals turn it into something you can show. If you want to learn Java with projects alongside a mentor, our [Java projects for students](/java-projects-for-students) page explains how those classes run; if you are still practising single programs, see [10 Java programs every college student should know](/blog/top-10-java-programs-every-college-student-must-know).

> **How these were tested**

> Every starter was saved as its own `.java` file, compiled with `javac` 21 and run with `java`. Each runs on its own fixed sample data (no typing needed), so the output you get will match ours exactly. Some use records, text blocks and `Stream.toList()`, so use Java 17 or newer.

## All 25 Java project ideas at a glance

| No. | Project | Level | What it teaches | Starter code |
| --- | --- | --- | --- | --- |
| 1 | Student grade calculator | Beginner | arrays, loops, methods | Yes |
| 2 | Bank account | Beginner | classes, encapsulation, exceptions | Yes |
| 3 | Tic-tac-toe | Beginner | 2D arrays, game logic | Yes |
| 4 | Word frequency counter | Beginner | streams, Map, text blocks | Yes |
| 5 | Number guessing game | Beginner | Scanner, Random, while | Idea |
| 6 | Unit converter | Beginner | switch, methods | Idea |
| 7 | Calculator with history | Beginner | switch, ArrayList | Idea |
| 8 | Quiz app | Beginner | classes, lists, scoring | Idea |
| 9 | Hangman | Beginner | StringBuilder, char arrays | Idea |
| 10 | Library management system | Intermediate | classes, Optional, streams | Yes |
| 11 | Inventory manager | Intermediate | records, TreeMap, merge() | Yes |
| 12 | To-do list with file storage | Intermediate | java.nio.file, I/O | Yes |
| 13 | Parking lot system | Intermediate | enums, EnumMap, design | Yes |
| 14 | Employee management with sorting | Intermediate | records, Comparator, grouping | Yes |
| 15 | Student database app | Intermediate | JDBC, SQL | Idea |
| 16 | Snake game | Intermediate | Swing or JavaFX, game loop | Idea |
| 17 | Chat application | Intermediate | sockets, threads | Idea |
| 18 | LRU cache | Final year / resume | LinkedHashMap, generics | Yes |
| 19 | Online exam system | Final year / resume | Spring Boot, database, roles | Idea |
| 20 | Clinic appointment booking | Final year / resume | REST API, validation, scheduling | Idea |
| 21 | Expense tracker REST API | Final year / resume | Spring Boot, JPA, tests | Idea |
| 22 | Multithreaded web crawler | Final year / resume | ExecutorService, concurrency | Idea |
| 23 | URL shortener service | Final year / resume | hashing, REST, caching | Idea |
| 24 | API rate limiter | Final year / resume | token bucket, time, threads | Idea |
| 25 | Android habit tracker | Final year / resume | Android SDK in Java, local storage | Idea |

![Twenty-five Java project ideas in three levels: beginner projects with arrays and classes, intermediate systems with collections and files, and final year projects with Spring Boot, concurrency and caching](/images/blog/java-project-ideas-for-students/01-levels.png)

*Each level reuses what the one below taught.*

## Think before you code: model the nouns and verbs

Most Java projects are systems: a library, a parking lot, a shop. The trick that makes them manageable is to describe the system in one or two plain sentences, then underline the nouns and circle the verbs. "A member *borrows* a book and *returns* it; a book can be lent to one member at a time." The nouns become classes or fields (`Book`, `member`), the verbs become methods (`issue()`, `giveBack()`), and the rule (one member at a time) becomes an `if` that refuses the second loan. You can see exactly that in project 10 below. Do this on paper before you open your IDE, and the code mostly writes itself. It is also the part an AI assistant cannot do for you: it can type the classes, but only you know what your system has to allow and refuse.

## Java project ideas for beginners

These need classes, arrays, loops and a little error handling. Each fits in one file.

### 1. Student grade calculator

A 2D array holds three marks per student. The program prints totals, averages and grades, and finds the top student. Note the cast to `double`: without it, `total / 3` would chop off the decimals.

```java
public class GradeCalculator {
    static String grade(double avg) {
        if (avg >= 90) return "A";
        if (avg >= 75) return "B";
        if (avg >= 60) return "C";
        if (avg >= 40) return "D";
        return "Needs support";
    }

    public static void main(String[] args) {
        String[] names = {"Aditi", "Bilal", "Chen", "Dev"};
        int[][] marks = {
            {88, 92, 79},
            {65, 58, 71},
            {94, 97, 90},
            {38, 45, 41}
        };
        int best = 0;
        double bestAvg = -1;
        for (int i = 0; i < names.length; i++) {
            int total = 0;
            for (int m : marks[i]) total += m;
            double avg = total / (double) marks[i].length;
            System.out.printf("%-6s total %3d  avg %5.1f  %s%n", names[i], total, avg, grade(avg));
            if (avg > bestAvg) { bestAvg = avg; best = i; }
        }
        System.out.println("Top of the class: " + names[best]);
    }
}
```

**Output (compiled with javac 21 and run)**

```text
$ javac GradeCalculator.java && java GradeCalculator
Aditi  total 259  avg  86.3  B
Bilal  total 194  avg  64.7  C
Chen   total 281  avg  93.7  A
Dev    total 124  avg  41.3  D
Top of the class: Chen
```

**Stretch goal:** read the names and marks with `Scanner`, and print the class average for each subject.

### 2. Bank account

The balance is `private` and can only change through `deposit()` and `withdraw()`, which refuse bad amounts by throwing exceptions. That is encapsulation, the idea interviewers ask about most often, in thirty lines.

```java
import java.util.ArrayList;
import java.util.List;

public class BankAccount {
    private final String owner;
    private long balance;                      // whole units, so no rounding surprises
    private final List<String> statement = new ArrayList<>();

    public BankAccount(String owner, long opening) {
        this.owner = owner;
        this.balance = opening;
        statement.add("open      " + opening);
    }

    public void deposit(long amount) {
        if (amount <= 0) throw new IllegalArgumentException("Deposit must be positive");
        balance += amount;
        statement.add("deposit   " + amount);
    }

    public void withdraw(long amount) {
        if (amount > balance) throw new IllegalStateException("Insufficient funds: balance is " + balance);
        balance -= amount;
        statement.add("withdraw  " + amount);
    }

    public long getBalance() { return balance; }

    public static void main(String[] args) {
        BankAccount acc = new BankAccount("Riya", 2000);
        acc.deposit(750);
        acc.withdraw(1200);
        try {
            acc.withdraw(5000);
        } catch (IllegalStateException e) {
            System.out.println("Refused: " + e.getMessage());
        }
        System.out.println("Statement for " + acc.owner);
        acc.statement.forEach(line -> System.out.println("  " + line));
        System.out.println("Balance: " + acc.getBalance());
    }
}
```

**Output (compiled with javac 21 and run)**

```text
$ javac BankAccount.java && java BankAccount
Refused: Insufficient funds: balance is 1550
Statement for Riya
  open      2000
  deposit   750
  withdraw  1200
Balance: 1550
```

**Stretch goal:** add a `SavingsAccount` subclass that adds monthly interest, and a transfer between two accounts.

### 3. Tic-tac-toe

The board is a `char[3][3]`. `winner()` checks every row, column and both diagonals. The demo plays a fixed list of moves that ends in a draw.

```java
public class TicTacToe {
    private final char[][] board = new char[3][3];

    TicTacToe() {
        for (char[] row : board) java.util.Arrays.fill(row, '.');
    }

    boolean play(int row, int col, char player) {
        if (board[row][col] != '.') return false;
        board[row][col] = player;
        return true;
    }

    char winner() {
        for (int i = 0; i < 3; i++) {
            if (board[i][0] != '.' && board[i][0] == board[i][1] && board[i][1] == board[i][2]) return board[i][0];
            if (board[0][i] != '.' && board[0][i] == board[1][i] && board[1][i] == board[2][i]) return board[0][i];
        }
        if (board[1][1] != '.' && ((board[0][0] == board[1][1] && board[1][1] == board[2][2])
                || (board[0][2] == board[1][1] && board[1][1] == board[2][0]))) return board[1][1];
        return ' ';
    }

    void print() {
        for (char[] row : board) System.out.println(new String(row));
    }

    public static void main(String[] args) {
        TicTacToe game = new TicTacToe();
        int[][] moves = {{1, 1}, {0, 0}, {0, 2}, {2, 0}, {1, 0}, {1, 2}, {2, 2}, {0, 1}, {2, 1}};
        char player = 'X';
        for (int[] m : moves) {
            if (!game.play(m[0], m[1], player)) System.out.println("Square taken");
            if (game.winner() != ' ') break;
            player = (player == 'X') ? 'O' : 'X';
        }
        game.print();
        char w = game.winner();
        System.out.println(w == ' ' ? "Draw" : w + " wins");
    }
}
```

**Output (compiled with javac 21 and run)**

```text
$ javac TicTacToe.java && java TicTacToe
OOX
XXO
OXX
Draw
```

**Stretch goal:** read moves from the keyboard, then add a computer player that blocks your winning lines.

### 4. Word frequency counter

Splits a text block into words with a regular expression and counts them with `Collectors.groupingBy`. The sort shows how to order by count and then alphabetically when counts tie.

```java
import java.util.Arrays;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

public class WordFrequency {
    public static void main(String[] args) {
        String text = """
                It was the best of times, it was the worst of times,
                it was the age of wisdom, it was the age of foolishness.
                """;
        Map<String, Long> counts = Arrays.stream(text.toLowerCase().split("[^a-z]+"))
                .filter(w -> !w.isBlank())
                .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));

        System.out.println("Words: " + counts.values().stream().mapToLong(Long::longValue).sum());
        System.out.println("Distinct: " + counts.size());
        counts.entrySet().stream()
                .sorted(Map.Entry.<String, Long>comparingByValue().reversed()
                        .thenComparing(Map.Entry.comparingByKey()))
                .limit(5)
                .forEach(e -> System.out.println(e.getKey() + " " + e.getValue()));
    }
}
```

**Output (compiled with javac 21 and run)**

```text
$ javac WordFrequency.java && java WordFrequency
Words: 24
Distinct: 10
it 4
of 4
the 4
was 4
age 2
```

**Stretch goal:** read a whole book from a text file and skip common words such as "the" and "of".

### 5 to 9. More beginner ideas

- **Number guessing game:** `Random` picks, `Scanner` reads guesses, a `while` loop says higher or lower.
- **Unit converter:** a menu with `switch` and one method per conversion.
- **Calculator with history:** each result added to an `ArrayList` and printed on request.
- **Quiz app:** a `Question` class with text, options and answer, kept in a list and shuffled.
- **Hangman:** a `StringBuilder` of underscores revealed letter by letter.

## Java project ideas for students: intermediate systems

Now several classes work together and data outlives one method call. These are the classic school and college Java projects.

### 10. Library management system

The nouns-and-verbs method from above, in code. `find()` returns an `Optional`, so a missing book is handled on purpose instead of crashing with a `NullPointerException`.

```java
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

public class LibrarySystem {
    static class Book {
        final String id, title, author;
        String borrowedBy;                       // null when on the shelf
        Book(String id, String title, String author) { this.id = id; this.title = title; this.author = author; }
        public String toString() { return id + " " + title + " (" + author + ")" + (borrowedBy == null ? "" : " -> " + borrowedBy); }
    }

    private final List<Book> books = new ArrayList<>();

    void add(String id, String title, String author) { books.add(new Book(id, title, author)); }

    Optional<Book> find(String id) {
        return books.stream().filter(b -> b.id.equals(id)).findFirst();
    }

    String issue(String id, String member) {
        Book b = find(id).orElse(null);
        if (b == null) return "No book with id " + id;
        if (b.borrowedBy != null) return b.title + " is already issued to " + b.borrowedBy;
        b.borrowedBy = member;
        return "Issued " + b.title + " to " + member;
    }

    String giveBack(String id) {
        Book b = find(id).orElseThrow();
        String who = b.borrowedBy;
        b.borrowedBy = null;
        return who + " returned " + b.title;
    }

    List<Book> searchByAuthor(String name) {
        return books.stream().filter(b -> b.author.toLowerCase().contains(name.toLowerCase())).toList();
    }

    public static void main(String[] args) {
        LibrarySystem lib = new LibrarySystem();
        lib.add("B1", "Clean Code", "Robert C. Martin");
        lib.add("B2", "Head First Java", "Kathy Sierra");
        lib.add("B3", "Effective Java", "Joshua Bloch");
        System.out.println(lib.issue("B3", "Kunal"));
        System.out.println(lib.issue("B3", "Neha"));
        System.out.println(lib.issue("B9", "Neha"));
        System.out.println("Search 'bloch': " + lib.searchByAuthor("bloch"));
        System.out.println(lib.giveBack("B3"));
        lib.books.forEach(System.out::println);
    }
}
```

**Output (compiled with javac 21 and run)**

```text
$ javac LibrarySystem.java && java LibrarySystem
Issued Effective Java to Kunal
Effective Java is already issued to Kunal
No book with id B9
Search 'bloch': [B3 Effective Java (Joshua Bloch) -> Kunal]
Kunal returned Effective Java
B1 Clean Code (Robert C. Martin)
B2 Head First Java (Kathy Sierra)
B3 Effective Java (Joshua Bloch)
```

**Stretch goal:** add a `Member` class with a borrowing limit, due dates with `LocalDate`, and save the library to a file.

### 11. Inventory manager

Items are **records**, so they cannot be changed by accident; a sale creates a new record with the new quantity. `Map.merge()` adds stock to an item that already exists in one line. Selling 9 monitors fails because only 8 are in stock.

```java
import java.util.Map;
import java.util.TreeMap;

public class Inventory {
    record Item(String name, int qty, int reorderLevel) {
        Item withQty(int newQty) { return new Item(name, newQty, reorderLevel); }
        boolean low() { return qty <= reorderLevel; }
    }

    private final Map<String, Item> stock = new TreeMap<>();   // sorted by name

    void receive(String name, int qty, int reorderLevel) {
        stock.merge(name, new Item(name, qty, reorderLevel),
                (old, add) -> old.withQty(old.qty() + add.qty()));
    }

    boolean sell(String name, int qty) {
        Item item = stock.get(name);
        if (item == null || item.qty() < qty) return false;
        stock.put(name, item.withQty(item.qty() - qty));
        return true;
    }

    public static void main(String[] args) {
        Inventory inv = new Inventory();
        inv.receive("keyboard", 20, 5);
        inv.receive("mouse", 35, 10);
        inv.receive("monitor", 8, 3);
        inv.receive("mouse", 15, 10);
        System.out.println("sell 18 keyboard: " + inv.sell("keyboard", 18));
        System.out.println("sell 9 monitor:   " + inv.sell("monitor", 9));
        System.out.println("sell 40 mouse:    " + inv.sell("mouse", 40));
        inv.stock.values().forEach(i ->
                System.out.printf("%-9s %3d %s%n", i.name(), i.qty(), i.low() ? "REORDER" : ""));
    }
}
```

**Output (compiled with javac 21 and run)**

```text
$ javac Inventory.java && java Inventory
sell 18 keyboard: true
sell 9 monitor:   false
sell 40 mouse:    true
keyboard    2 REORDER
monitor     8 
mouse      10 REORDER
```

**Stretch goal:** add a sales log and a report of the best-selling items.

### 12. To-do list with file storage

Saves tasks to `todo.txt` with `java.nio.file.Files`, reads them back as the next run would, ticks one off and saves again. File I/O is what turns a demo into an app you would really use.

```java
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;

public class TodoFile {
    static final Path FILE = Path.of("todo.txt");

    static List<String> load() throws IOException {
        return Files.exists(FILE) ? new ArrayList<>(Files.readAllLines(FILE)) : new ArrayList<>();
    }

    static void save(List<String> tasks) throws IOException {
        Files.write(FILE, tasks);
    }

    public static void main(String[] args) throws IOException {
        Files.deleteIfExists(FILE);             // fresh start for the demo

        List<String> tasks = load();
        tasks.add("[ ] Revise arrays");
        tasks.add("[ ] Push project to GitHub");
        tasks.add("[ ] Write README");
        save(tasks);

        List<String> reopened = load();          // what the next run of the program sees
        reopened.set(1, reopened.get(1).replace("[ ]", "[x]"));
        save(reopened);

        System.out.println("todo.txt now contains:");
        Files.readAllLines(FILE).forEach(t -> System.out.println("  " + t));
        long done = reopened.stream().filter(t -> t.startsWith("[x]")).count();
        System.out.println(done + " of " + reopened.size() + " done");
    }
}
```

**Output (compiled with javac 21 and run)**

```text
$ javac TodoFile.java && java TodoFile
todo.txt now contains:
  [ ] Revise arrays
  [x] Push project to GitHub
  [ ] Write README
1 of 3 done
```

**Stretch goal:** add a menu loop with add, done, delete and list commands, and store due dates.

### 13. Parking lot system

An `enum` for bay sizes, an `EnumMap` of free spaces and a map of parked vehicles. The charge is in "points" per hour to keep the design about logic, not money. Parking lot is a favourite object-oriented design interview question, so it is worth building yourself.

```java
import java.util.EnumMap;
import java.util.HashMap;
import java.util.Map;

public class ParkingLot {
    enum Size { BIKE, CAR, TRUCK }

    private final Map<Size, Integer> free = new EnumMap<>(Size.class);
    private final Map<String, Size> parked = new HashMap<>();
    private final Map<Size, Integer> ratePerHour = Map.of(Size.BIKE, 10, Size.CAR, 20, Size.TRUCK, 50);

    ParkingLot(int bikes, int cars, int trucks) {
        free.put(Size.BIKE, bikes);
        free.put(Size.CAR, cars);
        free.put(Size.TRUCK, trucks);
    }

    String enter(String plate, Size size) {
        if (free.get(size) == 0) return plate + ": no " + size + " space";
        free.merge(size, -1, Integer::sum);
        parked.put(plate, size);
        return plate + ": parked in " + size + " bay";
    }

    String exit(String plate, int hours) {
        Size size = parked.remove(plate);
        if (size == null) return plate + ": not found";
        free.merge(size, 1, Integer::sum);
        int billedHours = Math.max(1, hours);
        return plate + ": left after " + hours + "h, charge " + billedHours * ratePerHour.get(size) + " points";
    }

    public static void main(String[] args) {
        ParkingLot lot = new ParkingLot(2, 1, 1);
        System.out.println(lot.enter("KA01AB1234", Size.CAR));
        System.out.println(lot.enter("MH12XY9999", Size.CAR));
        System.out.println(lot.enter("DL3CQ0001", Size.BIKE));
        System.out.println(lot.exit("KA01AB1234", 3));
        System.out.println(lot.enter("MH12XY9999", Size.CAR));
        System.out.println(lot.exit("ZZ00ZZ0000", 1));
        System.out.println("Free now: " + lot.free);
    }
}
```

**Output (compiled with javac 21 and run)**

```text
$ javac ParkingLot.java && java ParkingLot
KA01AB1234: parked in CAR bay
MH12XY9999: no CAR space
DL3CQ0001: parked in BIKE bay
KA01AB1234: left after 3h, charge 60 points
MH12XY9999: parked in CAR bay
ZZ00ZZ0000: not found
Free now: {BIKE=1, CAR=0, TRUCK=1}
```

**Stretch goal:** add levels, let a bike use a car bay when bike bays are full, and record entry times with `LocalDateTime`.

### 14. Employee management with sorting

Records plus streams: sort by rating and then experience with a chained `Comparator`, and average ratings per department with `groupingBy`. These two moves cover a large share of real reporting code.

```java
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class EmployeeSort {
    record Employee(String name, String dept, int years, int rating) {}

    public static void main(String[] args) {
        List<Employee> staff = List.of(
                new Employee("Anika", "Engineering", 4, 5),
                new Employee("Bharat", "Sales", 7, 3),
                new Employee("Carmen", "Engineering", 2, 4),
                new Employee("Daniel", "Support", 5, 4),
                new Employee("Esha", "Sales", 3, 5));

        System.out.println("By rating, then experience:");
        staff.stream()
                .sorted(Comparator.comparingInt(Employee::rating).reversed()
                        .thenComparing(Comparator.comparingInt(Employee::years).reversed()))
                .forEach(e -> System.out.printf("  %-7s %-12s %dy  rating %d%n", e.name(), e.dept(), e.years(), e.rating()));

        Map<String, Double> avgByDept = staff.stream()
                .collect(Collectors.groupingBy(Employee::dept, java.util.TreeMap::new,
                        Collectors.averagingInt(Employee::rating)));
        System.out.println("Average rating by department: " + avgByDept);
    }
}
```

**Output (compiled with javac 21 and run)**

```text
$ javac EmployeeSort.java && java EmployeeSort
By rating, then experience:
  Anika   Engineering  4y  rating 5
  Esha    Sales        3y  rating 5
  Daniel  Support      5y  rating 4
  Carmen  Engineering  2y  rating 4
  Bharat  Sales        7y  rating 3
Average rating by department: {Engineering=4.5, Sales=4.0, Support=4.0}
```

**Stretch goal:** load employees from a CSV file and let the user choose the sort order.

### 15 to 17. More intermediate ideas

- **Student database app:** the same records stored in SQLite or MySQL through JDBC, with add, search, update and delete.
- **Snake game:** a Swing or JavaFX window, a timer for the game loop, and a list of points for the snake.
- **Chat application:** a `ServerSocket` that accepts several clients, one thread per client, broadcasting each message.

## Java project ideas for final year and your resume

Final year and resume projects are judged on depth: a real problem, clean structure, tests, and decisions you can defend in an interview. One project done thoroughly beats five tutorials.

### 18. LRU cache

A least-recently-used cache keeps the most recently used items and throws out the oldest when full. Java's `LinkedHashMap` can do it in a few lines: pass `true` for access order and override `removeEldestEntry`. Reading `home` moves it to the back of the line, so `about` is the one evicted.

```java
import java.util.LinkedHashMap;
import java.util.Map;

public class LRUCache<K, V> extends LinkedHashMap<K, V> {
    private final int capacity;

    public LRUCache(int capacity) {
        super(16, 0.75f, true);                 // true = order by access, not insertion
        this.capacity = capacity;
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        return size() > capacity;               // evict the least recently used entry
    }

    public static void main(String[] args) {
        LRUCache<String, String> cache = new LRUCache<>(3);
        cache.put("home", "<html>home</html>");
        cache.put("about", "<html>about</html>");
        cache.put("blog", "<html>blog</html>");
        System.out.println("Cache: " + cache.keySet());
        cache.get("home");                      // home is now the most recent
        System.out.println("After reading home: " + cache.keySet());
        cache.put("contact", "<html>contact</html>");
        System.out.println("After adding contact: " + cache.keySet());
        System.out.println("about still cached? " + cache.containsKey("about"));
    }
}
```

**Output (compiled with javac 21 and run)**

```text
$ javac LRUCache.java && java LRUCache
Cache: [home, about, blog]
After reading home: [about, blog, home]
After adding contact: [blog, home, contact]
about still cached? false
```

**Stretch goal:** write it again without `LinkedHashMap`, using a `HashMap` plus your own doubly linked list, and make it thread-safe. That version is a common interview question.

![How the LRU cache changes: after adding home, about and blog the order is home, about, blog; reading home moves it to the end; adding contact evicts about, the least recently used](/images/blog/java-project-ideas-for-students/02-lru.png)

*The order is the whole idea: the front of the line is the next to go.*

### 19 to 25. More final year project ideas

- **Online exam system:** Spring Boot, a database of questions, timed tests, student and teacher roles, results with analytics.
- **Clinic appointment booking:** a REST API that refuses double bookings, with validation, doctor schedules and email reminders.
- **Expense tracker REST API:** Spring Boot with JPA, endpoints for expenses and categories, monthly reports, and JUnit tests for every rule.
- **Multithreaded web crawler:** an `ExecutorService` fetching pages in parallel, a concurrent set of visited links, polite delays and a depth limit.
- **URL shortener service:** base-62 codes, a REST endpoint that redirects, click counts, and the LRU cache from project 18 in front of the database.
- **API rate limiter:** the token bucket algorithm, tested with many threads hitting it at once.
- **Android habit tracker:** Android still supports Java; store habits locally and show streaks.

### How to present a Java project on your resume

- One line on the problem, one on what you built, and one on a result you measured (for example how many pages the crawler fetched per minute, measured by you).
- A GitHub link with a README: what it does, how to run it, a screenshot or sample output, and what you would improve.
- Tests. Even ten JUnit tests show you think about correctness.
- Be ready to explain any line. Interviewers often pick the most complex method and ask why.

## Java projects for school students

For ICSE and ISC students using BlueJ, the beginner projects (grade calculator, bank account, tic-tac-toe, quiz) match the classes, arrays and strings in the syllabus. Our [50 Java programs for ICSE Class 10](/blog/50-java-programs-for-icse-class-10) are the program-level practice, and the [ICSE Class 10 project guide](/icse-class-10-computer-applications-project-and-internal-assessment) covers the internal assessment.

## How we teach it

Following our [how we teach](/how-we-teach) page, students explain their thinking out loud, trace a loop line by line before running it, derive the rule themselves before they ever see it written down, and see the same problem three ways (the LRU cache, for example, with `LinkedHashMap`, with a hand-built linked list, and on paper). Mistakes are data, not failures. Teens can start with [Java for teens](/courses/java-programming-masterclass-for-teens), college students with the [Java course for college](/courses/complete-java-programming-masterclass-college) (core Java to Spring Boot), and our [Java projects for students](/java-projects-for-students) page explains the project-based approach. The first class is free: [book a free demo class](/book-demo).

## Frequently asked questions

**What are good Java project ideas for beginners?**

A student grade calculator, a bank account class, tic-tac-toe, a word frequency counter, a number guessing game, a unit converter, a quiz and hangman. They need only classes, arrays, loops and basic error handling.

**What Java projects should students build?**

After the beginner ones, build systems where several classes work together: library management, an inventory manager, a parking lot, employee management and a to-do list that saves to a file. These are the classic school and college Java projects.

**What are good Java projects for final year?**

An online exam system, a clinic appointment booking API, an expense tracker REST API with tests, a multithreaded web crawler, a URL shortener service or an API rate limiter. Pick one and build it thoroughly, with a database, tests and documentation.

**Which Java projects look good on a resume?**

Projects that solve a real problem and show depth: a Spring Boot REST API with tests, something concurrent such as a crawler, or a data structure built from scratch such as an LRU cache. A clear README and code you can explain matter more than the number of projects.

**Do I need Spring Boot for a Java project?**

Not for beginner or intermediate projects, which run with plain Java. For final year and resume projects that serve a web API, Spring Boot is the most common choice and worth learning.

**Which Java version should I use?**

Java 17 or 21, both long-term support releases. The starters on this page were tested on Java 21 and use records and text blocks, which need Java 16 and 15 or newer respectively.

**Can I build Java projects in BlueJ?**

Yes. Every starter here is a single class with a main method, so it runs in BlueJ, IntelliJ IDEA, Eclipse, VS Code or plain javac and java in a terminal.

**How long does a Java project take?**

Beginner starters take an hour or two with the stretch goal. Intermediate systems take a week of evenings. A final year project with a database, API and tests is usually several weeks of steady work.

[Book a free Java class](/book-demo)

---

*Source: https://learn.modernagecoders.com/blog/java-project-ideas-for-students/*
