DEV Community: Arul .A

Why Use Collections Instead of Arrays in Java?

Arul .A — Fri, 26 Jun 2026 16:41:24 +0000

Why Use Collections Instead of Arrays in Java?

When you start learning Java, one of the first data structures you'll encounter is the Array. Arrays are simple, fast, and useful—but they have limitations. As applications grow in complexity, Java developers often prefer the Collections Framework because it provides more flexibility and powerful features.

In this blog, let's understand why Collections are generally preferred over Arrays.

What is an Array?

An Array is a data structure that stores multiple values of the same type in a fixed-size container.

int[] numbers = {10, 20, 30, 40};

Arrays are efficient and easy to use when the number of elements is known beforehand.

What is a Collection?

A Collection is part of the Java Collections Framework (JCF). It provides dynamic data structures that can grow or shrink during program execution.

Some commonly used collection classes are:

ArrayList
LinkedList
HashSet
TreeSet
HashMap

Example:

import java.util.ArrayList;

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

names.add("Arul");
names.add("Rahul");
names.add("Kumar");

Why Collections Instead of Arrays?

1. Dynamic Size

One of the biggest limitations of arrays is their fixed size.

Array

int[] arr = new int[3];

Once created, the size cannot be changed.

If you need to store more elements, you'll have to create a new array and copy the existing elements manually.

Collection

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

list.add(10);
list.add(20);
list.add(30);
list.add(40);

Collections automatically resize themselves when needed.

2. Easy to Add and Remove Elements

With arrays, removing an element requires shifting the remaining elements manually.

Example:

int[] arr = {10, 20, 30};

Removing 20 isn't straightforward.

Collections make it much easier.

list.remove(Integer.valueOf(20));

That's it!

3. Rich Built-in Methods

Arrays provide very few operations.

Collections come with many useful methods.

list.add("Java");
list.remove("Java");
list.contains("Java");
list.size();
list.clear();
list.isEmpty();

These methods save time and reduce the amount of code you need to write.

4. Easy Searching

Searching an array usually requires writing a loop.

for(int i = 0; i < arr.length; i++) {
    if(arr[i] == 20) {
        System.out.println("Found");
    }
}

With Collections:

list.contains(20);

Simple and readable.

5. Easy Sorting

Sorting arrays:

Arrays.sort(arr);

Sorting collections:

Collections.sort(list);

Collections also support custom sorting using comparators, making them much more flexible.

6. Multiple Data Structures

Arrays provide only one type of data structure.

The Java Collections Framework offers different implementations for different use cases.

Collection	Best For
ArrayList	Fast random access
LinkedList	Frequent insertions and deletions
HashSet	Unique elements
TreeSet	Sorted unique elements
HashMap	Key-value pairs

This flexibility makes Collections suitable for real-world applications.

7. Better Code Readability

Collections make your code shorter and easier to understand.

Instead of writing loops and manual logic, you can use built-in methods.

Example:

list.contains("Java");
list.remove("Java");
Collections.sort(list);

Arrays vs Collections

Feature	Array	Collection
Size	Fixed	Dynamic
Built-in Methods	Very Few	Many
Add/Remove	Difficult	Easy
Searching	Manual	Built-in
Sorting	Basic	Advanced
Flexibility	Low	High

When Should You Use Arrays?

Arrays are a good choice when:

The size of the data is fixed.
You need better memory efficiency.
You're working with primitive data types.
You're solving algorithm or competitive programming problems.

Example:

int[] marks = {85, 90, 95};

When Should You Use Collections?

Collections are the better choice when:

The number of elements can change.
You frequently add or remove data.
You need searching, sorting, or filtering.
You're building real-world applications.

Example:

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

employees.add("Arul");
employees.add("Ravi");
employees.remove("Ravi");

Conclusion

Arrays are simple, efficient, and ideal for fixed-size data. However, modern Java applications often require flexibility, dynamic resizing, and powerful built-in operations. That's where the Java Collections Framework shines.

If you're building real-world Java applications, Collections like ArrayList, LinkedList, HashSet, and HashMap will usually be the better choice.

Understanding when to use Arrays and when to use Collections is an important skill for every Java developer and is a common topic in technical interviews.

💬 Final Thoughts

Both Arrays and Collections have their place in Java. Choose the right one based on your application's requirements. Mastering both will make you a better Java developer and help you write cleaner, more efficient code.

Happy Coding! 🚀

#Java #Programming #JavaCollections #ArrayList #DataStructures #Coding #JavaDeveloper #LearnJava #SoftwareDevelopment #100DaysOfCode

Java Scanner Class

Arul .A — Thu, 25 Jun 2026 07:31:19 +0000

Java Scanner Class Explained

If you're learning Java, one of the first things you'll need is taking input from the user. That's where the Scanner class comes in.

In this post, you'll learn:

What is Scanner?
Why do we use it?
How to use it?
Common Scanner methods
Difference between next() and nextLine()
Common mistakes
Interview questions

What is Scanner?

Scanner is a predefined class in Java used to read input from different sources such as:

Keyboard (System.in)
Files
Strings

It belongs to the java.util package, so we must import it before using it.

import java.util.Scanner;

Why Do We Use Scanner?

Normally, a Java program prints fixed output.

System.out.println("Hello Java");

But if you want the user to enter data while the program is running, you need the Scanner class.

