DEV Community: Harini

Difference Between ArrayList and LinkedList in Java

Harini — Wed, 10 Jun 2026 05:56:49 +0000

ArrayList and LinkedList are two commonly used classes in the Java Collections Framework. Both implement the List interface and allow duplicate elements while maintaining insertion order. However, they differ in how data is stored and how operations are performed.

ArrayList

ArrayList uses a dynamic array to store elements. It provides fast access to elements using indexes and is suitable when data retrieval is performed frequently.

Features of ArrayList

Uses a dynamic array internally.
Maintains insertion order.
Allows duplicate elements.
Fast random access using indexes.
Slower insertion and deletion in the middle of the list because elements need to be shifted.

LinkedList

LinkedList uses a doubly linked list to store elements. Each element is stored as a node containing data and references to the previous and next nodes.

Features of LinkedList

Uses a doubly linked list internally.
Maintains insertion order.
Allows duplicate elements.
Fast insertion and deletion operations.
Slower access to elements because it must traverse the list.

ArrayList vs LinkedList

Feature	ArrayList	LinkedList
Definition	A dynamic array implementation of the List interface.	A doubly linked list implementation of the List interface.
Data Storage	Stores elements in a dynamic array.	Stores elements as connected nodes.
Access Time	Fast access using index (O(1)).	Slower access because it traverses nodes (O(n)).
Insertion/Deletion	Slower in the beginning or middle because elements need to be shifted.	Faster because nodes can be added or removed without shifting elements.
Memory Usage	Uses less memory.	Uses more memory due to previous and next references.
Iteration	Generally faster for traversing elements.	Slightly slower than ArrayList.
Best Use Case	Frequent searching and accessing of elements.	Frequent insertion and deletion of elements.

When to Use ArrayList?

Use ArrayList when:

You frequently access elements using indexes.
Read operations are more common than insertions and deletions.
Better performance for searching and retrieving data is required.

Example:

ArrayList list = new ArrayList();
list.add("Java");
System.out.println(list.get(0));

When to Use LinkedList?

Use LinkedList when:

You frequently insert or remove elements.
Queue or Deque operations are required.
The application performs more updates than searches.

Example:

LinkedList list = new LinkedList();
list.addFirst("Java");
list.removeLast();

LinkedList in Java

Harini — Wed, 10 Jun 2026 05:56:26 +0000

LinkedList is a class in Java Collections Framework available in the java.util package.It stores data as nodes, where each node contains the element and links to the previous and next nodes.

The size of a LinkedList can increase or decrease automatically while the program is running.
It maintains the insertion order, meaning elements are stored in the order they are added.
It allows duplicate elements.
It provides faster insertion and deletion of elements compared to ArrayList, especially at the beginning or middle of the list.

Why LinkedList is Used?
LinkedList is preferred when:

1. Frequent Insertion

Adding elements in the middle or beginning is fast.

list.addFirst("Java");

2. Frequent Deletion

Removing elements does not require shifting other elements.

list.remove(2);

3. Queue and Deque Operations
LinkedList supports operations like:

addFirst()
addLast()
removeFirst()
removeLast()

Hence it can be used as:

Queue
Deque
Stack

What is a Doubly Linked List?
A Doubly Linked List is a type of linked list in which each node contains:

Data – the actual value stored.
Previous Reference (Prev) – points to the previous node.
Next Reference (Next) – points to the next node.

Because each node has links in both directions, we can traverse the list forward as well as backward.

Structure

NULL ← [10] ⇄ [20] ⇄ [30] ⇄ [40] → NULL

Each node contains:

[ Prev | Data | Next ]

For example:

[NULL | 10 | Address of 20]
[Address of 10 | 20 | Address of 30]
[Address of 20 | 30 | Address of 40]
[Address of 30 | 40 | NULL]

Advantages of Doubly Linked List

Supports forward and backward traversal.
Faster insertion and deletion compared to arrays.
Easy to implement Queue, Deque, and Browser History features.
No need to shift elements during insertion or deletion.

Disadvantages of Doubly Linked List

Requires extra memory to store the previous reference.
More complex than a singly linked list.
Accessing elements by index is slower because traversal is required.

