Forem: David Titilayo

Command line Expense Tracker

David Titilayo — Tue, 31 Mar 2026 19:01:17 +0000

Command-Line Expense Tracker

Using Java with a database-backed architecture

Challenge Outlines

Object-Oriented Programming (OOP):
is a programming paradigm based on the concept of objects that contain data (fields)
and behavior (methods). . It models real-world entities and improves code maintenance,
scalability, and collaboration.
Clean Code principles:
includes using meaningful names, adhering to the Single Responsibility Principle
(functions do one thing), keeping code DRY (Don't Repeat Yourself),
and maintaining consistent formatting to minimize cognitive load.
Layered architecture (Controller → Service → Repository):
used for separation of concerns in applications.
Working with a database (SQLite or MySQL)
mySql was used for this application.
JCBC (Java Database Connectivity):
used to interact with your relational database.
Exception handling and validation:
complementary techniques to ensure application stability and data integrity
Writing maintainable and scalable code: Maintainability
refers to how easily code can be modified, debugged, and enhanced, while
scalability refers to the system’s ability to handle increasing loads.

Dependency Configuration (Maven)

The project uses Maven for dependency management.
Key dependencies include:
Spring Shell → enables CLI interaction
Spring Boot Starter JDBC → simplifies database access
MySQL Connector → connects Java to MySQL
Lombok → reduces boilerplate code
These dependencies are defined in the pom.xml file.

<dependencies>
    <!-- Spring Boot JDBC Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>

    <!-- Spring Shell for CLI interaction -->
    <dependency>
        <groupId>org.springframework.shell</groupId>
        <artifactId>spring-shell-starter</artifactId>
    </dependency>

    <!-- MySQL Connector -->
    <dependency>
        <groupId>com.mysql</groupId>
        <artifactId>mysql-connector-j</artifactId>
        <scope>runtime</scope>
    </dependency>

    <!-- Lombok for reducing boilerplate code -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>

    <!-- Testing Dependencies -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>

    <dependency>
        <groupId>org.springframework.shell</groupId>
        <artifactId>spring-shell-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

Database Configuration

spring.datasource.url=jdbc:mysql://localhost:3306/expense
spring.datasource.username=*****
spring.datasource.password=*****
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

Project Structure

src/
└── main/
├── java/
│ └── myclexpensetracker/
│ ├── controller/
│ │ └── ExpenseController.java
│ ├── model/
│ │ └── Expense.java
│ ├── repository/
│ │ └── ExpenseRepository.java
│ ├── service/
│ │ ├── ExpenseService.java
│ │ └── ExpenseServiceInterface.java
│ ├── utilities/
│ │ ├── Category.java
│ │ └── Listformat.java
│ └── MyClExpenseTrackerApplication.java
└── resources/
└── application.properties

Core Data Model

The application revolves around a single core entity: Expense.
This model represents an expense record and is used throughout the system.

public class Expense {
    private int id;
    private double amount;
    private String description;
    private String category;
    private LocalDate date;
    private LocalDateTime createdAt;
}

The Repository Layer

The Repository layer is responsible for interacting directly with the database using JDBC.
It uses JdbcTemplate provided by Spring to execute SQL queries and map results to Java objects.

Key Responsibilities

Saving expenses to the database
Retrieving data (all, by ID, category, date, etc.)
Updating and deleting records
Running aggregate queries (e.g., total spending)

Example Operations

//Get All Expenses
public List<Expense> findAll();
//Get Expense by ID
public Expense findById(int id);
//Get Expenses by Category
public List<Expense> findByCategory(String category);
//Get Expenses by Date
public List<Expense> findByDate(LocalDate date);
//Get Expenses by Date Range
public List<Expense> findByDateRange(LocalDate startDate, LocalDate endDate);
//Update Expense
public void update(int id, String description, String category);
//Delete Expense
public void deleteById(int id);
//Total Spending
public Double getTotalSpending();
// Spending by Category
public List<Map<String, Object>> getSpendingByCategory();

JDBC Queries & Prepared Statements

The application uses Spring's JdbcTemplate, which internally uses Prepared Statements to safely execute SQL queries.

Prepared statements help to:

Prevent SQL Injection
Improve performance (queries are precompiled)
Safely insert dynamic values into SQL

➤ Insert Query (Save Expense)

jdbc.update(
    "INSERT INTO expense(amount, description, category, date, createdAt) VALUES (?, ?, ?, ?, ?)",
    expense.getAmount(),
    expense.getDescription(),
    expense.getCategory(),
    expense.getDate(),
    expense.getCreatedAt()
);

Expense Repository

@Repository
@RequiredArgsConstructor
public class ExpenseRepository {

  private final JdbcTemplate jdbc;

  // ===================== SAVE =====================
  public void save(Expense expense) {
    jdbc.update(
            "INSERT INTO expense(amount, description, category, date, createdAt) VALUES (?, ?, ?, ?, ?)",
            expense.getAmount(),
            expense.getDescription(),
            expense.getCategory().name(),
            expense.getDate(),
            expense.getCreatedAt()
    );
  }

  // ===================== FIND ALL =====================
  public List<Expense> findAll() {
    return jdbc.query("SELECT * FROM expense", (rs, rowNum) -> {
      Expense expense = new Expense();
      expense.setId(rs.getInt("id"));
      expense.setAmount(rs.getDouble("amount"));
      expense.setDescription(rs.getString("description"));
      expense.setCategory(Category.valueOf(rs.getString("category").toUpperCase()));
      expense.setDate(rs.getDate("date").toLocalDate());
      expense.setCreatedAt(rs.getTimestamp("createdAt").toLocalDateTime());
      return expense;
    });
  }

  // ===================== FIND BY ID =====================
  public Expense findById(int id) {
    return jdbc.queryForObject(
            "SELECT * FROM expense WHERE id = ?",
            (rs, rowNum) -> new Expense(
                    rs.getInt("id"),
                    rs.getDouble("amount"),
                    rs.getString("description"),
                    Category.valueOf(rs.getString("category").toUpperCase()),
                    rs.getDate("date").toLocalDate(),
                    rs.getTimestamp("createdAt").toLocalDateTime()
            ),
            id
    );
  }

  // ===================== FIND BY CATEGORY =====================
  public List<Expense> findByCategory(String category) {
    return jdbc.query(
            "SELECT * FROM expense WHERE category = ?",
            (rs, rowNum) -> new Expense(
                    rs.getInt("id"),
                    rs.getDouble("amount"),
                    rs.getString("description"),
                    Category.valueOf(rs.getString("category").toUpperCase()),
                    rs.getDate("date").toLocalDate(),
                    rs.getTimestamp("createdAt").toLocalDateTime()
            ),
            category
    );
  }

  // ===================== FIND BY DATE =====================
  public List<Expense> findByDate(LocalDate date) {
    return jdbc.query(
            "SELECT * FROM expense WHERE date = ?",
            (rs, rowNum) -> new Expense(
                    rs.getInt("id"),
                    rs.getDouble("amount"),
                    rs.getString("description"),
                    Category.valueOf(rs.getString("category").toUpperCase()),
                    rs.getDate("date").toLocalDate(),
                    rs.getTimestamp("createdAt").toLocalDateTime()
            ),
            date
    );
  }

  // ===================== FIND BY DATE RANGE =====================
  public List<Expense> findByDateRange(LocalDate startDate, LocalDate endDate) {
    return jdbc.query(
            "SELECT * FROM expense WHERE date BETWEEN ? AND ?",
            (rs, rowNum) -> new Expense(
                    rs.getInt("id"),
                    rs.getDouble("amount"),
                    rs.getString("description"),
                    Category.valueOf(rs.getString("category").toUpperCase()),
                    rs.getDate("date").toLocalDate(),
                    rs.getTimestamp("createdAt").toLocalDateTime()
            ),
            startDate,
            endDate
    );
  }

  // ===================== UPDATE =====================
  public void update(int id, String description, String category) {
    jdbc.update(
            "UPDATE expense SET description = ?, category = ? WHERE id = ?",
            description,
            Category.valueOf(category.toUpperCase()).name(),
            id
    );
  }

  // ===================== DELETE =====================
  public void deleteById(int id) {
    jdbc.update("DELETE FROM expense WHERE id = ?", id);
  }

  // ===================== TOTAL SPENDING =====================
  public Double getTotalSpending() {
    Double total = jdbc.queryForObject(
            "SELECT SUM(amount) FROM expense",
            Double.class
    );
    return (total != null) ? total : 0.0;
  }

  // ===================== SPENDING BY CATEGORY =====================
  public List<Map<String, Object>> getSpendingByCategory() {
    return jdbc.queryForList(
            "SELECT category, SUM(amount) AS total FROM expense GROUP BY category"
    );
  }
}

Service Layer (Business Logic)

The Service layer is responsible for handling the core business logic of the application.
It acts as a bridge between the Controller and the Repository.

Responsibilities

Validating user input
Enforcing business rules
Handling exceptions
Coordinating data flow between layers

📌 Service Implementation

@Service
@RequiredArgsConstructor
public class ExpenseService implements ExpenseServiceInterface {
    private final ExpenseRepository repository;

    public Expense getExpenseById(int id) {
        if (id <= 0) {
            throw new IllegalArgumentException("Invalid expense ID");
        }
        try {
            return repository.findById(id);
        } catch (Exception e) {
            throw new RuntimeException("Expense with ID " + id + " not found");
        }
    }

    public List<Expense> getAllExpenses() {
        List<Expense> expenseList = repository.findAll();

        if (expenseList.isEmpty()) {
            throw new RuntimeException("Expense list is empty");
        }
        return expenseList;
    }

    public void addExpense(Double amount, String category, String description) {
        Expense expense = new Expense();

        if (amount <= 0) {
            throw new IllegalArgumentException("Amount must be greater than 0");
        }

        if (category == null || category.isEmpty()) {
            throw new IllegalArgumentException("Category cannot be empty");
        }

        if (description == null || description.isEmpty()) {
            throw new IllegalArgumentException("Description cannot be empty");
        }

        expense.setAmount(amount);
        expense.setCategory(category);
        expense.setDescription(description);
        expense.setCreatedAt(LocalDateTime.now());
        expense.setDate(LocalDate.now());

        repository.save(expense);
    }

    public List<Expense> getByCategory(String category) {
        if (category == null || category.isEmpty()) {
            throw new IllegalArgumentException("Category cannot be empty");
        }

        List<Expense> expenseList = repository.findByCategory(category);

        if (expenseList.isEmpty()) {
            throw new RuntimeException("Expense list is empty");
        }

        return expenseList;
    }

    public List<Expense> getByDate(LocalDate date) {
        if (date == null) {
            throw new IllegalArgumentException("Date cannot be null");
        }

        try {
            return repository.findByDate(date);
        } catch (Exception e) {
            throw new RuntimeException("No expenses found for date: " + date);
        }
    }

    public List<Expense> getByDateRange(LocalDate startDate, LocalDate endDate) {
        if (startDate == null || endDate == null) {
            throw new IllegalArgumentException("Start date and end date cannot be null");
        }

        if (startDate.isAfter(endDate)) {
            throw new IllegalArgumentException("Start date cannot be after end date");
        }

        try {
            return repository.findByDateRange(startDate, endDate);
        } catch (Exception e) {
            throw new RuntimeException("No Expenses Available for the provided Age range");
        }
    }

    public List<Map<String, Object>> getSpendingByCategory() {
        try {
            return repository.getSpendingByCategory();
        } catch (Exception e) {
            throw new RuntimeException("No Spending found");
        }
    }
}

Controller Layer (CLI Interaction)

The Controller layer handles user interaction through the command line using Spring Shell.

It receives commands from the user and delegates them to the Service layer.

📌 Controller Implementation

@ShellComponent
@RequiredArgsConstructor
public class ExpenseController {
    private final ExpenseService service;

    @ShellMethod(value="Add a new expense", key = "add")
    public String addExpense(double amount, String category, String description) {
        service.addExpense(amount, category, description);
        return "Expense added successfully";
    }

    @ShellMethod(value = "View all expenses", key = "view all")
    public List<Expense> list() {
        return service.getAllExpenses();
    }

    @ShellMethod(value= "Get expense by ID", key= "getById")
    public Expense get(int id) {
        return service.getExpenseById(id);
    }

    @ShellMethod("Search expenses by category")
    public List<Expense> category(String category) {
        return service.getByCategory(category);
    }

    @ShellMethod("Search expenses by date (YYYY-MM-DD)")
    public List<Expense> date(String date) {
        return service.getByDate(LocalDate.parse(date));
    }

    @ShellMethod("Search expenses by date range")
    public List<Expense> range(String start, String end) {
        return service.getByDateRange(
                LocalDate.parse(start),
                LocalDate.parse(end)
        );
    }

    @ShellMethod("View spending summary by category")
    public List<Map<String, Object>> summary() {
        return service.getSpendingByCategory();
    }
}

🧾 Expense Tracker Utility Documentation

This document explains the utility classes used in the Expense Tracker CLI application built with Spring Boot and Spring Shell.

📦 1. Listformat Utility Class

📌 Overview

The Listformat class is a utility/formatter component responsible for converting Expense objects and related data structures into readable CLI-friendly output.

It ensures that all responses displayed in the terminal are:

Clean
Consistent
Easy to read
Structured (not raw object dumps)

🧱 Class Definition

@Component
public class Listformat
// Format a single expense
    public String formatExpense(Expense e) {
        return """
            ------------------------
            ID: %d
            Amount: %.2f
            Category: %s
            Description: %s
            Date: %s
            Created At: %s
            ------------------------
            """.formatted(
                e.getId(),
                e.getAmount(),
                e.getCategory(),
                e.getDescription(),
                e.getDate(),
                e.getCreatedAt()
        );
    }

    // Format a list of expenses with a title
    public String formatExpenseList(String title, List<Expense> expenses) {
        if (expenses == null || expenses.isEmpty()) {
            return "\n========== " + title.toUpperCase() + " ==========\n\nNo expenses found.";
        }

        StringBuilder sb = new StringBuilder();
        sb.append("\n========== ")
                .append(title.toUpperCase())
                .append(" ==========\n\n");

        for (Expense e : expenses) {
            sb.append(formatExpense(e)).append("\n");
        }

        return sb.toString();
    }

    // Format spending summary (category totals)
    public String formatSummary(List<Map<String, Object>> summary) {
        if (summary == null || summary.isEmpty()) {
            return "No summary data found.";
        }

        StringBuilder sb = new StringBuilder();
        sb.append("\n========== SPENDING SUMMARY ==========\n\n");

        for (Map<String, Object> row : summary) {
            sb.append("Category: ").append(row.get("category")).append("\n")
                    .append("Total: ").append(row.get("total")).append("\n")
                    .append("------------------------\n");
        }

        return sb.toString();
    }

Format a Single Expense(Example)

------------------------
ID: 1
Amount: 5000.00
Category: FOOD
Description: Jollof rice
Date: 2026-03-31
Created At: 2026-03-31T15:49:06
------------------------

Category Enum Documentation

Overview

The Category enum defines a fixed set of allowed expense categories in the Expense Tracker application. It is used to standardize how expenses are grouped, filtered, and stored across the system.

By using an enum instead of raw strings, the application ensures data consistency, type safety, and easier maintenance.

Enum Definition

package myclexpensetracker.utilities;

public enum Category {
    FOOD,
    TRANSPORT,
    UTILITIES,
    ENTERTAINMENT,
    HEALTH,
    EDUCATION,
    OTHER
}

Spring Shell Controller Testing Guide

# ➕ Add Expense
add 323 FOOD "adsfdkfnajdf;"

# 📄 View All Expenses
view all

# 🔍 Get Expense by ID
getById 1

# 🏷️ Search by Category
category FOOD

# 📅 Search by Date
date 2026-03-31

# 📆 Search by Date Range
range 2026-03-01 2026-03-31

# 📊 Summary
summary

Java Notes

David Titilayo — Wed, 04 Feb 2026 14:59:06 +0000

Run Java from Terminal

$ javac App.java && java App

Javac command is used to compile the Java code to byte code(App.class) while "&&" is a logical AND connector and "java" command runs the byte code

Hello World

public class Main{
      public static void main(String [] args){
          System.out.println("Hello World");
      }
}

Variables

Variables are just like containers that holds some values.

public class Main{
    public static void main(String [] args){
         int age = 10;
         String name = "Davet";
         boolean isCorrect = true;
         float height = 6.4F;
         double weight = 6.0;
         char gender = 'M';
         byte a = 1;
         long number = 2334323423432423L;
    }
}

in the above code, various variables are declared and values were assigned to them.

String Methods

These are methods that can be applied to strings for manipulation or other purposes.

   public class Main{
   public static void main(String [] args){
        String name = "Davet"; 
        name.toLowerCase(); // david
        name.toUpperCase();//  DAVID
        name.trim();               // removes spaces at start & end
        name.replace("a", "b");    // replaces characters
   }
}

Enum

Enum is a like a container used to save some sets of constant value.

 public class Main {
    public static void main(String[] args) {
        GRADE fail = GRADE.F;
        System.out.println(fail);
    }

    enum GRADE {
        A,
        B,
        C,
        D,
        E,
        F
    }
}

While Loop

The while loop is used to continually run some lines of code while a certain condition remains true.

public class Main {
    public static void main(String[] args) {
        boolean isCorrect = true;
        int count = 0;
        while (count < 10){
            System.out.println("The answer you picked is correct");
            count++;
        }
    }
}

Function

A function is a set of code that is used to perform a particular function. A function usually needs to be invoked before it can be used.

public class Main {
    public static void main(String[] args) {
        introduce();

    }


    public static void introduce() {
        String name = "David";
        String jobDescription = "Backend Developer";
        System.out.printf("I am %s, a %s", name, jobDescription);
    }
}

Atomicity

Atomicity is a concept that explains either all operations are carried out successfully or was not carried out at all.

import java.util.concurrent.AtomicInteger;
public class Main {
    static int count = 1;

    synchronized static void increment() {
        count++;
    }

    public static void main(String[] args) {
        increment();
        System.out.println(count); //prints 2
         //Using Atomic Integer
         AtomicInteger atomicint = new AtomicInteger(1); // Create a new instance of Atomic integer and initialise it with 1.
         System.out.println(atomicInt.getAndIncrement()); // prints 1
         System.out.println(atomicInt.Incrementandget()); // prints 3
         System.out.println(atomicInt.get()); prints 3


    }


}

Array

Array is like a container to save data of same data types

public class Main{
    public static void main(String[] args){
         int[] myFavNums = {1, 3, 5, 7, 9, 8};
         for( int i: myFavNums){
          System.out.print(i);
      }
    }
}

Class and Object

A class is a blueprint(template) of an object. An object is an instance of a class.

public class Main{
    public static void main(String[] args){
        Person person1 = new Person("Grace", 12);
        person1.introduce();

    }

}
class Person{
    String name;
    int age;

    public Person(String name, int age){
        this.name = name;
        this.age = age;
    }

    void introduce(){
        System.out.println("My name is " + name + " and I am " + age + " old");
    }

}

Inheritance

Inheritance is one of the core pillars of Object-Oriented Programming that lets a child class inherit the properties and methods of its parent class.

public class Main {
    public static void main(String[] args) {

        Person personOne = new Person("joe", 78);
        personOne.heartBeats();

        Baby babyOne = new Baby("baby Joe", 1);
        babyOne.heartbeats();
    }
}

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    void heartBeats() {
        System.out.println("My heart is functioning");
    }
}