For example:

Enter your name:

The program waits for the user's input and processes it.

Creating a Scanner Object

Scanner sc = new Scanner(System.in);

Explanation:

Scanner → Class name
sc → Object name
new → Creates a new object
System.in → Reads input from the keyboard

Example: Reading a String

import java.util.Scanner;

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

        Scanner sc = new Scanner(System.in);

        System.out.print("Enter your name: ");
        String name = sc.nextLine();

        System.out.println("Welcome " + name);

        sc.close();
    }
}

Output

Enter your name:
Arul

Welcome Arul

Common Scanner Methods

Method	Description	Example
`next()`	Reads one word	Java
`nextLine()`	Reads an entire line	Java Full Stack
`nextInt()`	Reads an integer	25
`nextDouble()`	Reads a decimal number	95.5
`nextFloat()`	Reads a float	3.14
`nextBoolean()`	Reads `true` or `false`	true
`nextLong()`	Reads a long value	9876543210

Reading an Integer

Scanner sc = new Scanner(System.in);

System.out.print("Enter your age: ");

int age = sc.nextInt();

System.out.println("Age is " + age);

sc.close();

Output

Enter your age:
22

Age is 22

Reading Multiple Inputs

Scanner sc = new Scanner(System.in);

System.out.print("Enter your name: ");
String name = sc.nextLine();

System.out.print("Enter your age: ");
int age = sc.nextInt();

System.out.println(name);
System.out.println(age);

sc.close();

Difference Between `next()` and `nextLine()`

`next()`

Reads only one word.

Scanner sc = new Scanner(System.in);

String name = sc.next();

Input

Java Programming

Output

Java

It stops reading when it encounters a space.

`nextLine()`

Reads the entire line.

Scanner sc = new Scanner(System.in);

String name = sc.nextLine();

Input

Java Programming

Output

Java Programming

Common Mistake

Scanner sc = new Scanner(System.in);

System.out.print("Age: ");
int age = sc.nextInt();

System.out.print("Name: ");
String name = sc.nextLine();

System.out.println(name);

Input

22
Arul

The program prints an empty string for name.

Why?

nextInt() reads only the number and leaves the Enter key (\n) in the input buffer. The following nextLine() immediately reads that leftover newline.

Solution

int age = sc.nextInt();
sc.nextLine();

String name = sc.nextLine();

Why Do We Close Scanner?

sc.close();

Closing the Scanner releases the resources associated with it. It is considered a good programming practice to close it after use.

Interview Questions

1. What is Scanner?

Scanner is a predefined class in the java.util package used to read input from the keyboard, files, strings, and other input sources.

2. Why do we use Scanner?

We use Scanner to take input from the user while the program is running.

3. Which package contains Scanner?

java.util

4. How do you create a Scanner object?

Scanner sc = new Scanner(System.in);

5. What is the difference between `next()` and `nextLine()`?

`next()`	`nextLine()`
Reads one word	Reads the entire line
Stops at whitespace	Reads until Enter is pressed

Conclusion

The Scanner class is one of the first Java classes every beginner should learn. It allows you to read user input easily and supports many data types such as int, double, String, and boolean.

Understanding methods like nextInt(), next(), and nextLine() will help you avoid common mistakes and write better Java programs.

My Experience Attending a Java Developer Interview at Twite AI Technologies

Arul .A — Tue, 23 Jun 2026 13:38:20 +0000

My Experience Attending a Java Developer Interview at Twite AI Technologies

Recently, I attended an interview for the Software Engineer Trainee – Product Development role at Twite AI Technologies in Chennai. As a fresher, it was a valuable experience that helped me understand what companies expect from candidates during technical interviews.

Self Introduction

The interview started with a self-introduction. I introduced myself as Arul, a B.E. Electronics and Communication Engineering graduate from Maha Barathi Engineering College. I explained that I am currently learning Java Full Stack Development and building projects to improve my development skills.

Project Discussion

The interviewer spent most of the time discussing my project. They were interested in understanding both the technical implementation and the features provided to users.

I explained my Product Management System project and demonstrated the major functionalities:

Key Features

1. Search Functionality

Users can quickly search products using a search bar. This helps locate products without manually browsing the entire list.

2. Category-Based Filtering

Products can be filtered by category, making it easier to view only the relevant items.

3. CSV File Support

The application supports importing product data through CSV files, which allows bulk data management instead of manually adding records one by one.

4. Product Updates

Users can update existing product information whenever product details change.

5. Product Management

The application allows adding, viewing, editing, and managing products efficiently.

Questions Asked

Some of the questions discussed during the interview included:

Explain your project.
What problem does your project solve?
What features have you implemented?
How does the search functionality work?
How does category filtering improve user experience?
Why did you implement CSV file support?
How are product updates handled in the application?

The interviewer focused more on understanding the project than asking complex theoretical questions.

What I Learned

This interview taught me that interviewers often evaluate how well candidates understand their own projects. Simply building a project is not enough; it is important to clearly explain:

The purpose of the project
The technologies used
The features implemented
The challenges faced
Future improvements

Final Thoughts

At the end of the interview, the interviewer informed me that they would review my profile and contact me later if selected for the next stage.

Regardless of the outcome, the experience improved my confidence and helped me prepare better for future interviews.

