DEV Community: KIRUBAGARAN .K

ArrayList vs LinkedList in Java

KIRUBAGARAN .K — Fri, 17 Apr 2026 16:27:08 +0000

ArrayList and LinkedList are two popular implementations of the List interface in Java. Both store elements in insertion order and allow duplicate values, but they differ in their internal data structure and performance.

What is an ArrayList?

Let’s start with the structure. ArrayList internally uses a dynamic array to store its elements. This means it’s essentially a resizable array that can grow or shrink as needed. The elements are stored in contiguous memory locations.

Example for ArrayList :

import java.util.ArrayList;

public class ArrayListDemo {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("A");
        arrayList.add("B");
        arrayList.add("C");
        System.out.println(arrayList); // Output: [A, B, C]
    }
}

What is an LinkedList?

On the other hand, LinkedList internally uses a doubly linked list. Each element is stored in a node, and each node contains a reference to both the next and the previous element in the list. This allows easier insertion and removal of elements, but the elements are not stored in contiguous memory.

Example for LinkedList :

import java.util.LinkedList;

public class LinkedListStructureExample {
    public static void main(String[] args) {
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("A");
        linkedList.add("B");
        linkedList.add("C");
        System.out.println(linkedList); // Output: [A, B, C]
    }
}

Best 1–2 Line Answer

When modifying data, an ArrayList can be slower because removing an element requires shifting all the remaining elements to keep the array continuous.
LinkedList uses a doubly linked list structure, where each element is stored in a node that has references to both the next and previous nodes. This makes insertion and deletion easier, but the elements are not stored in continuous memory.

Collections Framework in java

KIRUBAGARAN .K — Thu, 16 Apr 2026 14:51:40 +0000

The Java platform includes a collections framework. A collection is an object that represents a group of objects such as the classic Vector class. A collections framework is a unified architecture for representing and manipulating collections, enabling collections to be manipulated independently of implementation details.

The primary advantages of a collections framework are that it

Reduces Programming Effort
You don’t have to write data structures from scratch (like arrays, linked lists). Ready-made classes like ArrayList, HashSet, and HashMap save time and effort.

Increases Performance
The framework provides highly optimized data structures and algorithms, improving speed and efficiency.

Provides Reusability
Common data structures and algorithms can be reused across different programs, avoiding duplicate code.

Ensures Consistency
All collection classes follow a common set of interfaces (List, Set, Map), making them easy to learn and use.

Improves Code Quality
Using standard classes reduces bugs and makes code more readable and maintainable.

Supports Dynamic Data Handling
Unlike arrays, collections can grow or shrink dynamically at runtime.

Provides Utility Methods
The Collections class offers useful methods like sorting, searching, and reversing.

What is a need for the Collection Framework?

If the programmer wants to store 100 values then the disadvantage of this is the programmer has to create multiple variables with a unique name and it is very time-consuming also
In this case array concept is introduced. Programmer declare an array with specific size and store elements.
In the above example array is created with a size of five which means the array store only five data values.
If the size of the array is five and the user store only four values then memory is wasted.
To overcome this limitation, the Collection Framework was used.

Software Testing - Test Case

KIRUBAGARAN .K — Mon, 13 Apr 2026 18:54:25 +0000

What is test case?

Test cases define how to test a system, software or an application. A test case is a singular set of actions or instructions for a tester to perform that validates a specific aspect of a product or application functionality. If the test fails, the result might be a software defect that the organization can triage

Which Time do we Write a Test Case?

A test case is written even before the starting of the software development when the requirements are ready. The testers finish designing the test cases at the time when development of the software has also been completed

How to Write Test Cases

Writing test cases is an art and science designed to verify that your application operates as expected. As a test case writer, you write test cases so that testers know how to determine whether a feature of an application or software system is working correctly.

Instagram Post Upload – Test Case Table(application)

Mouse – Test Case Table(product)

Why Is Software Testing Important?

KIRUBAGARAN .K — Sat, 11 Apr 2026 18:02:44 +0000

Software testing

Software testing is a process used to identify the correctness, completeness and quality of developed computer software. It includes a set of activities conducted with the intent of finding errors in software so that it could be corrected before the product is released to the end users.

In simple words, Software testing is an activity to check that the software system is defect free

Why Is Testing Software Important?

The importance of software testing lies in its ability to detect issues early in the development lifecycle. Early software testing helps development teams prevent widespread system crashes and unexpected failures

Testing software helps development teams confirm that the software system performs according to specified requirements. It also prevents costly errors and improves overall software reliability

Thorough testing allows organizations to deliver a high quality product that meets user expectations. In modern software development, testing has become a critical part of the development process .

Major Historical Software Failures