class Baby extends Person {
    private String name;
    private int age;

    public Baby(String name, int age) {
        super(name, age); // call parent constructor
        this.name = name;
        this.age = age;
    }

    void heartbeats() {
        System.out.println("Name is " + name + " and age is " + age);
        super.heartBeats();
    }
}

Interface

An interface is a reference type in Java, similar to a class, that can contain abstract methods.

public class Main {
    public static void main(String[] args) {

        Person personOne = new Person("David");
        personOne.scream();
    }

}

interface Shout {
    void scream();
}

class Person implements Shout {

    private final String name;

    public Person(String name) {
        this.name = name;
    }

    @Override
    public void scream() {
        System.out.println(name + " screamed, Ahhhhh!!!");
    }
}

Static Method

A static method belongs to the class itself, not to any specific object created from the class.

public class Main {
    public static void main(String [] args){
        StaticDisplay.myName("David");
    }



}

class StaticDisplay{
    static void myName(String name){
        System.out.println("My name is " + name) ;
    }


}

This Keyword

The this keyword refers to the current object of a class.

class Student {
    String name;
    int age;

    // Constructor
    Student(String name, int age) {
        this.name = name; // 'this.name' refers to instance variable
        this.age = age;   // 'this.age' refers to instance variable
    }

    void display() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }
}