ArrayList in Java

Harini — Fri, 05 Jun 2026 12:31:09 +0000

ArrayList is one of the most commonly used classes in Java's collections framework.It provides a dynamic array that can grow and shrink automatically as elements are added or removed. Unlike traditional arrays, you do not need to specify the size in advance.

ArrayList is part of the java.util package and implements the list interface.

Why do we need ArrayList?

In Java,array have a fixed size.Once an array is created,its size cannot be changed.

Limitations of Arrays

Fixed size.
Insertion and deletion are difficult.
No built-in methods for data manipulation.

To overcome these limitations,Java provides ArrayList,which offers:

Dynamic resizing
Easy insertion and deletion
Built-in utility methods

Features of ArrayList
1.Dynamic size

ArrayList automatically increases or decreases its capacity based on the number of elements.

2.Maintains insertion order

Elements are stored in the same order in which they are inserted.

3.Allows duplicate elements

Multiple identical values can be stored.

4.Random access

Elements can be accessed directly using their index.

5.Stores objects

ArrayList stores objects rather than primitive datatypes.Wrapper classes are used for primitives.

int -> Integer
double -> Double
char -> Character

Collections in Java

Harini — Fri, 05 Jun 2026 05:23:58 +0000

What is Collections Framework in Java?

The Java Collections Framework (JCF) is a set of classes and interfaces provided by Java to store, manage, and manipulate groups of objects efficiently.

Before Collections, developers mainly used arrays. Arrays have a fixed size and limited functionality. Collections provide dynamic storage and many built-in methods for handling data.

Package: java.util

Why is Collections Used?

Collections are used to:

Store multiple objects dynamically.
Perform searching, sorting, insertion, and deletion easily.
Reduce coding effort through built-in methods.
Improve code reusability and maintainability.
Handle large amounts of data efficiently.

Without Collections

int[] arr = new int[100];

Fixed size
Difficult to resize
Limited operations

With Collections

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

Dynamic size
Easy insertion and deletion
Rich utility methods

Advantages

Dynamic Size
Ready-Made Data Structures
Better Performance
Reusability and Maintainability

List Interface

A List stores elements in insertion order and allows duplicates.

Features

Ordered
Duplicate elements allowed
Index-based access

Set Interface

A Set stores unique elements only.

Features

No duplicates
Usually unordered
Faster searching

Map Interface

Map stores data as Key-Value pairs.
A key must be unique.

Features

Key-Value storage
Duplicate keys not allowed
Values can be duplicated

File Handling in Java

Harini — Thu, 04 Jun 2026 07:11:29 +0000

What is File Handling?

File Handling in Java is the process of creating, reading, writing, updating, and deleting files stored on a storage device such as a hard disk, SSD, or external drive.

Normally, data stored in variables exists only while the program is running. Once the program terminates, that data is lost. File handling enables applications to store data permanently so that it can be accessed even after the program has ended.

Java provides file handling support mainly through the java.io package and the modern java.nio.file package.

Why is File Handling Important?

File handling is used to:

Store application data permanently
Save user information
Generate reports
Maintain logs
Store configuration settings
Transfer data between applications
Read existing records from files
Backup important information

Without file handling, applications would have to rely solely on memory, causing all data to be lost when the application closes.

File Class in Java

The File class is the foundation of file handling in Java.

A File object represents a file or directory path in the file system. It provides methods to create, delete, rename, and retrieve information about files and directories.

Creating a File object does not create the actual file on disk. It simply creates an object that represents the path.

Common Methods of the File Class

1. createNewFile()

Creates a new empty file in the specified location.

Return Type

boolean

Returns

true if the file is created successfully.
false if the file already exists.

Exception

Throws IOException if an error occurs during file creation.

Purpose

Used when an application needs to create a new file before storing data.

2. exists()

Checks whether a file or directory exists.

Return Type

boolean

Returns

true if the file exists.
false if the file does not exist.

Purpose

Used before performing operations such as reading, writing, or deleting a file.

3. delete()

Deletes a file or an empty directory.

Return Type

boolean

Returns

