DEV Community: KIRAN RAJ

Maven & MVC in Spring Boot

KIRAN RAJ — Tue, 05 May 2026 17:44:38 +0000

Maven & MVC in Spring Boot — how I actually understood it

When I started Spring Boot, I kept hearing two words again and again -Maven and MVC.

At that time I didn’t really get it.
Still, I didn’t ask… just went with the flow thinking it’ll make sense later.
This is basically what I undeThat’s pretty much it.understood after struggling a bit.

Maven first.

When you create a Java project, you don’t just write code and run it.
You need other stuff — Spring Boot, database drivers, some libraries.
Initially I thought I could handle it manually. Download jars, add them, done.
It works, but only for some time.
After that, small problems start:
wrong versions, something not working, no idea what went wrong.
That’s where Maven helps.
You just write everything in one file (pom.xml).
After that, it takes care of the rest — downloading, managing versions, building.
You don’t really “see” Maven working.
It just does things in the background.
After a point, you stop thinking about it completely.

Now MVC.

Before this, I used to write everything in one place.
Controller, logic, data… all mixed.
It was okay for small code, but once it got bigger, it became confusing.
MVC just separates things. That’s it.

Controller — where the request comes.

If you hit something like /users, it reaches the controller first.
Controller won’t do everything.
It just decides what should happen next and passes it.

Model — your data.

Like a User: id, name.
Nothing complicated.
Just represents what you’re working with.

View — what goes back.

In most cases, it’s just JSON.
User asks → you send data → done.

What made it clear for me was this:

request → controller → process → response
That’s the whole flow.
I was overthinking it before.

One simple way I remember it:

like ordering food.

You talk to waiter → controller
Waiter goes inside → model
Food comes back → view You never go to the kitchen.
Same thing here.

*One mistake I made — I thought Maven and MVC are related.
*
They’re not.

MVC is about how you write code.
Maven is just there handling dependencies and setup.

That’s pretty much it.

Honestly, reading won’t make it fully click.
Try a small API, return some data… then it makes sense.

ArrayList vs LinkedList in Java

KIRAN RAJ — Tue, 28 Apr 2026 18:04:46 +0000

ArrayList vs LinkedList in Java (Easy Explanation)

When learning Java Collections, one common doubt is:
“Should I use ArrayList or LinkedList?”

Both are part of the List interface. Both store data in order.
But internally, they work in completely different ways — and that changes performance.

ArrayList – How it works

An ArrayList is a resizable array.

Elements are stored next to each other (continuous memory)
Each element has an index (0, 1, 2…)
You can directly access any element using the index

Example:

ArrayList<Integer> list = new ArrayList<>();
list.add(10);
list.add(20);
list.add(30);

System.out.println(list.get(1)); // 20

Real-world feel:
Like selecting a song by number in a playlist — instant access

LinkedList – How it works

A LinkedList is a chain of nodes connected together.

Each node contains:

Data
Reference to next node
Reference to previous node
Elements are not stored together
To access an element, it moves step by step

Example:

LinkedList<Integer> list = new LinkedList<>();
list.add(10);
list.add(20);
list.addFirst(5);

System.out.println(list);

Real-world feel:
Like standing in a queue — you move one step at a time

Key Differences

Feature	ArrayList	LinkedList
Storage	Continuous	Non-continuous
Access	Fast (O(1))	Slow (O(n))
Insert/Delete	Slow (shifting)	Fast (no shifting)
Memory	Less	More

Easy Way to Remember

ArrayList → Like seats in a theater
If one person leaves, others shift
LinkedList → Like people holding hands
Remove one, just reconnect

When to Use

Use ArrayList when:

You read/access data frequently
You need fast get() operations
Insert/delete is rare

Use LinkedList when:

You frequently insert/delete
Especially at beginning or middle
Access speed is not important

Final Thought

There is no “better” one.

Need fast access → go with ArrayList
Need easy modification → go with LinkedList

It all depends on how you use your data.

Comparable Interface in Java