public class Main {
    public static void main(String[] args) {
        Student s1 = new Student("David", 20);
        s1.display();
    }
}

Constructor Overloading

Constructor overloading is a concept in Java where a class has more than one constructor with different parameter lists.

class Student {
    String name;
    int age;

    // Constructor 1
    Student(String name, int age) {
        this.name = name; // 'this.name' refers to instance variable
        this.age = age;   // 'this.age' refers to instance variable
    }
   // Constructor 2
   Student(String name) {
        this.name = name; // 'this.name' refers to instance variable
    }

    void display() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }
}

public class Main {
    public static void main(String[] args) {
        Student s1 = new Student("David", 20);
        s1.display();
    }
}

Polymorphism(Method Overriding)

Polymorphism is an OOP concept where the same method name can perform different actions based on the object calling it.
Method overriding is a type of polymorphism where a child class provides its own implementation of a method defined in the parent class.

class Animal {

    void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {

    @Override
    void sound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {

        Animal a = new Dog(); // Polymorphism
        a.sound();           // Calls Dog's version
    }
}

Abstraction
Abstraction is an OOP concept that focuses on showing only essential features while hiding implementation details. Abstract class cannot be instanciated, it has to be inherited by a child class to implement it. Abstract methods don't have body.

abstract class Animal {