Every interview is an opportunity to learn, improve communication skills, and identify areas for growth.

JDBC Basics for Beginners

Arul .A — Mon, 22 Jun 2026 13:23:31 +0000

JDBC Basics for Beginners

What is JDBC?

JDBC (Java Database Connectivity) is a Java API that allows Java applications to connect with databases such as PostgreSQL, MySQL, Oracle, and SQL Server.

Using JDBC, we can:

Connect to a database
Execute SQL queries
Insert, update, and delete records
Retrieve data from tables

JDBC Architecture

Java Application
       |
       v
     JDBC API
       |
       v
   JDBC Driver
       |
       v
    Database

The JDBC Driver acts as a bridge between the Java application and the database.

JDBC Steps

Step 1: Load the Driver

Class.forName("org.postgresql.Driver");

This loads the PostgreSQL JDBC driver into memory.

Step 2: Create a Connection

Connection con = DriverManager.getConnection(
    "jdbc:postgresql://localhost:5432/postgres",
    "postgres",
    "password"
);

This creates a connection between Java and PostgreSQL.

Step 3: Create a Statement

Statement stmt = con.createStatement();

A Statement object is used to execute SQL queries.

Step 4: Execute Query

ResultSet rs = stmt.executeQuery(
    "SELECT * FROM india_players"
);

The query is sent to the database and the result is stored in a ResultSet.

Step 5: Read Data

while(rs.next()) {
    System.out.println(
        rs.getString("player_name")
    );
}

The next() method moves through each row and retrieves data.

Step 6: Close Resources

rs.close();
stmt.close();
con.close();

Closing resources helps prevent memory leaks.

Example Program

import java.sql.*;

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

        try {

            Class.forName("org.postgresql.Driver");

            Connection con = DriverManager.getConnection(
                "jdbc:postgresql://localhost:5432/postgres",
                "postgres",
                "password"
            );

            Statement stmt = con.createStatement();

            ResultSet rs = stmt.executeQuery(
                "SELECT * FROM india_players"
            );

            while(rs.next()) {
                System.out.println(
                    rs.getString("player_name")
                );
            }

            rs.close();
            stmt.close();
            con.close();

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

Important JDBC Classes

Class	Purpose
DriverManager	Creates database connections
Connection	Represents a database connection
Statement	Executes SQL queries
ResultSet	Stores query results

Conclusion

JDBC is the standard API used to connect Java applications with databases. The basic JDBC flow is:

Load Driver
Create Connection
Create Statement
Execute Query
Read ResultSet
Close Resources

Understanding these six steps is enough to start working with JDBC and database-driven Java applications.

SQL Interview Questions Asked in Solverines Technology Solutions – Technical Round

Arul .A — Thu, 18 Jun 2026 15:59:13 +0000

SQL Interview Questions Asked in Solverines Technology Solutions – Technical Round

Recently, I attended a technical interview at Solverines Technology Solutions Private Limited. During the SQL round, I was asked several interesting queries related to retrieving records and row numbering. I was also asked a logical programming problem involving bulb state toggling.

In this blog, I will explain the questions along with their solutions.

1. Write a Query to Access the Last Record from a Table

Assume we have an Employee table:

CREATE TABLE Employee(
    emp_id INT,
    emp_name VARCHAR(50)
);

To retrieve the last record:

SELECT *
FROM Employee
ORDER BY emp_id DESC
LIMIT 1;

Explanation:

ORDER BY emp_id DESC sorts the records in descending order.
LIMIT 1 returns only the first record after sorting, which is the last record in the table.

2. Access the First Nth Row and Last Nth Row in a Table

Nth Row from the Beginning

Example: Retrieve the 3rd row.

SELECT *
FROM Employee
ORDER BY emp_id
LIMIT 1 OFFSET 2;

Formula:

LIMIT 1 OFFSET (N - 1);

Nth Row from the End

Example: Retrieve the 3rd row from the end.

SELECT *
FROM Employee
ORDER BY emp_id DESC
LIMIT 1 OFFSET 2;

Formula:

ORDER BY emp_id DESC
LIMIT 1 OFFSET (N - 1);

3. Retrieve Only the Nth Even and Odd Row in a Table

For this problem, we use ROW_NUMBER().

Nth Odd Row

Example: Retrieve the 2nd odd row.

SELECT *
FROM (
    SELECT *,
           ROW_NUMBER() OVER(ORDER BY emp_id) AS rn
    FROM Employee
) t
WHERE rn = (2 * 2 - 1);

General Formula:

rn = (2 * N - 1)

Nth Even Row

Example: Retrieve the 3rd even row.

SELECT *
FROM (
    SELECT *,
           ROW_NUMBER() OVER(ORDER BY emp_id) AS rn
    FROM Employee
) t
WHERE rn = (2 * 3);

General Formula:

rn = (2 * N)

Retrieve All Odd Rows

SELECT *
FROM (
    SELECT *,
           ROW_NUMBER() OVER(ORDER BY emp_id) AS rn
    FROM Employee
) t
WHERE rn % 2 = 1;

Retrieve All Even Rows

SELECT *
FROM (
    SELECT *,
           ROW_NUMBER() OVER(ORDER BY emp_id) AS rn
    FROM Employee
) t
WHERE rn % 2 = 0;

Logical Programming Question

Bulb Toggle Problem

Problem Statement

There are N bulbs arranged in a row.

Initially, all bulbs are OFF (0).

Perform K operations.

In each operation, toggle all bulbs from index i to j (inclusive).

0 becomes 1
1 becomes 0

Finally, print the state of all bulbs.

Example

Input:

N = 5
K = 2

Operation 1: 1 3
Operation 2: 2 4

Initial State:

0 0 0 0 0

After Operation 1:

0 1 1 1 0

After Operation 2:

0 1 0 0 1

Final Output:

0 1 0 0 1

Java Solution

import java.util.Scanner;

public class BulbToggle {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        int n = sc.nextInt();
        int k = sc.nextInt();

        int[] bulbs = new int[n];

        for(int op = 0; op < k; op++) {

            int i = sc.nextInt();
            int j = sc.nextInt();

            for(int index = i; index <= j; index++) {
                bulbs[index] = 1 - bulbs[index];
            }
        }

        for(int bulb : bulbs) {
            System.out.print(bulb + " ");
        }
    }
}