KIRAN RAJ — Mon, 20 Apr 2026 17:01:53 +0000

Comparable Interface in Java

In Java, the Comparable interface is used to compare objects and define their natural ordering.

Examples:

Comparing students based on marks

Comparing products based on price

Sorting strings alphabetically

Why Do We Need Comparable?

Primitive values like int or double can be compared easily.
But for custom objects like Student or Employee, Java does not know how to compare them by default.

So, we define the comparison logic using the Comparable interface.

Definition

public interface Comparable<T> {
    int compareTo(T o);
}

The key method is compareTo().

*How compareTo() Works
*
Returns a negative value → current object is smaller

Returns 0 → both objects are equal

Returns a positive value → current object is greater

This is the basis for sorting.

Example: Sorting Students by Marks

import java.util.*;

class Student implements Comparable<Student> {
    int marks;
    String name;

    Student(String name, int marks) {
        this.name = name;
        this.marks = marks;
    }

    public int compareTo(Student s) {
        return this.marks - s.marks; // ascending order
    }
}

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

        list.add(new Student("A", 80));
        list.add(new Student("B", 60));
        list.add(new Student("C", 90));

        Collections.sort(list);

        for (Student s : list) {
            System.out.println(s.name + " " + s.marks);
        }
    }
}

Output:

B 60
A 80
C 90

Key Points

Comparable defines natural (default) ordering

It is implemented inside the class

Collections.sort() automatically uses it

You must override compareTo()

Comparable vs Comparator

Comparable	Comparator
Implemented inside the class	Implemented in a separate class
Only one sorting logic	Multiple sorting logics possible
Uses compareTo()	Uses compare()

Simple Analogy

Comparable: the object decides how it should be compared
Comparator: an external logic decides how objects are compared

Final Line

The Comparable interface allows you to define a default sorting behavior for your objects.

ArrayList Methods in Java

KIRAN RAJ — Sun, 19 Apr 2026 18:15:27 +0000

ArrayList Methods in Java

When I first started learning Java, arrays were a bit confusing because of fixed size. Then I came across ArrayList, and it felt much easier to use.

Basically, ArrayList is like an improved version of array. You don’t need to decide the size before. It grows when you add data.

What is ArrayList?

ArrayList is a class in Java used to store multiple values. It allows duplicate values and keeps order.

In simple terms,
it is just a dynamic array.

Creating an ArrayList

import java.util.ArrayList;

ArrayList<String> list = new ArrayList<>();

Methods I used the most

add()

This is the first method everyone uses. It just adds elements.

list.add("Apple");
list.add("Banana");

Also we can add using index:

list.add(1, "Mango");

get()

Used to take value from list.

System.out.println(list.get(0));

Index starts from 0, same like array.

set()

If you want to change something:

list.set(1, "Orange");

It replaces the old value.

remove()

Used to delete.

list.remove(0);
list.remove("Apple");

Both ways will work.

size()

To know how many elements are there:

System.out.println(list.size());

contains()

Sometimes we need to check if item is present.

System.out.println(list.contains("Banana"));

isEmpty()

Simple check:

System.out.println(list.isEmpty());

clear()

Deletes everything.

list.clear();

Looping

Normal for loop:

for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

For-each (easy one):

for (String s : list) {
    System.out.println(s);
}

Small program I tried

import java.util.ArrayList;

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

        ArrayList<String> list = new ArrayList<>();

        list.add("Tea");
        list.add("Coffee");
        list.add("Boost");

        list.remove("Coffee");

        for (String s : list) {
            System.out.println(s);
        }
    }
}

Final

ArrayList is very useful. Once you start using it, you won’t feel like going back to arrays for most cases.

At first I just memorized methods, but later when I practiced, it became easy.

That’s it. Nothing big. Just practice

ArrayList vs LinkedList in Java

KIRAN RAJ — Sat, 18 Apr 2026 04:53:43 +0000

ArrayList vs LinkedList in Java