true if deletion is successful.
false if deletion fails.

Purpose

Used to remove unnecessary files from the system.

4. getName()

Returns the name of the file or directory.

Return Type

String

Purpose

Used when displaying or processing file names.

5. getAbsolutePath()

Returns the complete path of a file.

Return Type

String

Purpose

Helps identify the exact location of a file in the system.

6. getCanonicalPath()

Returns the canonical path of a file.

Return Type

String

Purpose

Provides the unique and standardized file path after resolving relative references such as:

.
..

It removes ambiguities from the path.

7. length()

Returns the size of a file.

Return Type

long

Purpose

Used to determine file size in bytes.

8. canRead()

Checks whether the file has read permission.

Return Type

boolean

Returns

true if readable.
false otherwise.

Purpose

Used before reading file contents.

9. canWrite()

Checks whether the file has write permission.

Return Type

boolean

Returns

true if writable.
false otherwise.

Purpose

Used before writing data into a file.

10. canExecute()

Checks whether the file can be executed.

Return Type

boolean

Purpose

Commonly used for executable files and scripts.

11. isFile()

Checks whether the path represents a file.

Return Type

boolean

Returns

true if it is a file.
false otherwise.

Purpose

Helps distinguish files from directories.

12. isDirectory()

Checks whether the path represents a directory.

Return Type

boolean

Returns

true if it is a directory.
false otherwise.

Purpose

Used when working with folders.

13. mkdir()

Creates a single directory.

Return Type

boolean

Purpose

Used to create one folder.

14. mkdirs()

Creates multiple nested directories.

Return Type

boolean

Purpose

Creates all required parent directories automatically.

15. renameTo()

Renames a file or directory.

Return Type

boolean

Purpose

Used when changing file or folder names.

16. list()

Returns all files and folders inside a directory.

Return Type

String[]

Purpose

Used to retrieve directory contents.

17. listFiles()

Returns file objects representing all files and directories inside a folder.

Return Type

File[]

throw and throws in Java

Harini — Tue, 02 Jun 2026 06:11:22 +0000

Exception handling is an important feature in Java that helps developers manage runtime errors gracefully.

Two commonly used keywords in exception handling are:

throw
throws

Although they look similar, they serve different purposes.

What is `throw` in Java?

The throw keyword is used to explicitly create and throw an exception from a method or block of code.

Syntax

throw new ExceptionType("Error Message");

Example

public class ThrowExample {

public static void main(String[] args) {

    int marks = -10;

    if (marks < 0) {
        throw new ArithmeticException("Marks cannot be negative");
    }

    System.out.println("Valid Marks");
}

}

Output

Exception in thread "main"
java.lang.ArithmeticException: Marks cannot be negative

Key Points of `throw`

Used to explicitly throw an exception.
Followed by an exception object.
Throws only one exception at a time.
Can throw both checked and unchecked exceptions.
Used inside method body.

What is `throws` in Java?

The throws keyword is used in a method declaration to indicate that the method may throw one or more exceptions.

It informs the caller of the method that exception handling is required.

Syntax

returnType methodName() throws ExceptionType {
// code
}

Example

import java.io.IOException;

public class ThrowsExample {

static void readFile() throws IOException {
    throw new IOException("File not found");
}

public static void main(String[] args) {

    try {
        readFile();
    }
    catch(IOException e) {
        System.out.println(e.getMessage());
    }
}

}

Output

File not found

Key Points of `throws`

Used in method declaration.
Declares possible exceptions.
Can declare multiple exceptions.
Mainly used for checked exceptions.
Responsibility is passed to the caller.

Example Using Both `throw` and `throws`

import java.io.IOException;