    abstract void sound();
}

class Dog extends Animal {


    void sound() {
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {

        Animal a = new Dog(); // Polymorphism
        a.sound();           // Calls Dog's version
    }
}

Super() Keyword

The super keywod refers to the parent class.

class Animal {
    void eat() {
        System.out.println("Animal eats food");
    }
}

class Dog extends Animal {
    void eat() {
        System.out.println("Dog eats bones");
    }

    void showEat() {
        eat();         // Calls Dog's eat()
        super.eat();   // Calls Animal's eat()
    }
}

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.showEat();
    }
}

Wrapper Classes

Wrapper classes convert primitive data types into Reference data types.

Primitive	Wrapper
int	Integer
double	Double
char	Character
boolean	Boolean

Integer age = 20;

String Builder

StringBuilder is mutable, allowing efficient modification of text using methods like append, insert, delete, replace, and reverse.
In contrast, String is immutable, so any change creates a new object, making StringBuilder faster for repeated string operations.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hello");

        sb.append(" World");       // Hello World
        sb.insert(6, "Java ");     // Hello Java World
        sb.replace(6, 10, "C++");  // Hello C++ World
        sb.delete(5, 9);           // HelloWorld
        sb.reverse();              // dlroWolleH

        System.out.println(sb.toString());
    }
}