Time Complexity

SQL queries using ROW_NUMBER(): O(N)
Bulb Toggle Problem: O(K × N) in the basic approach

Conclusion

The technical round focused on SQL fundamentals and logical problem-solving skills. The main SQL topics covered were:

Retrieving the last record from a table.
Finding the Nth row from the beginning and end.
Retrieving Nth even and odd rows using ROW_NUMBER().
Understanding row numbering concepts.
Solving a bulb state toggling problem using arrays.

These are common interview questions for freshers and junior software developers. Practicing these concepts can significantly improve performance in technical interviews.

Joins in SQL

Arul .A — Wed, 17 Jun 2026 16:54:05 +0000

SQL Joins in SQL

Introduction

SQL Joins are used to combine data from two or more tables based on a related column. They help retrieve meaningful information stored across multiple tables.

Employees Table

emp_id	emp_name	dept_id
101	Kumar	1
102	Priya	2
103	Raja	1
104	Anu	3

Department Table

dept_id	dept_name
1	ARUL
2	HARINI
4	SIMBU
5	DIVYA

1. INNER JOIN

An INNER JOIN returns only the matching records from both tables.

Query

SELECT e.emp_id, e.emp_name, d.dept_name
FROM Employees e
INNER JOIN Department d
ON e.dept_id = d.dept_id;

Output

emp_id	emp_name	dept_name
101	Kumar	ARUL
102	Priya	HARINI
103	Raja	ARUL

Explanation

Only matching department IDs are displayed. Anu is excluded because department 3 does not exist in the Department table.

2. LEFT JOIN

A LEFT JOIN returns all records from the left table and matching records from the right table.

Query

SELECT e.emp_id, e.emp_name, d.dept_name
FROM Employees e
LEFT JOIN Department d
ON e.dept_id = d.dept_id;

Output

emp_id	emp_name	dept_name
101	Kumar	ARUL
102	Priya	HARINI
103	Raja	ARUL
104	Anu	NULL

Explanation

All employees are displayed. Since department 3 does not exist, Anu's department appears as NULL.

3. RIGHT JOIN

A RIGHT JOIN returns all records from the right table and matching records from the left table.

Query

SELECT e.emp_id, e.emp_name, d.dept_name
FROM Employees e
RIGHT JOIN Department d
ON e.dept_id = d.dept_id;

Output

emp_id	emp_name	dept_name
101	Kumar	ARUL
103	Raja	ARUL
102	Priya	HARINI
NULL	NULL	SIMBU
NULL	NULL	DIVYA

Explanation

All departments are displayed. SIMBU and DIVYA have no employees, so employee columns contain NULL values.

4. FULL OUTER JOIN

A FULL OUTER JOIN returns all records from both tables.

Query

SELECT e.emp_id, e.emp_name, d.dept_name
FROM Employees e
FULL OUTER JOIN Department d
ON e.dept_id = d.dept_id;

Output

emp_id	emp_name	dept_name
101	Kumar	ARUL
102	Priya	HARINI
103	Raja	ARUL
104	Anu	NULL
NULL	NULL	SIMBU
NULL	NULL	DIVYA

Explanation

All employees and all departments are displayed. Unmatched rows contain NULL values.

5. CROSS JOIN

A CROSS JOIN returns every possible combination of rows from both tables.

Query

SELECT e.emp_name, d.dept_name
FROM Employees e
CROSS JOIN Department d;

Output

emp_name	dept_name
Kumar	ARUL
Kumar	HARINI
Kumar	SIMBU
Kumar	DIVYA
Priya	ARUL
Priya	HARINI
Priya	SIMBU
Priya	DIVYA
Raja	ARUL
Raja	HARINI
Raja	SIMBU
Raja	DIVYA
Anu	ARUL
Anu	HARINI
Anu	SIMBU
Anu	DIVYA

Explanation

Every employee is combined with every department.

Formula:

Rows in Employees × Rows in Department

4 × 4 = 16 Rows

6. SELF JOIN

A SELF JOIN joins a table with itself.

Employee Table

emp_id	emp_name	manager_id
1	Arul	NULL
2	Kumar	1
3	Priya	1
4	Raja	2

Query

SELECT e.emp_name AS Employee,
       m.emp_name AS Manager
FROM Employee e
LEFT JOIN Employee m
ON e.manager_id = m.emp_id;