public class Demo {

static void validateAge(int age) throws IOException {

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

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

public static void main(String[] args) {

    try {
        validateAge(15);
    }
    catch(IOException e) {
        System.out.println(e.getMessage());
    }
}

}

Output

Not eligible to vote

Explanation

throws IOException declares that the method may throw an IOException.
throw new IOException() actually creates and throws the exception.
The caller handles it using try-catch.

Difference Between `throw` and `throws`

Feature	throw	throws
Purpose	Explicitly throws an exception	Declares exceptions
Location	Inside method body	Method declaration
Followed By	Exception object	Exception class name
Number of Exceptions	One at a time	Multiple exceptions
Usage	To generate exception	To delegate exception handling
Keyword Type	Statement	Clause

Why Objects Are Passed as Arguments in Java – Complete Guide for Beginners

Harini — Fri, 29 May 2026 05:00:55 +0000

In Java, objects are often passed as arguments to methods. This is an important concept in Object-Oriented Programming (OOP) because it helps methods work with real-world data efficiently.

Before understanding why objects are passed as arguments, let us first understand what an object is.

What is an Object in Java?

An object is an instance of a class.

A class is like a blueprint, and an object is the real implementation created from that blueprint.

Example:

class Student {
    String name = "Harini";
    int mark = 90;
}

Here:

Student is a class
name and mark are data members
An object can be created using the new keyword

Student obj = new Student();

Now obj contains the data and behavior of the Student class.

Why Do We Pass Objects as Arguments?

Objects are passed as arguments mainly for the following reasons:

To access object data inside another method
To reduce code complexity
To modify object values
To achieve code reusability
To work with real-world applications efficiently

Let us understand each point in detail.

1. To Access Object Data Inside Another Method

When an object is passed to a method, the method can access all the variables and methods of that object.

Example

class Student {

    String name = "Harini";
    int mark = 90;
}

class Main {

    void display(Student s) {

        System.out.println("Student Name: " + s.name);
        System.out.println("Student Mark: " + s.mark);
    }

    public static void main(String[] args) {

        Student obj = new Student();

        Main m = new Main();

        m.display(obj);
    }
}

Output

Student Name: Harini
Student Mark: 90

Explanation

obj is an object of the Student class
The object is passed to the display() method
Inside the method, s receives the object reference
Using s.name and s.mark, we access the object's data

This allows methods to work directly with object information.

2. To Reduce Code Complexity

Instead of passing many individual variables, we can pass a single object.

Without Passing Object

display("Harini", 90, "Chennai", 12345);

If the class contains many fields, the method becomes difficult to manage.

With Passing Object

display(studentObj);

The entire data is available through the object.

Benefits

Cleaner code
Easy to read
Easy to maintain
Reduces parameter list size

3. To Modify Object Values

When an object is passed to a method, the method can modify the object's data.

Example

class Employee {

    int salary = 20000;
}

class Main {

    void increaseSalary(Employee e) {

        e.salary = 30000;
    }

    public static void main(String[] args) {

        Employee emp = new Employee();

        Main m = new Main();

        System.out.println("Before Increment: " + emp.salary);

        m.increaseSalary(emp);

        System.out.println("After Increment: " + emp.salary);
    }
}

Output

Before Increment: 20000
After Increment: 30000

Explanation

The original object is passed to the method
The method changes the salary
Since both references point to the same object, the original value changes

How Java Passes Objects

This is one of the most important interview concepts.

Java does NOT pass the actual object.

Java passes the reference of the object by value.

What Does "Reference by Value" Mean?

When an object is created:

Student obj = new Student();

obj stores the memory address (reference) of the object
When passed to a method, Java copies this reference

Example:

display(obj);

Now:

obj and method parameter s point to the same object in memory

That is why object data can be modified inside methods.

Memory Representation

obj  --------->  Student Object
                     name = Harini
                     mark = 90

s    --------->  Same Student Object

Both references point to the same object.

Exception Handling in Java

Harini — Fri, 22 May 2026 04:45:21 +0000

What is an Exception?

An exception is an event that disrupts the normal execution of a program.

Example:

int a = 10 / 0;

Output:

ArithmeticException

Here, dividing by zero causes an exception.

Exception Handling

Exception handling is a mechanism used to handle runtime errors so the program does not terminate suddenly.

It allows the program to continue execution normally.

Why Exception Handling is Used

Without exception handling:

Program stops immediately when an error occurs.

With exception handling:

Error can be handled properly.
Remaining code can continue executing.

Example:

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

        System.out.println("Start");

