DEV Community: Harini

Applet, Servlet, and JSP in Java

Harini — Thu, 25 Jun 2026 15:24:29 +0000

What is Applet?

An Applet is a small Java program that runs inside a web browser or an applet viewer. It was mainly used to create interactive web applications but is now obsolete because modern browsers no longer support it.

Features

Runs on the client side.
Extends the Applet class.
No main() method.
Uses lifecycle methods like init(), start(), stop(), and destroy().

Note: Applets are no longer used in modern Java web development.

What is Servlet?

A Servlet is a server-side Java program that handles client requests and generates dynamic web content. It runs inside a web server such as Apache Tomcat.

Features

Runs on the server.
Handles HTTP requests and responses.
Improves performance by using multithreading.
Extends HttpServlet.

Servlet Lifecycle

init() – Initializes the servlet.
service() – Processes client requests.
destroy() – Cleans up resources before removal.

Advantages

Fast and efficient.
Platform-independent.
Secure and scalable.
Supports session management.

What is JSP (JavaServer Pages)?

JSP (JavaServer Pages) is a server-side technology used to create dynamic web pages by embedding Java code inside HTML.

Features

Simplifies web page development.
Automatically converted into a servlet by the server.
Supports HTML, CSS, JavaScript, and Java.
Ideal for displaying dynamic data.

JSP Lifecycle

Translation into a Servlet.
Compilation.
Initialization (jspInit()).
Request Processing (_jspService()).
Destruction (jspDestroy()).

Advantages

Easy to write and maintain.
Reduces Java code in web pages.
Reusable using JSP tags and Expression Language (EL).
Better separation of presentation and business logic.

Spring and its Features

Harini — Wed, 24 Jun 2026 07:11:20 +0000

What is Spring?

Spring is a powerful, lightweight, open-source Java framework used to build enterprise-level applications. It simplifies Java development by providing built-in support for dependency management, database access, web applications, security, transactions, and microservices.

Why was Spring introduced?

Before Spring, developers mainly used Enterprise JavaBeans (EJB) for enterprise applications.

Problems with EJB:

Complex configuration
Heavyweight framework
Difficult to test
Required application servers

Spring solved these problems by providing:

Lightweight architecture
POJO (Plain Old Java Object) programming
Easy testing
Flexible configuration
Better performance

Features of Spring
1. Lightweight

Spring is lightweight because it uses simple Java classes (POJOs).

2. Dependency Injection (DI)

Spring automatically creates and injects required objects instead of developers creating them manually.

3. Inversion of Control (IoC)

Normally, developers control object creation.

In Spring, the IoC Container creates and manages objects.

4. Loose Coupling

Objects depend on interfaces rather than concrete classes.

5. Aspect-Oriented Programming (AOP)

AOP separates common functionalities from business logic.

Examples:

Logging
Security
Transaction management
Exception handling

Instead of writing logging code in every method, Spring can apply it automatically.

Introduction to SQL: Database, DBMS, RDBMS, and types of SQL Commands

Harini — Wed, 17 Jun 2026 11:51:51 +0000

What is SQL?

SQL (Structured Query Language) is a standard language used to communicate with databases. It helps us store, retrieve, update, and delete data from a database.

In simple terms, SQL is the language that allows applications to interact with data.

What is a Database?

A Database is an organized collection of related data stored electronically.

Instead of storing information in files, databases store data in a structured manner for easy access and management.

What is DBMS?
DBMS (Database Management System)
A DBMS is software that allows users to create, manage, and manipulate databases.

It acts as an interface between the user and the database.

Responsibilities of DBMS

Data storage
Data retrieval
Data security
Backup and recovery
Data management

Limitations of DBMS

Traditional DBMS has some drawbacks:

Data redundancy (duplicate data)
Data inconsistency
Difficult relationships between data
Poor scalability
Limited multi-user support

To overcome these issues, RDBMS was introduced.

What is RDBMS?

RDBMS (Relational Database Management System) is a type of DBMS that stores data in the form of tables (relations). These tables are connected to each other using relationships.

Advantages of RDBMS
1. Reduced Data Redundancy

Data is stored only once.

2. Data Integrity

Ensures data accuracy.

3. Data Security

Provides user permissions and access control.

4. Multi-User Support

Multiple users can access data simultaneously.

5. Better Relationships

Tables can be linked using keys.

Types of SQL Commands
1. DDL (Data Definition Language)

DDL commands are used to create, modify, and delete the structure of database objects such as tables, views, and indexes.

Commands

CREATE – Creates a new database object such as a table, view, or database.
ALTER – Modifies the structure of an existing database object.
DROP – Permanently deletes a database object and its data.
TRUNCATE – Removes all records from a table while keeping the table structure intact.

2. DML (Data Manipulation Language)
DML commands are used to insert, update, and delete data stored in database tables.