Null Pointer

A null pointer occurs when a reference variable does not point to any object, i.e., it has the value null.

public class Main {
    public static void main(String[] args) {
        String str = null;  // str points to nothing

        // This will cause NullPointerException
        // System.out.println(str.length());

        if (str != null) {
            System.out.println(str.length()); // Safe check
        } else {
            System.out.println("String is null");
        }
        System.out.println(str.length()); //💥 NullPointerException
    }
}

List

A List in Java is an ordered collection, meaning elements are stored in the order they are inserted, and it allows duplicate elements.

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

public class Main {
    public static void main(String[] args) {
        List<String> fruits = new ArrayList<>();

        // Adding elements
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Apple"); // duplicate allowed

        // Accessing elements
        for (String fruit : fruits) {
            System.out.println(fruit);
        }
    }
}

Hash Map

Hash Map is an ordered collection that stores key-value pairs.
Keys must be unique, but values can be duplicated.

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();

        // Adding key-value pairs
        map.put(1, "Apple");
        map.put(2, "Banana");
        map.put(3, "Orange");
        map.put(4, "Apple");  // duplicate value allowed

        // Accessing elements
        System.out.println("Value for key 2: " + map.get(2));

        // Iterating over HashMap
        for (Integer key : map.keySet()) {
            System.out.println(key + " -> " + map.get(key));
        }
    }
}