        int a = 10 / 0;

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

Output
Start Exception in thread "main" java.lang.ArithmeticException

End will not execute.

try-catch in Java

try-catch is used to handle exceptions.

Syntax

try {
    // risky code
}
catch(ExceptionType e) {
    // handling code
}

Example of try-catch

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

        try {
            int a = 10 / 0;
        }

        catch(ArithmeticException e) {
            System.out.println("Cannot divide by zero");
        }

        System.out.println("Program continues");
    }
}

Output:

Cannot divide by zero Program continues

Real-Time Example

ATM application:

If wrong PIN is entered,program should show error message instead of stopping.
Banking apps, websites, and mobile apps use exception handling to avoid crashes.

String in Java

Harini — Tue, 19 May 2026 13:22:05 +0000

The String in Java is a sequence of characters used to store and manipulate text.It is one of the most used classes in Java.

Each character in a string is stored using 16-bit Unicode (UTF-16) encoding.
Strings are immutable, meaning their value cannot be changed after creation.

Example

String str = "Hello";

str.concat(" World");

System.out.println(str);

Output
Hello

Because concat() creates a new string instead of modifying the old one.

Ways to Create String

1. String Literal

Example:1

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

        String name = "Harini";

        System.out.println(name);
    }
}

Output
Harini

Why is this called String Literal?

String name = "Harini";

"Harini" → String literal
It is directly written inside double quotes.
Java stores it inside the String Constant Pool.

Example: 2

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

        String a = "Java";
        String b = "Java";

        System.out.println(a == b);
    }
}

Output:
true

Because both a and b point to the same object in the String pool.

String Pool

Java stores string literals in a special memory area called the String Constant Pool.

2. Using new Keyword

Example

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

        String s1 = new String("Java");
        String s2 = new String("Java");

        System.out.println(s1);
        System.out.println(s2);

        System.out.println(s1 == s2);
        System.out.println(s1.equals(s2));
    }
}

Output
Java Java false true

Creating String using new

String s1 = new String("Java");

new keyword creates a new object
Object is created in heap memory
Even if "Java" already exists, Java creates another new object

Same for:

String s2 = new String("Java");

So s1 and s2 are different objects.

Why s1 == s2 is false?

System.out.println(s1 == s2);

Output:

false

Because:

== compares memory address/reference
s1 and s2 are different objects in memory

Why s1.equals(s2) is true?

System.out.println(s1.equals(s2));

Output:

true

Because:

equals() compares actual content
Both strings contain "Java"

Memory Representation

String s1 = new String("Java");
String s2 = new String("Java");

Heap Memory

s1 ---> "Java" (Object 1)

s2 ---> "Java" (Object 2)

Two separate objects are created.

Abstraction in Java

Harini — Thu, 14 May 2026 05:46:50 +0000

Abstraction in Java is a core concept of Object-Oriented Programming (OOP). It means hiding unnecessary implementation details and showing only the essential features of an object.

Abstraction focuses on what an object does instead of how it does it.

Example:
When you drive a car, you use the steering wheel, accelerator, and brakes — you don’t need to know how the engine works internally.

How Abstraction is Achieved in Java

In Java, abstraction is implemented using:

Abstract Classes
- Declared using the keyword abstract
- Can have:
- Abstract methods (no body)
- Concrete methods (with body)

abstract class Animal {
    abstract void sound(); // abstract method

    void eat() {
        System.out.println("This animal eats food");
    }
}

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

2. Interfaces

Used for 100% abstraction (traditionally)
All methods are abstract by default (until Java 8 added default methods)

interface Vehicle {
    void start();
}

class Car implements Vehicle {
    public void start() {
        System.out.println("Car starts with a key");
    }
}

Key Points

You cannot create objects of abstract classes directly.
Interfaces support multiple inheritance, while classes do not.
Abstraction helps in:
- Reducing complexity
- Increasing code reusability
- Improving security (hiding data)

Difference from Encapsulation

Abstraction → Hides implementation details
Encapsulation → Hides data (using private variables and getters/setters)

Final Keyword in java

Harini — Thu, 14 May 2026 05:30:02 +0000