CrowdStrike Global Outage (2024) A flawed software update caused widespread system crashes on Microsoft Windows platforms, leading to thousands of flight cancellations and estimated losses exceeding $500 million for companies like Delta Air Lines.

NASA Mars Climate Orbiter (1998) A $125 million spacecraft was lost because one team used imperial units while another used metric units in the ground control software.

Knight Capital Group Disaster (2012): An old, dormant software flag was accidentally reactivated during deployment. The resulting trading algorithm glitch caused a $440 million loss in just 45 minutes.

File Handling Classes in Java

KIRUBAGARAN .K — Tue, 07 Apr 2026 11:40:13 +0000

File – Managing Files

The java.io.File class is used to represent file and directory pathnames in an abstract manner. It doesn't represent the contents of a file but allows you to create, delete, check properties (like size, existence), and manipulate files or directories

Method	Purpose
`createNewFile()`	Create file
`exists()`	Check file exists
`getName()`	Get file name
`getAbsolutePath()`	Get file path
`canRead()`	Check read permission
`canWrite()`	Check write permission
`canExecute()`	Check execute permission
`length()`	File size
`delete()`	Delete file
`mkdir()`	Create directory
`mkdirs()`	Create multiple directories
`list()`	List files

FileReader – Reading Characters

Convenience class for reading character files. The constructors of this class assume that the default character encoding and the default byte-buffer size are appropriate. To specify these values yourself, construct an InputStreamReader on a FileInputStream.

Method	Purpose
`read()`	Read one character
`read(char[])`	Read multiple characters
`read(char[], off, len)`	Read with position
`ready()`	Check readiness
`skip(n)`	Skip characters
`getEncoding()`	Get encoding
`close()`	Close file

FileWriter – Writing Data

If you are just starting with Java, the easiest way to write text to a file is by using the FileWriter class.
In the example below, we use FileWriter together with its write() method to create and write some text into a file.

Method	Purpose
`write(int)`	Write one character
`write(char[])`	Write character array
`write(String)`	Write string
`write(String, off, len)`	Write part of string
`append()`	Add data at end
`flush()`	Force write
`close()`	Close file

BufferedReader – Efficient Reading

The BufferedReader class in Java helps read text efficiently from files or user input. It stores data in a buffer, making reading faster and smoother instead of reading one character at a time.
Faster Reading Reads large chunks of data at once, reducing the number of read operations.

Method	Purpose
`read()`	Read one character
`readLine()`	Read full line
`read(char[], off, len)`	Read into array
`ready()`	Check readiness
`skip(n)`	Skip characters
`mark()`	Mark position
`reset()`	Return to mark
`close()`	Close stream

BufferedWriter – Efficient Writing

The BufferedWriter class is used to write text to a file, one line or one string at a time. If the file already exists, its contents will be replaced (overwritten).

Method	Purpose
`write(int)`	Write one character
`write(char[])`	Write character array
`write(String)`	Write string
`write(String, off, len)`	Write part of string
`newLine()`	Add new line
`flush()`	Force write
`close()`	Close stream

PrintWriter – Formatted Writing

Unlike the PrintStream class, if automatic flushing is enabled it will be done only when one of the println, printf, or format methods is invoked, rather than whenever a newline character happens to be output. These methods use the platform's own notion of line separator rather than the newline character

Method	Purpose
`print()`	Write without new line
`println()`	Write with new line
`printf()`	Formatted output
`format()`	Same as printf
`write()`	Write raw data
`append()`	Add data
`flush()`	Force write
`close()`	Close writer

File Handling Classes in Java

KIRUBAGARAN .K — Tue, 07 Apr 2026 11:40:13 +0000

File – Managing Files

Method	Purpose
`createNewFile()`	Create file
`exists()`	Check file exists
`getName()`	Get file name
`getAbsolutePath()`	Get file path
`canRead()`	Check read permission
`canWrite()`	Check write permission
`canExecute()`	Check execute permission
`length()`	File size
`delete()`	Delete file
`mkdir()`	Create directory
`mkdirs()`	Create multiple directories
`list()`	List files

FileReader – Reading Characters

Method	Purpose
`read()`	Read one character
`read(char[])`	Read multiple characters
`read(char[], off, len)`	Read with position
`ready()`	Check readiness
`skip(n)`	Skip characters
`getEncoding()`	Get encoding
`close()`	Close file

FileWriter – Writing Data

If you are just starting with Java, the easiest way to write text to a file is by using the FileWriter class.
In the example below, we use FileWriter together with its write() method to create and write some text into a file.

Method	Purpose
`write(int)`	Write one character
`write(char[])`	Write character array
`write(String)`	Write string
`write(String, off, len)`	Write part of string
`append()`	Add data at end
`flush()`	Force write
`close()`	Close file