I used to think ArrayList and LinkedList are basically the same thing.
Because when you’re coding, both feel similar — you just call add(), get(), and move on.

But after using them a bit more, the difference starts to show. Not immediately, but when the list gets bigger or when you keep modifying it.

ArrayList

ArrayList is kind of like a normal array, but it grows automatically.

So everything is stored in order, one next to another. Because of that, accessing elements is quick.
If you know the index, you’ll get the value instantly.

The only thing is, inserting or deleting in between isn’t that smooth.
Other elements need to shift, so it takes some extra work internally.

ArrayList<Integer> list = new ArrayList<>();
list.add(10);
list.add(20);
System.out.println(list.get(1));

LinkedList

LinkedList works differently. It doesn’t store elements in a continuous way.

Each element is connected to the next one (and previous too). So it’s more like a chain.

Because of this, inserting or removing elements is easier — it just updates the links.
But accessing is slower, since it has to go step by step.

LinkedList<Integer> list = new LinkedList<>();
list.add(10);
list.add(20);
System.out.println(list.get(1));

What I understood

Instead of remembering all details, I just think like this:

If I need fast access → I use ArrayList
If I keep adding/removing → LinkedList makes more sense

That’s how I usually decide.

In practice

Most of the time, I end up using ArrayList. It’s simple and works fine for general cases.

LinkedList is useful, but I don’t reach for it unless there’s a clear reason.

Final note
Both are part of the same interface, but they behave differently inside.

So choosing one depends on what your program is doing more — reading or modifying.

Java Collections Framework

KIRAN RAJ — Thu, 16 Apr 2026 19:37:10 +0000

Java Collections Framework

Java Collections Framework is used to store and manage a group of objects in an easy way.

Instead of creating everything from scratch, Java already gives ready-made classes like ArrayList, HashSet, and HashMap. We can directly use them.

1. What is a Collection?

A collection means a group of data.
For example, storing multiple names or numbers together.

2. Why do we use Collections?

Before collections:

If we want to store many values, we had to create many variables → confusing

Then arrays came → better, but still not perfect

Problems with arrays:

Size is fixed

Memory can be wasted

Not flexible

So Java introduced Collections to solve these issues.

3. Advantages (Simple way)

No need to write your own data structures

Works faster (already optimized)

Can reuse in many programs

Easy to learn (same pattern – List, Set, Map)

Code looks clean and simple

Size can increase or decrease anytime

Extra help methods like sorting and searching available

Java File Handling

KIRAN RAJ — Tue, 07 Apr 2026 15:51:04 +0000

Java File Handling

What I understood about File Handling

When I started learning Java, one thing I noticed is that data inside a program does not stay forever. Once the program stops, everything is gone. Because of that, we use files to store data.

So, file handling is basically working with files like creating them, writing something into them, reading the content later, and sometimes deleting them.

File Class (Basic Idea)

In Java, we usually use the File class from the java.io package. It is mainly used to refer to a file path.

One small confusion I had at first was thinking it creates a file directly. But actually, it just creates an object that points to a location.

import java.io.File;

public class Test {
    public static void main(String[] args) {
        File myFile = new File("data.txt");
        System.out.println("Just created a reference, not the actual file");
    }
}

Creating the File

To actually create the file in the system, we use createNewFile().

import java.io.File;
import java.io.IOException;

public class FileCreate {
    public static void main(String[] args) {
        try {
            File myFile = new File("data.txt");

            if (myFile.createNewFile()) {
                System.out.println("New file created");
            } else {
                System.out.println("File already exists");
            }

        } catch (IOException e) {
            System.out.println("Something went wrong while creating file");
        }
    }
}

Writing into the File

To write something into the file, we can use FileWriter. One important thing is to close it after writing.

import java.io.FileWriter;

public class FileWrite {
    public static void main(String[] args) {
        try {
            FileWriter writer = new FileWriter("data.txt");

            writer.write("This is just a practice example.");
            writer.close();

            System.out.println("Writing done");

        } catch (Exception e) {
            System.out.println("Error while writing");
        }
    }
}