Commands

INSERT – Adds new records into a table.
UPDATE – Modifies existing records in a table.
DELETE – Removes one or more records from a table.

3. DQL (Data Query Language)
DQL commands are used to retrieve and display data from database tables.

Commands

SELECT – Retrieves data from one or more tables based on specified conditions.

4. DCL (Data Control Language)
DCL commands are used to control user access and permissions on database objects.

Commands

GRANT – Provides specific privileges or permissions to a user.
REVOKE – Removes previously granted privileges from a user.

5. TCL (Transaction Control Language)
TCL commands are used to manage and control transactions in a database.

Commands

COMMIT – Permanently saves all changes made during the current transaction.
ROLLBACK – Undoes changes made during the current transaction and restores the previous state.
SAVEPOINT – Creates a checkpoint within a transaction that can be rolled back to later.

Comparable vs Comparator in Java

Harini — Tue, 16 Jun 2026 15:36:43 +0000

In Java, sorting is an important operation when working with collections such as ArrayList, LinkedList, and other data structures. For primitive data types, Java already knows how to sort values. However, for custom objects like Student, Employee, or Product, Java needs instructions on how objects should be compared.

To achieve this, Java provides two interfaces:

Comparable – Used for natural sorting.
Comparator – Used for custom sorting.

Comparable Interface
Comparable is an interface available in the java.lang package.

It is used to define the natural ordering of objects. The sorting logic is written inside the class itself using the compareTo() method.

Method
int compareTo(T obj)
Return Values

Negative - Current object comes before the given object
Zero - Both objects are equal
Positive - Current object comes after the given object

When to Use Comparable?

Use Comparable when:

A class has one default sorting order.
The sorting logic is a natural property of the object.
The sorting criteria rarely change.

Comparator Interface
Comparator is an interface available in the java.util package.

It is used to define custom sorting logic outside the class. Multiple comparators can be created for the same class.

Method
int compare(T o1, T o2)

Return Values

Negative - First object comes before second object
Zero - Both objects are equal
Positive - First object comes after second object

When to Use Comparator?

Use Comparator when:

Multiple sorting criteria are required.
You don't want to modify the original class.
Different sorting orders are needed at different times.

String Program

Harini — Tue, 16 Jun 2026 15:24:28 +0000

Reverse the word

Algorithm

Start
Initialize variables:
- sen → input string
- start = 0
- end = sen.length - 1 (points to last character)
- result = "" (to store final output)
Loop from end of string to beginning:
- For i = end to 0
Check condition:
- If sen[i] == " " (space found) OR i == 0 (start reached)
Decide starting index of word:
- If i == 0 → start = i
- Else → start = i + 1
Extract the word:
- Loop from j = start to end
- Add each character to result
Add space after word:
- result += " "
Update end:
- end = i - 1 (move to previous word)
Repeat until loop ends
Print result
End

Program

let start = 0;
let sen = "YOU ARE HOW";
let len = sen.length - 1;
let end = len;
let result = "";  

for (let i = end; i >= 0; i--) {
    if (sen[i] == " " || i == 0) {

        if (i == 0) {
            start = i;        
        } else {
            start = i + 1;
        }

        for (let j = start; j <= end; j++) {
            result += sen[j];
        }
        result += " ";

        end = i - 1;
    }
}

console.log(result);

Output

Map in Java

Harini — Tue, 16 Jun 2026 05:31:09 +0000

What is Map in Java?

A Map in Java is a part of the Collections Framework that stores data in the form of key-value pairs.

Each key is unique.
Values can be duplicated.
A key is used to retrieve its corresponding value.
Map is available in the java.util package.
It does not extend the Collection interface.

Real-Time Example

Think of a student's record:

Roll Number (Key)	Student Name (Value)
101	Harini
102	Rahul
103	Kaviya

Here:

Roll Number = Key
Student Name = Value

A key uniquely identifies a value.

Why Use Map?

Map is useful when you need:

Fast searching
Unique identifiers
Key-based data storage
Efficient lookup operations

Examples

Employee ID → Employee Details
Username → Password
Product ID → Product Information
Roll Number → Student Details
Country Code → Country Name

Syntax

Map<KeyType, ValueType> map = new HashMap<>();

Example

Map<Integer, String> students = new HashMap<>();

Integer → Key
String → Value

Creating a Map

import java.util.*;

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

        Map<Integer, String> map = new HashMap<>();

        map.put(101, "Harini");
        map.put(102, "Rahul");
        map.put(103, "Kaviya");

        System.out.println(map);
    }
}

Output

{101=Harini, 102=Rahul, 103=Kaviya}

Important Methods in Map

1. put()

Used to insert key-value pairs.

map.put(101, "Harini");

Example

Map<Integer,String> map = new HashMap<>();