BufferedReader – Efficient Reading

The BufferedReader class in Java helps read text efficiently from files or user input. It stores data in a buffer, making reading faster and smoother instead of reading one character at a time.
Faster Reading Reads large chunks of data at once, reducing the number of read operations.

Method	Purpose
`read()`	Read one character
`readLine()`	Read full line
`read(char[], off, len)`	Read into array
`ready()`	Check readiness
`skip(n)`	Skip characters
`mark()`	Mark position
`reset()`	Return to mark
`close()`	Close stream

BufferedWriter – Efficient Writing

The BufferedWriter class is used to write text to a file, one line or one string at a time. If the file already exists, its contents will be replaced (overwritten).

Method	Purpose
`write(int)`	Write one character
`write(char[])`	Write character array
`write(String)`	Write string
`write(String, off, len)`	Write part of string
`newLine()`	Add new line
`flush()`	Force write
`close()`	Close stream

PrintWriter – Formatted Writing

Method	Purpose
`print()`	Write without new line
`println()`	Write with new line
`printf()`	Formatted output
`format()`	Same as printf
`write()`	Write raw data
`append()`	Add data
`flush()`	Force write
`close()`	Close writer

File Handling in Java

KIRUBAGARAN .K — Mon, 06 Apr 2026 17:16:24 +0000

What is File Handling in Java?

File handling in Java is about managing files on your system. It allows you to create new files, read information from existing files, write data into them, and remove files when they are no longer needed

This feature is useful because it lets applications store data safely. Even after the program finishes running, the saved data remains available for future use.

Why is File Handling Important?

Data persistence: Saving data to files assures that it can be retrieved later, even if a program has stopped running.
Data communication: Files enable data communication between different programs or systems.
Large data storage: Files enable the storage of large datasets that would not fit in memory.
Log management: Storing logs in files allows you to follow program activity and troubleshoot difficulties.

Java File Class Methods

File Class

The File class is used to create and manage files.

import java.io.File;

public class FileExample {
    public static void main(String[] args) {
        try {
            File file = new File("example.txt");

            if (file.createNewFile()) {
                System.out.println("File created successfully");
            } else {
                System.out.println("File already exists");
            }
        } catch (Exception e) {
            System.out.println("Error occurred");
        }
    }
}

Real-Life Analogy

File handling can be compared to managing a notebook

Writing notes means saving data
Reading notes means accessing data
Editing notes means updating data
Removing pages means deleting data

Java Exception Handling – Practical Scenarios Explained

KIRUBAGARAN .K — Thu, 02 Apr 2026 17:51:48 +0000

Exception handling in Java is not just about catching errors, but about designing programs that behave predictably even when things go wrong. Let’s explore three important real-world scenarios to understand how exceptions should be used effectively.

1.Student Result System

Problem Statement

You are building a system to store student marks. The valid range is between 0 and 100.

Conditions

If marks < 0 → throw exception
If marks > 100 → throw exception

public class StudentResult {
    public static void main(String[] args) {
        int marks = 110; 

        if (marks < 0 || marks > 100) {
            throw new IllegalArgumentException("Invalid marks! Marks should be between 0 and 100 ");
        }

        System.out.println("Valid marks: " + marks);
    }
}

This uses an unchecked exception (IllegalArgumentException)
It is appropriate because invalid marks indicate a programming or input validation issue
The program immediately stops when invalid data is detected, preventing incorrect results

2.Checked vs Unchecked Exceptions – When to Use?

Checked

Checked exceptions are used when the error is expected and recoverable.

Java forces you to handle them using try-catch or throws. For example, opening a file may throw an IOException, and the program can recover by asking for another file.

FileReader file = new FileReader("test.txt"); // IOException

When to Use

The error is expected
The error is recoverable
The caller should be forced to handle it

Unchecked

Unchecked exceptions are used for programming mistakes that are not recoverable at runtime.

These occur due to logical errors in code, like dividing by zero, which throws an ArithmeticException. Instead of handling them, the correct approach is to fix the code.

int a = 10 / 0; // ArithmeticException

When to Use

The error is due to a programming mistake
It is not recoverable at runtime
No need to force handling

3.Will finally Execute if System.exit(0)is Called? (To be discussed)

When System.exit(0) runs, it immediately shuts down the JVM, like pulling the plug on the entire program. Because of this sudden stop, the normal flow of execution is interrupted, and the finally block is skipped completely.

public class TestFinally {
    public static void main(String[] args) {
        try {
            System.out.println("Try block");
            System.exit(0);
        } finally {
            System.out.println("Finally block");
        }
    }
}