Reading the File

For reading, I used Scanner because it is easy to understand. It reads line by line.

import java.io.File;
import java.util.Scanner;

public class FileRead {
    public static void main(String[] args) {
        try {
            File myFile = new File("data.txt");
            Scanner sc = new Scanner(myFile);

            while (sc.hasNextLine()) {
                System.out.println(sc.nextLine());
            }

            sc.close();

        } catch (Exception e) {
            System.out.println("Could not read the file");
        }
    }
}

Deleting the File

If the file is not needed, we can delete it using delete().

import java.io.File;

public class FileDelete {
    public static void main(String[] args) {
        File myFile = new File("data.txt");

        if (myFile.delete()) {
            System.out.println("File deleted successfully");
        } else {
            System.out.println("Delete failed");
        }
    }
}

Streams (Just Basic Understanding)

While reading about this, I found that Java uses streams internally.

Byte streams - used for images or other binary data

Character streams - used for text

Some classes I came across are FileReader and FileWriter.

Errors I Faced

While trying these programs, I got errors like file not found and sometimes permission issues. Using try-catch helped me handle those errors.

Conclusion (My Understanding)

File handling is simple once we practice it. At first it felt confusing, but after trying examples, it became clear how Java works with files.

I feel practicing small programs is the best way to understand this topic.

Java File Handling

KIRAN RAJ — Mon, 06 Apr 2026 05:46:22 +0000

What is File Handling?

File Handling in Java is the process of creating, reading, writing, updating, and deleting files using Java programs.

👉 It helps programs to store data permanently instead of only in memory.

📁 What is a File?

A file is a collection of data stored in a storage device (like hard disk).

👉 Examples:

notes.txt
data.pdf
image.jpg

📂 What is a Directory (Folder)?

A directory (folder) is a container used to store files and other folders.

👉 Example:

Documents/
   ├── notes.txt
   ├── resume.pdf
   └── Images/

⚙️ What is the File Class?

The File class in Java is used to:

Create files
Check file properties
List files and folders
Delete files

👉 It belongs to:

java.io package

🔑 Important Methods (Definition)

createNewFile() → Creates a new file
listFiles() → Lists all files in a directory
isFile() → Checks if it is a file
isDirectory() → Checks if it is a folder
getName() → Returns file/folder name
delete() → Deletes a file

🔤 String Methods Used in File Handling

👉 File handling often uses String methods:

toLowerCase() → ignore case
endsWith() → check file type
substring() → extract extension
lastIndexOf() → find extension position

💾 Why File Handling is Important?

Store data permanently
Read/write application data
Work with system files
Used in real-world apps (logs, configs, reports)

Short Conclusion

File handling is a core concept in Java that allows developers to interact with system files and build practical applications.

Java Exception Handling – 20 Scenarios Q&A

KIRAN RAJ — Sat, 04 Apr 2026 04:29:27 +0000

Java Exception Handling – 20 Real-Time Scenarios Explained

Introduction

Exception handling in Java helps developers manage runtime errors and keep applications stable. Let’s understand all key concepts through real-time scenarios.

1.What is an Exception?

While running your app, a calculation crashes.

✔ Answer: Runtime error

2.How to Handle Exceptions?

You want to prevent app crash.

✔ Answer: Use try, catch, and throw

3.Root Class of Exceptions

You want to know the parent of all exceptions.

✔ Answer: Throwable

4.Code That Always Runs

You want cleanup code to always execute.

✔ Answer: finally

5.Divide by Zero

User enters 0 in division.

✔Answer: ArithmeticException

6.Checked Exception

File reading operation.

✔ Answer: IOException

7.Not Handling Exception

You ignore exception.

✔Answer: Program terminates

8.Correct Block Order

Writing try-catch-finally.

✔ Answer: try → catch → finally

9.Manually Throw Exception

Validate input and throw error.

✔ Answer: throw

10. Declare Exception

Inform method may throw exception.