Output

Employee	Manager
Arul	NULL
Kumar	Arul
Priya	Arul
Raja	Kumar

Explanation

The Employee table is joined with itself to find each employee's manager.

Difference Between SQL Joins

Join Type	Result
INNER JOIN	Matching rows only
LEFT JOIN	All left table rows + matching right rows
RIGHT JOIN	All right table rows + matching left rows
FULL OUTER JOIN	All rows from both tables
CROSS JOIN	Every possible combination
SELF JOIN	Table joined with itself

Understanding Forms in React

Arul .A — Tue, 16 Jun 2026 12:23:27 +0000

Understanding Forms in React

Forms are one of the most common ways users interact with web applications. Whether it's a login page, registration form, search bar, or contact form, React provides a simple and efficient way to handle form data.

What is a Form in React?

A form is used to collect user input. In React, form elements such as <input>, <textarea>, and <select> are typically controlled using state.

Example:

function LoginForm() {
  const [username, setUsername] = useState("");

  return (
    <input
      type="text"
      value={username}
      onChange={(e) => setUsername(e.target.value)}
      placeholder="Enter username"
    />
  );
}

In this example:

value connects the input to React state.
onChange updates the state whenever the user types.
React becomes the single source of truth for the input value.

Controlled Components

A controlled component is an input element whose value is controlled by React state.

import { useState } from "react";

function Form() {
  const [name, setName] = useState("");

  return (
    <input
      value={name}
      onChange={(e) => setName(e.target.value)}
    />
  );
}

How It Works

User types in the input.
onChange event fires.
State updates using setName.
Component re-renders.
Input displays the latest state value.

Flow:

User Input
    ↓
onChange Event
    ↓
State Update
    ↓
Re-render
    ↓
Updated UI

Handling Multiple Inputs

Instead of creating separate states for every field, use a single object.

import { useState } from "react";

function RegisterForm() {
  const [formData, setFormData] = useState({
    name: "",
    email: ""
  });

  const handleChange = (e) => {
    setFormData({
      ...formData,
      [e.target.name]: e.target.value
    });
  };

  return (
    <>
      <input
        name="name"
        value={formData.name}
        onChange={handleChange}
        placeholder="Name"
      />

      <input
        name="email"
        value={formData.email}
        onChange={handleChange}
        placeholder="Email"
      />
    </>
  );
}

Why Use `[e.target.name]`?

[e.target.name]: e.target.value

This dynamically updates the field that triggered the event.

If:

e.target.name = "email"

then:

{
  email: "arul@example.com"
}

gets updated automatically.

Form Submission

Use the onSubmit event on the form.

function LoginForm() {
  const [email, setEmail] = useState("");

  const handleSubmit = (e) => {
    e.preventDefault();

    console.log(email);
  };

  return (
    <form onSubmit={handleSubmit}>
      <input
        value={email}
        onChange={(e) =>
          setEmail(e.target.value)
        }
      />

      <button type="submit">
        Submit
      </button>
    </form>
  );
}

Why `preventDefault()`?

By default, submitting a form refreshes the page.

e.preventDefault();

prevents the page reload and allows React to handle the submission.

Handling Checkboxes

const [isChecked, setIsChecked] =
  useState(false);

<input
  type="checkbox"
  checked={isChecked}
  onChange={(e) =>
    setIsChecked(e.target.checked)
  }
/>

For checkboxes, use:

e.target.checked

instead of:

e.target.value

Handling Select Dropdowns

const [country, setCountry] =
  useState("");

<select
  value={country}
  onChange={(e) =>
    setCountry(e.target.value)
  }
>
  <option value="">Select</option>
  <option value="India">India</option>
  <option value="USA">USA</option>
</select>

Basic Form Validation

const handleSubmit = (e) => {
  e.preventDefault();

  if (!email) {
    alert("Email is required");
    return;
  }

  console.log("Form Submitted");
};

Common validations:

Required fields
Email format
Password length
Confirm password matching

Controlled vs Uncontrolled Components

Controlled Component

<input
  value={name}
  onChange={(e) =>
    setName(e.target.value)
  }
/>

Managed by React state
Easier validation
Preferred approach

Uncontrolled Component

const inputRef = useRef();

<input ref={inputRef} />

Managed by the DOM
Uses refs to access values
Less common in React applications

Best Practices

Use controlled components
Store related fields in a single state object
Validate before submission
Use meaningful field names
Prevent default form submission
Reuse a common handleChange function

Conclusion

React forms are built around state management. By using controlled components, handling events with onChange, and managing submissions with onSubmit, you can build scalable and maintainable forms.

Key concepts to remember:

Controlled Components
useState
onChange
onSubmit
preventDefault()
Form Validation
Handling Multiple Inputs

Mastering forms is a crucial step toward building real-world React applications.

Understanding React Rendering:

Arul .A — Mon, 15 Jun 2026 13:28:19 +0000

What is Rendering in React?

Rendering is the process where React converts your components into elements that the browser can display. Whenever the state or props of a component change, React re-renders the component to reflect the latest data.

Example:

function App() {
  const name = "Arul";

  return (
    <div>
      <h1>Hello, {name}</h1>
    </div>
  );
}

React renders the App component and displays:

Hello, Arul

Types of Rendering in React :