No, the finally block will not execute if System.exit(0) is called.

What System.exit(0) Does

Immediately terminates the Java Virtual Machine (JVM)
Stops all running threads
Ends program execution abruptly

Why Finally Does Not Execute

The finally block is part of normal program flow
System.exit(0) bypasses this flow completely
The JVM shuts down before finally gets a chance to run

Java throws Made Easy: Learn When and Why to Use It

KIRUBAGARAN .K — Wed, 01 Apr 2026 15:40:07 +0000

Introduction

In Java, exception handling is essential for building robust applications. One important keyword in this mechanism is throws, which allows a method to declare that it might generate certain exceptions and pass the responsibility of handling them to the caller.

What is throws in Java?

throws is a keyword used in the method signature to indicate that a method may throw one or more exceptions. Instead of handling the exception inside the method, it delegates the responsibility to the method caller.

Syntax

returnType methodName(parameterList) throws ExceptionType1, ExceptionType2 {
}

When Should You Use throws?

1.When You Want the Caller to Handle the Exception

Use throws when the method cannot or should not decide how to handle an error.

For example, a file-reading method does not know whether to retry, log the error, or terminate the program. So, it passes the exception to the caller.

2.When You Want to Keep Your Code Clean

Adding multiple try-catch blocks can make your method cluttered and harder to read.

Using throws helps keep the method simple, clean, and focused on its main task.

3.When Writing Reusable or Library Code

If you're developing methods that others will use, you should not force a specific way of handling exceptions.

Using throws gives flexibility to the caller to decide how to respond.

Real-Life Analogy: The Cooking Scenario

Imagine you are cooking a dish and suddenly realize that an important ingredient is missing.

Now, you have two choices:

Using try-catch

You handle the problem yourself.
You might go to the store, find a substitute, or adjust the recipe and continue cooking.

Using throws

Instead of solving the problem yourself, you inform someone else:
“An ingredient is missing. You handle it.”

You pass the responsibility to another person, and they decide what to do next.

Throwable in Java: The Foundation of Error and Exception Handling

KIRUBAGARAN .K — Tue, 31 Mar 2026 14:49:43 +0000

The Root of All Errors and Exceptions

In Java, things don’t always go as planned. Programs crash, unexpected inputs appear, and system failures sneak in. To manage all these situations, Java provides a powerful mechanism called exception handling.

At the heart of this mechanism lies a single class: Throwable.

Understanding Throwable is like understanding the family tree of all problems in Java. Let’s break it down in a simple and practical way.

What is Throwable?

Throwable is a superclass in Java (java.lang) that represents all errors and exceptions that can occur during program execution.

Java organizes all errors and exceptions under the Throwable class

Exception
Error

Exception (Handleable Problems)

Exceptions are conditions that a program can catch and handle during runtime . These can be handled using try-catch blocks.

ArithmeticException
NullPointerException
IOException

Error (Critical Problems)

Errors are serious problems that occur at the system level and are generally not recoverable. These are usually not handled in application code.

OutOfMemoryError
StackOverflowError

Key Methods in Throwable

Some commonly used methods in the Throwable class include

getMessage() – Returns the error message
printStackTrace() – Displays detailed error information
toString() – Returns a string representation of the error

Understanding the Right Use of If-else and Exception Handling

KIRUBAGARAN .K — Mon, 30 Mar 2026 09:54:04 +0000

At first glance, both seem to handle problems. However, they serve very different purposes in programming.

Why We Should Use Exception Handling

1.Handles Unexpected Errors

Some errors cannot be predicted in advance.

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

This prevents the program from crashing.

2.Maintains Program Flow

Without exception handling, a program stops when an error occurs.
With exception handling, the program can continue execution.

3.Improves Code Readability

It separates the main logic from error-handling logic:

try contains normal code
catch handles errors

This makes the code easier to understand and maintain.

4.Provides Debugging Information

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

This helps developers identify the exact cause of the error.

Why if-else is Not Enough

1.Cannot Handle Unknown Errors

String str = null;
System.out.println(str.length());

This will throw a runtime error if not handled properly. If-else cannot always prevent such cases.

2.Leads to Complex Code

if(condition1) {
    if(condition2) {
        if(condition3) {
            // logic
        }
    }
}

Nested conditions make the code harder to read and maintain.

3.Cannot Handle System-Level Exceptions

Errors such as file not found or input-output failures are generated by the system and cannot be managed using if-else alone.

Understanding the Right Use of If-else and Exception Handling

If-else and exception handling are not substitutes for each other. They solve different types of problems.
If-else is used for handling expected conditions, while exception handling is used for managing unexpected runtime errors.
A well-designed Java program uses both appropriately to ensure stability, readability, and robustness.