LinkedMap

LinkedHashMap is like a HashMap, but it maintains the insertion order of keys.

import java.util.LinkedHashMap;

public class Main {
    public static void main(String[] args) {
        LinkedHashMap<Integer, String> map = new LinkedHashMap<>();

        map.put(3, "Orange");
        map.put(1, "Apple");
        map.put(2, "Banana");
        map.put(4, "Apple"); // duplicate value allowed

        for (Integer key : map.keySet()) {
            System.out.println(key + " -> " + map.get(key));
        }
    }
}

Stream

A Stream is a sequence of elements from a data source (like a collection, array, or generator) that allows you to perform some operations.

import java.util.*;
import java.util.stream.*;

public class Main {
    public static void main(String[] args) {
        List<String> fruits = Arrays.asList("Apple", "Banana", "Orange", "Apple");

        // Stream example: filter and print unique fruits
        fruits.stream()
              .distinct()                // remove duplicates
              .filter(f -> f.startsWith("A")) // filter fruits starting with 'A'
              .forEach(System.out::println);  // print result
    }
}

Exception

An Exception in Java is an event that occurs during the execution of a program that disrupts the normal flow of instructions. it’s an error that happens while the program is running.

public class Main {
    public static void main(String[] args) {

        try {
            int response = 10 / 0;
            System.out.println(response);
        }catch (ArithmeticException e){
            System.out.println("Oops!, Error");
        }
    }

}