1. Initial Rendering:

This happens when a React application loads for the first time.

import ReactDOM from "react-dom/client";
import App from "./App";

const root = ReactDOM.createRoot(
  document.getElementById("root")
);

root.render(<App />);

React creates the component tree and displays it on the page.

2. Re-Rendering

A component re-renders when:

State changes
Props change
Parent component re-renders
Context value changes

Example:

import { useState } from "react";

function Counter() {
  const [count, setCount] = useState(0);

  return (
    <div>
      <h2>Count: {count}</h2>
      <button onClick={() => setCount(count + 1)}>
        Increment
      </button>
    </div>
  );
}

When the button is clicked, React updates the state and re-renders the component.

React Virtual DOM

React uses a Virtual DOM to improve performance.

How It Works

State changes.
React creates a new Virtual DOM.
React compares it with the previous Virtual DOM.
Only the changed elements are updated in the real DOM.

This process is called Reconciliation.

State Change
      ↓
Virtual DOM Update
      ↓
Compare Changes
      ↓
Update Real DOM

Reconciliation in React

Reconciliation is React's algorithm for determining what has changed in the UI.

Example:

function Greeting({ isLoggedIn }) {
  return (
    <h1>
      {isLoggedIn ? "Welcome Back!" : "Please Login"}
    </h1>
  );
}

React updates only the text inside the

instead of rebuilding the entire page.

Why Components Re-Render

Consider this example:

function Parent() {
  const [count, setCount] = useState(0);

  return (
    <>
      <button onClick={() => setCount(count + 1)}>
        Increment
      </button>
      <Child />
    </>
  );
}

function Child() {
  console.log("Child Rendered");

  return <h2>Child Component</h2>;
}

Every time the button is clicked, both Parent and Child re-render.

Preventing Unnecessary Re-Renders:

Using React.memo :

import React from "react";

const Child = React.memo(() => {
  console.log("Child Rendered");

  return <h2>Child Component</h2>;
});

export default Child;

Now the child component only re-renders when its props change.

Using useMemo:

import { useMemo } from "react";

const expensiveValue = useMemo(() => {
  return calculateValue();
}, []);

useMemo stores a computed value and recalculates it only when dependencies change.

Using useCallback:

import { useCallback } from "react";

const handleClick = useCallback(() => {
  console.log("Clicked");
}, []);

useCallback prevents function recreation on every render.

React Rendering Lifecycle:

Component Mounts
       ↓
Initial Render
       ↓
State/Props Change
       ↓
Re-Render
       ↓
Virtual DOM Comparison
       ↓
DOM Update

Dependency Injection in Spring Boot?

Arul .A — Sun, 14 Jun 2026 16:25:54 +0000

Introduction

Spring Boot is one of the most popular frameworks for building Java applications. One of its most powerful features is Dependency Injection (DI), which helps developers create flexible, maintainable, and scalable applications.

Dependency Injection allows Spring Boot to manage the creation and injection of objects automatically, reducing manual coding and improving application design.

What is Dependency Injection?

Dependency Injection is a design pattern where an object's dependencies are provided by an external source rather than being created inside the object itself.

A dependency is simply an object that another object needs to perform its work.

Without Dependency Injection

public class UserService {

    private UserRepository userRepository = new UserRepository();

}

In this example, UserService creates its own UserRepository object. This creates tight coupling between the two classes.

With Dependency Injection

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

}

Here, Spring Boot automatically creates and injects the UserRepository object into UserService.

Why is Dependency Injection Important?

Dependency Injection provides several benefits:

Reduces tight coupling between classes
Improves code maintainability
Makes unit testing easier
Encourages reusable components
Simplifies object management

These advantages make applications more scalable and easier to maintain over time.

Understanding Spring Beans

A Spring Bean is an object managed by the Spring IoC (Inversion of Control) Container.

Spring automatically creates beans for classes annotated with:

@Component
@Service
@Repository
@Controller
@RestController

The Spring Container is responsible for creating, configuring, and managing these beans throughout the application's lifecycle.

Common Annotations Used in Dependency Injection

@Component

The @Component annotation tells Spring that a class should be managed as a bean.

@Component
public class EmailService {

    public void sendEmail() {
        System.out.println("Email Sent");
    }
}

@Service

The @Service annotation is used for classes that contain business logic.

@Service
public class UserService {

    public String getUserDetails() {
        return "User Details";
    }
}

@Repository

The @Repository annotation is used for database-related operations.

@Repository
public class UserRepository {

    public String findUser() {
        return "Arul";
    }
}

@Autowired

The @Autowired annotation tells Spring to inject a required dependency automatically.

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public String getUser() {
        return userRepository.findUser();
    }
}

Constructor Injection (Recommended)

Constructor Injection is considered the best practice in modern Spring Boot applications.

@Service
public class UserService {

    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public String getUser() {
        return userRepository.findUser();
    }
}

Benefits of Constructor Injection

Better testability
Improved readability
Supports immutability
Clearly defines required dependencies

How Dependency Injection Works

The Spring Framework follows these steps:

Spring Boot starts the application.
Component scanning identifies annotated classes.
Spring creates bean instances.
Dependencies are detected.
Required beans are injected automatically.
The application becomes ready to handle requests.

This entire process is managed by the Spring IoC Container.

Real-World Example