map.put(1, "Java");
map.put(2, "Python");

System.out.println(map);

Output

{1=Java, 2=Python}

2. get()

Retrieves value using key.

System.out.println(map.get(1));

Output

Java

3. remove()

Removes entry based on key.

map.remove(1);

Output

{2=Python}

4. containsKey()

Checks whether a key exists.

System.out.println(map.containsKey(2));

Output

true

5. containsValue()

Checks whether a value exists.

System.out.println(map.containsValue("Python"));

Output

true

6. size()

Returns number of entries.

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

Output

7. isEmpty()

Checks if map is empty.

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

Output

false

8. clear()

Removes all entries.

map.clear();

Traversing a Map

Using keySet()

Map<Integer,String> map = new HashMap<>();

map.put(1, "Java");
map.put(2, "Python");
map.put(3, "C++");

for(Integer key : map.keySet()) {
    System.out.println(key);
}

Output

1
2
3

Using values()

for(String value : map.values()) {
    System.out.println(value);
}

Output

Java
Python
C++

Using entrySet()

Most commonly used approach.

for(Map.Entry<Integer,String> entry : map.entrySet()) {
    System.out.println(entry.getKey() + " : " + entry.getValue());
}

Output

1 : Java
2 : Python
3 : C++

Implementations of Map Interface

1. HashMap

Features

Most commonly used
No insertion order maintained
Allows one null key
Allows multiple null values
Fast performance

Example

Map<Integer,String> map = new HashMap<>();

map.put(101, "Harini");
map.put(102, "Kaviya");

System.out.println(map);

2. LinkedHashMap

Features

Maintains insertion order
Slightly slower than HashMap
Allows null key and values

Example

Map<Integer,String> map = new LinkedHashMap<>();

map.put(3, "C");
map.put(1, "A");
map.put(2, "B");

System.out.println(map);

Output

{3=C, 1=A, 2=B}

3. TreeMap

Features

Stores keys in sorted order
Does not allow null keys
Based on Red-Black Tree

Example

Map<Integer,String> map = new TreeMap<>();

map.put(3, "C");
map.put(1, "A");
map.put(2, "B");

System.out.println(map);

Output

{1=A, 2=B, 3=C}

Set in Java

Harini — Mon, 15 Jun 2026 05:49:20 +0000

What is Set in Java?

The Set interface is a part of the Java Collections Framework and is available in the java.util package. It represents a collection that stores unique elements, meaning duplicate values are not allowed.

Key Characteristics of Set

A Set does not allow duplicate elements. If an attempt is made to add a duplicate element, it is ignored.
Most Set implementations allow at most one null value. However, TreeSet does not permit null elements because it stores elements in sorted order.
Set provides efficient operations for searching, inserting, and deleting elements.
It does not support index-based access like the List interface.
The order of elements depends on the implementation:
- HashSet → No guaranteed order
- LinkedHashSet → Maintains insertion order
- TreeSet → Maintains sorted order

Implementations of Set Interface

1. HashSet
HashSet is an implementation of the Set interface that stores unique elements using a hash table.

Set<String> set = new HashSet<>();

Characteristics

Does not allow duplicates
Allows one null value
Does not maintain insertion order
Fastest among Set implementations

Example

import java.util.HashSet;

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

        HashSet<String> set = new HashSet<>();

        set.add("Java");
        set.add("React");
        set.add("SQL");
        set.add("Java");

        System.out.println(set);
    }
}

Output
[React, Java, SQL]
(Order may vary.)

Internal Data Structure
Hash Table

When to Use

Duplicates are not allowed
Order is not important
Fast performance is required

2. LinkedHashSet
LinkedHashSet is a HashSet that maintains insertion order.

Set<String> set = new LinkedHashSet<>();

Characteristics

No duplicates
Maintains insertion order
Allows one null
Slightly slower than HashSet

Example

import java.util.LinkedHashSet;

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

        LinkedHashSet<String> set =
                new LinkedHashSet<>();

        set.add("Java");
        set.add("React");
        set.add("SQL");

        System.out.println(set);
    }
}

Output
[Java, React, SQL]
Order remains same as insertion order.

Internal Data Structure
Hash Table + Doubly Linked List

When to Use

Duplicates are not allowed
Insertion order must be preserved

3. TreeSet

TreeSet stores unique elements in sorted order.

Set<Integer> set = new TreeSet<>();

Characteristics

No duplicates
Automatically sorts elements
Does not allow null
Slower than HashSet

Example

import java.util.TreeSet;

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

        TreeSet<Integer> set =
                new TreeSet<>();

        set.add(50);
        set.add(10);
        set.add(30);

        System.out.println(set);
    }
}

Output
[10, 30, 50]
Automatically sorted in ascending order.

Internal Data Structure
Red-Black Tree
(A self-balancing binary search tree.)

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[]