In Java, the final keyword is used to restrict changes. Once something is marked as final, it cannot be modified further. It can be applied in three main places: variables, methods, and classes.

1. Final Variable

A final variable acts like a constant — its value cannot be changed once assigned.

public class GRT{
    final int price = 15000;

    public void display(){
        GRT grt = new GRT();
        grt.price = 200;

        System.out.println(grt.price);
    }
}

Key point:

You must assign value once
After that, no reassignment allowed

2. Final Method
A final method cannot be overridden by subclasses.

class Parent {
    final void show() {
        System.out.println("This is final method");
    }
}

class Child extends Parent {
    // void show() { } ❌ Error: cannot override final method
}

Key point:

Used when you want to prevent method overriding

3. Final Class
A final class cannot be extended (inherited).

final class A {
    void display() {
        System.out.println("Final class");
    }
}

// class B extends A { } ❌ Error: cannot inherit final class

Key point:

Used when you want to stop inheritance

POJO in Java

Harini — Tue, 12 May 2026 05:09:47 +0000

What is a POJO?

POJO stands for Plain Old Java Object. It is a term used to describe a simple Java class that follows basic coding conventions and does not depend on any specific frameworks or external libraries.
In simple words, a POJO is just a normal Java object created to hold and manage data in a clean and straightforward way.

Key Features of a POJO

A typical POJO usually includes:

Private variables (fields) to store data
Public getter and setter methods to access and update those fields
Optional methods for additional behavior (like toString())

It may also have:

A no-argument constructor
A parameterized constructor

Properties of a POJO
A class is considered a POJO if it does not:

Extend any predefined class (e.g., HttpServlet, EntityBean, etc.)
Implement any predefined interface (e.g., javax.ejb.EntityBean)
Contain framework-specific annotations (e.g., @entity, @Component)

Example

public class Employee {

    private int id;
    private String name;

    // Default constructor
    public Employee() {}

    // Parameterized constructor
    public Employee(int id, String name) {
        this.id = id;
        this.name = name;
    }

    // Getter
    public int getId() {
        return id;
    }

    // Setter
    public void setId(int id) {
        this.id = id;
    }

    // Getter
    public String getName() {
        return name;
    }

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

What is a JavaBean?

A JavaBean is a special type of POJO that follows a set of strict rules (conventions). It is mainly used to encapsulate data and make it reusable across applications.

Every JavaBean is a POJO, but not every POJO is a JavaBean.

Rules for a JavaBean

Must implement the Serializable interface.
Must have a no-argument constructor.
All fields must be private.
Each property should have corresponding getter and setter methods.
Fields must be accessed only through these methods (not directly).

This design provides encapsulation and controlled access to object properties.

DEV Community: Harini

Difference Between ArrayList and LinkedList in Java

ArrayList

Features of ArrayList

LinkedList

Features of LinkedList

ArrayList vs LinkedList

When to Use ArrayList?

When to Use LinkedList?

LinkedList in Java

ArrayList in Java

Collections in Java

File Handling in Java

What is File Handling?

Why is File Handling Important?

File Class in Java

Common Methods of the File Class

1. createNewFile()

Return Type

Returns

Exception

Purpose

2. exists()

Return Type

Returns

Purpose

3. delete()

Return Type

Returns

Purpose

4. getName()

Return Type

Purpose

5. getAbsolutePath()

Return Type

Purpose

6. getCanonicalPath()

Return Type

Purpose

7. length()

Return Type

Purpose

8. canRead()

Return Type

Returns

Purpose

9. canWrite()

Return Type

Returns

Purpose

10. canExecute()

Return Type

Purpose

11. isFile()

Return Type

Returns

Purpose

12. isDirectory()

Return Type

Returns

Purpose

13. mkdir()

Return Type

Purpose

14. mkdirs()

Return Type

Purpose

15. renameTo()

Return Type

Purpose

16. list()

Return Type

Purpose

17. listFiles()

Return Type

throw and throws in Java

What is throw in Java?

Syntax

Example

Output

What is `throw` in Java?

Key Points of `throw`

What is `throws` in Java?

Key Points of `throws`

Example Using Both `throw` and `throws`

Difference Between `throw` and `throws`