Consider an Employee Management System.

Repository Layer

@Repository
public class EmployeeRepository {

    public String getEmployee() {
        return "Arul";
    }
}

Service Layer

@Service
public class EmployeeService {

    private final EmployeeRepository employeeRepository;

    public EmployeeService(EmployeeRepository employeeRepository) {
        this.employeeRepository = employeeRepository;
    }

    public String fetchEmployee() {
        return employeeRepository.getEmployee();
    }
}

Controller Layer

@RestController
@RequestMapping("/employee")
public class EmployeeController {

    private final EmployeeService employeeService;

    public EmployeeController(EmployeeService employeeService) {
        this.employeeService = employeeService;
    }

    @GetMapping
    public String getEmployee() {
        return employeeService.fetchEmployee();
    }
}

Request Flow

Client Request → Controller → Service → Repository → Database

Spring automatically injects the required dependencies at each layer.

Understanding React Router: Building Multi-Page Applications in React

Arul .A — Sat, 13 Jun 2026 16:38:33 +0000

Understanding React Router: Building Multi-Page Applications in React

Modern web applications often require multiple pages such as Home, About, Contact, and Projects. In React, we can achieve page navigation without reloading the browser using React Router.

What is React Router?

React Router is a library that enables navigation between different components in a React application. It allows developers to create Single Page Applications (SPA) with a seamless user experience.

Why Use React Router?

Faster navigation
No page reloads
Better user experience
Easy route management
Supports dynamic routing

Installation

Install React Router using npm:

npm install react-router-dom

Setting Up BrowserRouter

In the main entry file, wrap the application with BrowserRouter.

import ReactDOM from "react-dom/client";
import { BrowserRouter } from "react-router-dom";
import App from "./App";

ReactDOM.createRoot(document.getElementById("root")).render(
  <BrowserRouter>
    <App />
  </BrowserRouter>
);

Creating Routes

Inside App.jsx, define the application routes.

import { Routes, Route } from "react-router-dom";
import Home from "./pages/Home";
import About from "./pages/About";

function App() {
  return (
    <Routes>
      <Route path="/" element={<Home />} />
      <Route path="/about" element={<About />} />
    </Routes>
  );
}

export default App;

Navigation Using Link

The Link component is used to navigate between pages.

import { Link } from "react-router-dom";

<Link to="/">Home</Link>
<Link to="/about">About</Link>

Unlike traditional anchor tags, Link prevents full page reloads.

Creating a Navbar

import { NavLink } from "react-router-dom";

function Navbar() {
  return (
    <nav>
      <NavLink to="/">Home</NavLink>
      <NavLink to="/about">About</NavLink>
      <NavLink to="/projects">Projects</NavLink>
    </nav>
  );
}

Benefits of Keeping Navbar in App.jsx

A common mistake is adding the Navbar component to every page. Instead, place it once inside App.jsx.

Advantages:

No duplicate code
Easier maintenance
Consistent navigation
Better application structure

Real-World Example

Portfolio websites commonly use React Router for navigation between:

Home
About
Skills
Projects
Experience
Education
Contact

This creates a professional and organized user experience.

Conclusion

React Router is an essential library for React developers. It simplifies navigation, improves performance, and helps create modern Single Page Applications. Understanding routing is an important step toward building professional React projects such as portfolios, dashboards, and e-commerce applications.

Understanding useMemo in React

Arul .A — Fri, 12 Jun 2026 12:30:43 +0000

React provides several hooks to improve performance and manage state efficiently. One of these hooks is useMemo, which is used to memoize expensive calculations and avoid unnecessary re-computations during component re-renders.

What is useMemo?

useMemo is a React Hook that stores the result of a calculation and only recalculates it when one of its dependencies changes. This helps improve application performance by preventing expensive operations from running on every render.

Syntax

const memoizedValue = useMemo(() => {
  return expensiveCalculation();
}, [dependencies]);

The first argument is a function that returns a value.
The second argument is a dependency array.
React recalculates the value only when a dependency changes.

Why use useMemo?

When a component re-renders, all calculations inside the component are executed again. For simple calculations, this is not a problem. However, for expensive operations such as filtering, sorting, or processing large datasets, repeated calculations can affect performance.

useMemo helps by caching the result and reusing it until the dependencies change.

Example Without useMemo

import React, { useState } from "react";

function App() {
  const [count, setCount] = useState(0);
  const [text, setText] = useState("");

  console.log("Calculating...");
  const square = count * count;

  return (
    <div>
      <h2>Count: {count}</h2>
      <h2>Square: {square}</h2>

      <button onClick={() => setCount(count + 1)}>
        Increment
      </button>

      <input
        type="text"
        value={text}
        onChange={(e) => setText(e.target.value)}
      />
    </div>
  );
}

export default App;

In this example, typing in the input field causes the component to re-render, and the calculation runs again even though the count value has not changed.

Example With useMemo

import React, { useState, useMemo } from "react";

function App() {
  const [count, setCount] = useState(0);
  const [text, setText] = useState("");

  const square = useMemo(() => {
    console.log("Calculating...");
    return count * count;
  }, [count]);

  return (
    <div>
      <h2>Count: {count}</h2>
      <h2>Square: {square}</h2>

      <button onClick={() => setCount(count + 1)}>
        Increment
      </button>

      <input
        type="text"
        value={text}
        onChange={(e) => setText(e.target.value)}
      />
    </div>
  );
}