I/O

IO (Input/Output) in Java refers to the process of reading data from a source (input) and writing data to a destination (output).
Sources and destinations can be files, keyboards, memory, networks, etc.

import java.io.*;

public class Main {
    public static void main(String[] args) {
        String filePath = "C:\\Users\\CAPTAIN ENJOY\\Downloads\\JavaNote\\src\\text.txt";

        // Reading the file
        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            System.out.println("Read error: " + e.getMessage());
        }

        // Appending to the file
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath, true))) { // 'true' = append mode
            writer.newLine(); // optional: start on a new line
            writer.write("ner");
        } catch (IOException e) {
            System.out.println("Write error: " + e.getMessage());
        }
    }
}

Lambda

It's more like an arrow function in javaScript. it's an anonymous function.

(int a, int b) -> a + b       // returns sum
x -> x * 2                    // multiplies by 2
() -> System.out.println("Hi") // no parameters

Constants

The "final" keyword is used to declare constants.

public class Main {
    public static void main(String[] args) {

        final int MAX_ATTEMPTS = 909090;
        // MAX_ATTEMPTS = 200; // ❌ Will cause error
        System.out.println(MAX_ATTEMPTS);
    }
}

SOLID

SOLID is an acronym for five key principles of object-oriented design that make software more maintainable, flexible, and scalable.

S – Single Responsibility Principle (SRP)

A class should have only one reason to change, i.e., it should do one thing only.

Example:

Invoice class → only handles invoice data.

InvoicePrinter class → only handles printing invoices.

class UserService {
    void registerUser(User user) { /* ... */ }
}

class EmailService {
    void sendWelcomeEmail(User user) { /* ... */ }
}

Open/Closed Principle (OCP)

Software entities (classes, methods, modules) should be open for extension but closed for modification.

Open for extension → You should be able to add new functionality without changing existing code.
Closed for modification → You should not modify existing, tested code, because that risks introducing bugs.

// Payment interface (abstraction)
interface Payment {
    void pay(double amount);
}

// Existing class
class CreditCardPayment implements Payment {
    public void pay(double amount) {
        System.out.println("Paid " + amount + " with Credit Card");
    }
}

// Adding a new functionality: PayPal
class PayPalPayment implements Payment {
    public void pay(double amount) {
        System.out.println("Paid " + amount + " via PayPal");
    }
}

// Checkout class depends on abstraction
class Checkout {
    Payment payment;
    Checkout(Payment payment) { this.payment = payment; }
    void process(double amount) { payment.pay(amount); }
}

public class Main {
    public static void main(String[] args) {
        Checkout checkout1 = new Checkout(new CreditCardPayment());
        checkout1.process(100);

        Checkout checkout2 = new Checkout(new PayPalPayment()); // new payment type added WITHOUT changing existing Checkout class
        checkout2.process(200);
    }
}

### L - Liskov Substition Principle
Subtypes should replace base types without breaking the program.

java
class Bird { void fly() {} }
class Sparrow extends Bird {}
class Penguin extends Bird {} // Penguins cannot fly

Bird bird = new Sparrow(); // Works fine
Bird bird = new Penguin(); // Violates LSP if fly() is called


### I - Interface Segregation Principle
Don’t force classes to implement unnecessary methods.
Bad:

java
interface Animal{
void fly(); //Animal can't fly
}
interface Bird { void fly(); } //Good Interface



### D — Dependency Inversion Principle (DIP)
Depends on Abstraction not concrete class

java
interface Payment { void pay(); }

class CreditCardPayment implements Payment {
public void pay() { System.out.println("Paid with Credit Card"); }
}

class Checkout {
Payment payment;
Checkout(Payment payment) { this.payment = payment; }
void process() { payment.pay(); }
}

public class Main {
public static void main(String[] args) {
Checkout c = new Checkout(new CreditCardPayment());
c.process();
}
}