✔ Answer: throws

11.Arithmetic Exception Handling

Division by zero inside try.

✔ Answer: "Error" printed

12.Null Value Access

Access method on null.

✔ Answer: "Handled" printed

13.Wrong Catch Order

Parent class before child class.

✔ Answer: Wrong order

14.Array Index Error

Access invalid index.

✔ Answer: "Out of bounds"

15.System.exit() Case

Program exits forcefully.

✔ Answer: finally will NOT execute

16.Try Without Catch

Writing only try block.

✔ Answer: Only valid with finally

17.Unchecked Exception

Runtime error (null access).

✔ Answer: NullPointerException

18.Exception Propagation

Method doesn’t handle exception.

✔ Answer: Passed to caller

19.Who Handles Exception?

Which block manages error.

✔ Answer: catch

20.Purpose of Finally

Cleanup operations needed.

✔ Answer: Execute cleanup code

21.Student Result Validation

Marks must be between 0–100

if(marks < 0 || marks > 100){
    throw new IllegalArgumentException("Invalid marks");
}

22: Checked vs Unchecked

👉 Use:

Checked → external issues

Unchecked → coding mistakes

23.Finally Not Executed

System.exit(0) → finally skip

Final Summary

Exception = runtime error

try-catch = handle

finally = cleanup

throw = create

throws = declare

propagation = pass to caller

Exception Handling In Java(Complete Guide with Examples)

KIRAN RAJ — Fri, 03 Apr 2026 04:35:31 +0000

Exception Handling in Java

- Introduction

Exception handling is a powerful mechanism in Java that helps developers manage runtime errors and maintain the normal flow of applications. Instead of crashing the program, Java allows you to handle unexpected situations gracefully using structured blocks like try, catch, and finally.

1.What is an Exception?

An exception is an error that occurs during the execution of a program (runtime error).

👉 Example:

int a = 10;
int b = 0;
int c = a / b; // ArithmeticException

2.Types of Exceptions

✅ Checked Exceptions

Checked at compile time
Must be handled using try-catch or throws
Example: IOException, SQLException

❌ Unchecked Exceptions

Occur at runtime
Not mandatory to handle
Example: NullPointerException, ArithmeticException

3.Important Keywords

Wraps code that may cause an exception.

catch

Handles the exception.

finally

Always executes (except when JVM stops).

throw

Used to explicitly throw an exception.

throws

Declares exceptions in a method signature.

4.Order of Execution

Correct order:

try → catch → finally

5.Common Exceptions

Divide by zero → ArithmeticException
Null value access → NullPointerException
Invalid array index → ArrayIndexOutOfBoundsException

6.Exception Propagation

Exception propagation means passing an exception from one method to another until it is handled.

void method1() {
    int x = 10 / 0;
}

void method2() {
    method1();
}

void method3() {
    try {
        method2();
    } catch (Exception e) {
        System.out.println("Handled");
    }
}

Code Examples

7.Handling Exception

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

8.Null Handling

try {
    String s = null;
    System.out.println(s.length());
} catch (Exception e) {
    System.out.println("Handled");
}

9.Throw Example

if(marks < 0 || marks > 100){
    throw new IllegalArgumentException("Invalid marks");
}

10.SpecialCase:System.exit()

try {
    System.exit(0);
} finally {
    System.out.println("Finally");
}

Output: Finally will NOT execute

Reason: JVM stops immediately.

11. Purpose of Finally Block

Used for cleanup operations:

Closing files

Releasing resources

Closing database connections

12.Important Rules

try cannot exist alone

Must be followed by catch or finally

catch blocks must be ordered from specific → general

Parent class (Exception) should come last

13.Quick Summary

Exception = Runtime error

try-catch = Handle errors

finally = Cleanup

throw = Create exception

throws = Declare exception

Propagation = Passing exception to caller

14.Conclusion

Exception handling is essential for building robust Java applications. By using proper handling techniques, developers can prevent crashes, improve user experience, and write clean, maintainable code.