export default App;

Now the calculation runs only when the count value changes. Updating the input field will not trigger the calculation again.

Advantages of useMemo

Improves performance by avoiding unnecessary calculations.
Reduces processing time for expensive operations.
Useful when working with large datasets.
Helps optimize React applications.

When to Use useMemo

Use useMemo for:

Sorting large arrays
Filtering large datasets
Complex mathematical calculations
Creating stable object or array references

Example:

const sortedUsers = useMemo(() => {
  return users.sort((a, b) => a.age - b.age);
}, [users]);

When Not to Use useMemo

Do not use useMemo for simple calculations because it introduces its own overhead.

const total = a + b;

Using useMemo for simple operations often provides no performance benefit.

What is SQL? Understanding the Language of Databases

Arul .A — Thu, 11 Jun 2026 16:27:53 +0000

Introduction to SQL

SQL (Structured Query Language) is the standard language used to communicate with relational databases.
It allows users to store, retrieve, update, and manage data efficiently.
SQL is widely used in software development, data analysis, banking systems, e-commerce platforms, and enterprise applications.

Why SQL is Important

Modern applications generate and store large amounts of data.
SQL helps developers and database administrators organize and access this data quickly.
It provides a simple and powerful way to work with databases without needing to understand their internal structure.

Features of SQL

Easy to learn and use
Supports data storage and retrieval
Allows data modification and deletion
Provides security and access control
Supports data relationships through tables
Works with popular database systems such as PostgreSQL, MySQL, Oracle, and Microsoft SQL Server

Common SQL Commands

CREATE

Used to create a new table.

CREATE TABLE employee (
    id SERIAL PRIMARY KEY,
    name VARCHAR(50),
    department VARCHAR(50)
);

INSERT

Used to add data into a table.

INSERT INTO employee (name, department)
VALUES ('Arul', 'IT');

SELECT

Used to retrieve data from a table.

SELECT * FROM employee;

UPDATE

Used to modify existing data.

UPDATE employee
SET department = 'HR'
WHERE id = 1;

DELETE

Used to remove data from a table.

DELETE FROM employee
WHERE id = 1;

Types of SQL Commands

DDL (Data Definition Language)

Used to define database structures.

CREATE
ALTER
DROP
TRUNCATE

DML (Data Manipulation Language)

Used to manage data within tables.

INSERT
UPDATE
DELETE

DQL (Data Query Language)

Used to retrieve data.

SELECT

DCL (Data Control Language)

Used to manage permissions.

GRANT
REVOKE

TCL (Transaction Control Language)

Used to manage transactions.

COMMIT
ROLLBACK
SAVEPOINT

Advantages of SQL

Fast data retrieval
Efficient data management
Easy integration with applications
Supports large databases
Industry-standard database language

DEV Community: Arul .A

Why Use Collections Instead of Arrays in Java?

Why Use Collections Instead of Arrays in Java?

What is an Array?

What is a Collection?

Why Collections Instead of Arrays?

1. Dynamic Size

Array

Collection

2. Easy to Add and Remove Elements

3. Rich Built-in Methods

4. Easy Searching

5. Easy Sorting

6. Multiple Data Structures

7. Better Code Readability

Arrays vs Collections

When Should You Use Arrays?

When Should You Use Collections?

Conclusion

💬 Final Thoughts

Java Scanner Class

Java Scanner Class Explained

What is Scanner?

Why Do We Use Scanner?

Creating a Scanner Object

Example: Reading a String

Output

Common Scanner Methods

Reading an Integer

Reading Multiple Inputs

Difference Between next() and nextLine()

next()

nextLine()

Common Mistake

Why?

Solution

Why Do We Close Scanner?

Interview Questions

1. What is Scanner?

2. Why do we use Scanner?

3. Which package contains Scanner?

4. How do you create a Scanner object?

5. What is the difference between next() and nextLine()?

Conclusion

My Experience Attending a Java Developer Interview at Twite AI Technologies

My Experience Attending a Java Developer Interview at Twite AI Technologies

Self Introduction

Project Discussion

Key Features

1. Search Functionality

2. Category-Based Filtering

3. CSV File Support

4. Product Updates

5. Product Management

Questions Asked

What I Learned

Final Thoughts

JDBC Basics for Beginners

JDBC Basics for Beginners

What is JDBC?

JDBC Architecture

JDBC Steps

Step 1: Load the Driver

Step 2: Create a Connection

Step 3: Create a Statement

Step 4: Execute Query

Step 5: Read Data

Step 6: Close Resources

Example Program

Important JDBC Classes

Conclusion

SQL Interview Questions Asked in Solverines Technology Solutions – Technical Round

SQL Interview Questions Asked in Solverines Technology Solutions – Technical Round

1. Write a Query to Access the Last Record from a Table

2. Access the First Nth Row and Last Nth Row in a Table

Nth Row from the Beginning

Nth Row from the End

3. Retrieve Only the Nth Even and Odd Row in a Table

Nth Odd Row

Nth Even Row

Difference Between `next()` and `nextLine()`

`next()`

`nextLine()`

5. What is the difference between `next()` and `nextLine()`?

Why Use `[e.target.name]`?

Why `preventDefault()`?