Java Exception Handling:Understanding throw vs throws

KIRAN RAJ — Wed, 01 Apr 2026 18:02:03 +0000

Exception Handling in Java: throw vs throws

When writing Java programs, errors can happen anytime — like dividing by zero, invalid input, or file issues.
To handle these situations properly, Java provides exception handling.

Two important keywords in Java exception handling are:

throw
throws

1.What is an Exception?

An exception is an unwanted event that stops the normal flow of a program.

Example:

int a = 10;
int b = 0;
int result = a / b; // ArithmeticException

2.What is throw in Java?

throw is used to manually create and throw an exception.

It is used inside a method.

✅ Syntax:

throw new ExceptionType("Error message");

✅ Example:

public class Test {
    public static void main(String[] args) {
        int age = 15;

        if(age < 18){
            throw new ArithmeticException("Not eligible to vote");
        }

        System.out.println("Eligible");
    }
}

Explanation:

If condition is true → exception is thrown manually

Program stops unless handled

What is throws in Java?

throws is used to declare exceptions that a method might throw.

It is used in method signature.

✅ Syntax:

returnType methodName() throws ExceptionType

✅ Example:

import java.io.*;

public class Test {
    public static void readFile() throws IOException {
        FileReader file = new FileReader("test.txt");
    }

    public static void main(String[] args) {
        try {
            readFile();
        } catch(IOException e){
            System.out.println("File not found");
        }
    }
}

Explanation:

throws tells the compiler: "This method may cause an exception"

The caller must handle it using try-catch

4. Difference Between throw and throws

Feature throw throws

Usage Used to throw exception Used to declare exception
Location Inside method Method signature
Number Only one exception at a time Multiple exceptions allowed
Keyword Type Statement Declaration

💡 Real-Life Analogy

throw 👉 You actually throw a ball

throws 👉 You warn someone that you may throw a ball

5.When to Use?

✔ Use throw

When you want to create custom error conditions

For validation (age, input, etc.)

✔ Use throws

When method might cause checked exceptions

When you want caller to handle exception

Advantages Of Exception Handling

KIRAN RAJ — Mon, 30 Mar 2026 07:35:22 +0000

Advantages of Exception Handling in Java

Exception handling is a powerful mechanism in Java that allows developers to manage runtime errors efficiently. Instead of crashing the program, it helps maintain the normal flow of execution and improves the overall reliability of applications.

1. Maintains Normal Flow of Program

Without exception handling, a program stops abruptly when an error occurs. Using try-catch, you can handle errors and continue execution smoothly.

try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Cannot divide by zero");
}
System.out.println("Program continues...");

2. Prevents Program Crashes

Exception handling prevents unexpected termination of programs. It catches runtime errors and handles them gracefully.

👉 Example:

Without handling → Program crashes
With handling → Error message shown, program continues

3. Separates Error Handling Code

It separates normal code from error-handling code, making programs more readable and maintainable.

try {
    // main logic
} catch (Exception e) {
    // error handling logic
}

4. Improves Code Readability

When exceptions are handled properly, the code becomes easier to understand and debug.

Clean structure
Organized logic
Better debugging

5. Allows Custom Error Messages

Developers can display meaningful error messages instead of confusing system errors.

catch (NumberFormatException e) {
    System.out.println("Please enter a valid number");
}

🔹 6. Supports Multiple Exception Types

Java allows handling different exceptions separately using multiple catch blocks.

try {
    int arr[] = new int[5];
    arr[10] = 50;
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Array index error");
} catch (Exception e) {
    System.out.println("General error");
}

7. Ensures Resource Cleanup

The finally block ensures that important resources (like files, database connections) are always closed.

finally {
    System.out.println("Closing resources...");
}

8. Enables Robust and Secure Applications

Exception handling helps build strong applications that can handle unexpected situations without failing.

9. Helps in Debugging

Using e.printStackTrace() or logs, developers can easily identify where the error occurred.

catch (Exception e) {
    e.printStackTrace();
}