DEV Community: Pavithraarunachalam

ArrayList in the Java Collection Framework.

Pavithraarunachalam — Thu, 28 Aug 2025 16:38:17 +0000

ArrayList Methods in java:

In Java, ArrayList is a part of the Java Collections Framework and provides many useful methods to store, manipulate, and retrieve data dynamically.

Commonly used ArrayList Methods:

1. Adding Elements:

add(E e)-> Adds the elements at the end

Example:

List.add("Apple");

add(int index, E e) → Adds an element at the specified index.

Example:

list.add(1, "Banana");

addAll(Collection c) → Adds all elements from another collection.

Example:

list.addAll(otherList);

2.Accessing Elements:

get(int index) → Returns the element at the given index.

Examples:

String fruit = list.get(0);

3. Changing Elements:

set(int index, E e) → Updates the element at the specified index.

Example:

list.set(1, "Mango");

4. Removing Elements:

remove(int index) → Removes the element at the given index.

Example:

list.remove(2);

remove(Object o) → Removes the first occurrence of the given element.

Example:

list.remove("Apple");

clear() → Removes all elements from the list.

Example:

list.clear();

Searching Elements:

contains(Object o) → Returns true if the list contains the element.

Example:

list.contains("Mango");

indexOf(Object o) → Returns the first index of the element, or -1 if not found.

Example:

int index = list.indexOf("Banana");

lastIndexOf(Object o) → Returns the last index of the element.

Example:

int index = list.lastIndexOf("Apple");

Size and Empty Check:

size() → Returns the number of elements in the list.

EXample:

int count = list.size();

isEmpty() → Returns true if the list is empty.

Example:

isEmpty() → Returns true if the list is empty.

7. Converting to Array:

toArray() → Converts the list to an array.

Example:

Object[] arr = list.toArray();

8. Iteration:

iterator() → Returns an iterator to traverse the list.
listIterator() → Returns a list iterator for forward and backward traversal.

Example:

Iterator<String> it = list.iterator();

9. Sorting (Using Collections):

Example:

Collections.sort(list);

Collections in Java

Pavithraarunachalam — Tue, 26 Aug 2025 16:59:36 +0000

what is collection in java?

A Collection in Java is like a container that is used to store a group of objects together and perform operations like adding, removing, searching, and sorting easily.
It is part of the Java Collection Framework in the java.util package.

Key Points:

Present in java.util package.
Dynamic size → can grow or shrink.
Built-in methods → add, remove, search, sort, etc.
Supports interfaces: List, Set, Queue, Map.

Main Parts of the Java Collection Framework:

Interface
Implementation class
Algorithms
Iterators

1. Interfaces:

They provide the blueprint for collections.

Main interfaces:

Collection (root interface)

List → Ordered, allows duplicates

Set → No duplicates

Queue → FIFO (First In First Out)

Map (separate, stores Key–Value pairs)

2. Implementations (Classes):

These are the actual classes that implement the interfaces.

Interface Common Classes

List - ArrayList, LinkedList, Vector, Stack

Set - HashSet, LinkedHashSet, TreeSet

Queue - PriorityQueue, LinkedList, ArrayDeque

Map - HashMap, LinkedHashMap, TreeMap, Hashtable

3. Algorithms:

Utility methods provided by the Collections class:

Sorting → Collections.sort(list)
Searching → Collections.binarySearch(list, key)
Shuffling → Collections.shuffle(list)
Reverse → Collections.reverse(list)

4. Iterators:

Used to traverse elements in a collection:

Iterator → Basic iterator, forward direction.
ListIterator → Forward & backward traversal.
Enumeration → Legacy iterator for older collections.

Method Overriding in Java..

Pavithraarunachalam — Wed, 30 Jul 2025 12:12:54 +0000

What is method overriding?

Method Overriding is a subclass(child class) to provide a specific implementation of a method that is already defined in its superclass(parent class).

Why use method overriding?

To change the behavior of a method in a subclass without modifying the superclass. It helps achieve runtime polymorphism (deciding which method to call during program execution).

Rules of Method Overriding in Java:

  - The method name must be the same.

  - The parameters (number and type) must be the same.

  - The return type must be the same (or covariant).

  -  The method in the parent class must not be:

              1. private (not accessible)

              2. final (cannot be changed)

              3. static (belongs to class not object)

              4. You can use @Override to help catch errors.

Constructor,this Keyword,Packages...

Pavithraarunachalam — Tue, 22 Jul 2025 09:12:50 +0000

Constructor:

Zero Argument constructor:

A zero-argument constructor is a constructor that takes no parameters.
You write it explicitly to set up default or custom values for an object.

Example:

class MyClass {
    // Zero-argument constructor
    MyClass() {
        System.out.println("Zero-argument constructor called");
    }
}

Default constructor:

A default constructor is a constructor that Java provides automatically only if you don’t define any constructor in your class. It:
- Takes no arguments.
- Initializes object with default values (like 0, null, false, etc.).

Example:

public class Student {
    int id;
    String name;
}

// Java automatically provides a default constructor:
// Student() { }

This:

This Keyword.
The this keyword in Java refers to the current object in a method or constructor.
This keyword is used to differentiate between local and global variable.
When local variable names are the same as instance variables, this is used to differentiate

Example:

public class Student {
    String name;

    public Student(String name) {
        this.name = name; 
    }
}

Package:

In java packages means folder.

Why use packages?

Avoid class name conflicts.
Make code easier to maintain and understand.

create package:

package com.indianBank;

compile package:

javac -d . classname.java

Run package:

java filename

Constructor in Java..

Pavithraarunachalam — Sun, 20 Jul 2025 16:10:04 +0000

Constructor:

In Java, a constructor is a special method used to initialize objects. It's called when an object of a class is created.
In constructor JVM is the default constructor.

What is the uses of constructor?

constructors are special methods used to initialize objects when they are created. They have the same name as the class and no return type (not even void).

Characteristics:

A constructor must have the same name as the class in which it is declared.
Constructors do not have a return type, not even void.
A constructor is automatically invoked when an object is created.
Java allows constructor overloading—you can define multiple constructors with different parameter lists.

Types of constructors:

1. Default constructor in java:

In default constructor they will not provide an arguments, provided by Java if no other constructor is defined.

Default constructor Example:

class Car {
       Car() {
        System.out.println("This is a car.");
    }
}

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car();  

    }
}

Output:

This is a car.

Arguments constructor in java:

Constructor arguments are values you pass to a constructor when you create an object.These arguments helps initialize the objects with specific values.

Argument constructor Example:

public class Market
{
static String marketName = "Pragyaa";
String prodname;
int price;

public Market(String s, int i)
{
System.out.println("I'm constructor");
prodname = s;
price = i; 
}

public static void main(String[] args)
{
Market prod1 = new Market("abc",100);
Market prod2 = new Market("xyz",2000);
System.out.println(prod1.prodname);
System.out.println(prod2.prodname);
System.out.println(prod2.price);
}
}

Output:

I'm constructor
I'm constructor
abc
xyz
2000

Method Overloading,Default Values..

Pavithraarunachalam — Wed, 16 Jul 2025 13:46:26 +0000

Method Overloading:

Method Overloading in Java means defining multiple methods with the same name in a class, but with different parameter lists.
It allows a class to perform similar actions in different ways based on the type or number of inputs.

Example:

public class SuperMarket
{
static String shopName="Pavithra";
String prodname;
int price;
public static void main(String []args)
{
SuperMarket Product1=new SuperMarket();
Product1.buy(10);
Product1.buy(15,100);
Product1.buy(10.5);
Product1.buy(10.5f);
System.out.println(10);
System.out.println(10.5f);
System.out.println("hii");
}
void buy(double dd)
{
System.out.println("buy one double arg"+dd);
}
void buy(int no)
{
System.out.println("buy one arg"+no);
}
void buy(int n01,int n02)
{
System.out.println("buy two args"+n01+""+n02);
}
}

`

Output:

buy one arg10
buy two args15100
buy one double arg10.5
buy one double arg10.5
10
10.5
hii

Default values:

In Java, default values are the values that Java automatically assigns to instance variables if you don’t give them a value.

For example, numbers get 0, booleans get false, and objects (like String) get null.
This happens only for variables declared in a class, not inside methods.

Local variables must be given a value before you use them — Java will show an error if you don’t.

Keyword,Return type,Method,Objects,Void&Variables...

Pavithraarunachalam — Tue, 15 Jul 2025 16:52:56 +0000

Keywords:

Static :

static keyword refers to class specific information.
Static keyword have only one memory copy.
In the static keyword class can common for all object.

Non-static:

Non-Static Keyword refers to object specific information.
Non static have multiple memory copy.
In the non static keyword object have the specific information.

Return Type:

The return statement is used to exit from a method and optionally pass a value back to the code that called the method.
Return statement is the last statement in the method definition.
If the method has a return type (like int, String, boolean, etc.), return sends a value of that type back.
If the method is declared as void, return; simply ends the method early (and doesn’t return any value).

Example:

String buy()
{
System.out.println("buy method");
return "thank you"
}

Method:

A method in Java is a block of code that performs a specific task. It is used to define behavior or functionality that can be reused.

Example:

String buy()
{
System.out.println("buy method");
}

Object:

In Java, an object is an instance of a class. It represents a real-world entity with state (data) and behavior (methods).

## Key concepts:

Class: A blueprint or template.
Object: A real thing created from the blueprint.

syntax for object:

Home Person = new Home();

Home - Home is the name of the class.
Person - Person is the name of the variable.
new Home - new Home is the keyword used to create new object from the class.

Void:

This method does not return anything.

It is used when a method performs an action, but doesn’t give back a result.

Variables:

Local Variables:

Local variable declared in side the function or block.

Global variables:

Global variable declared outside the function.

Today I Learned in Java -Data types and variables..

Pavithraarunachalam — Mon, 14 Jul 2025 08:54:14 +0000

Data Types:

In java there are two types of data types:

Primitive data type.
Non-Primitive data type.

Primitive data type:

Primitive data types are the basic building blocks that store simple values directly in memory.Primitive data types are fixed.

boolean
char
byte
int
short
long
float
double

Boolean:

Stores true or false values

char:

char Stores a single character/letter or ASCII values

byte:

Stores whole numbers from -128 to 127

int:
- Stores whole numbers from -2,147,483,648 to 2,147,483,647 ## short:
Stores whole numbers from -32,768 to 32,767

long:

Stores whole numbers from -32,768 to 32,767

float:

float temperature = 36.6f;
This stores a decimal number representing body temperature.

double:

Stores fractional numbers. Sufficient for storing 15 to 16 decimal digits

Non-Primitive data type:

Non primitive data types are non fixed They are ,

string
object
array

Variables:

Data types are used in variable,there are two types are variables they are,

Local variable
Global variable

Object oriented Programming in java..

Pavithraarunachalam — Fri, 11 Jul 2025 09:34:06 +0000

Introduction to OOPs in Java:

OOPs stands for Object-Oriented Programming System. It is a programming approach based on the concept of "objects", which contain data (variables) and methods (functions).
Java is an object-oriented programming language, meaning it follows the OOPs concepts to organize and design software.

Java oops concepts:

Class:

In Java, a class is a blueprint or template used to create objects. It defines the state (fields/attributes) and behavior (methods) that the created objects will have.

object:

An object is created from a class and holds its own copies of the class’s variables and can call the class’s methods.

Encapsulation:

Encapsulation is one of the four fundamental OOP principles in Java . It means wrapping data (variables) and code (methods) together as a single unit — and restricting direct access to some of an object’s components.

Polymorphism:

Polymorphism means "many forms." It allows objects to be treated as instances of their parent class, even if they behave differently. It’s a core concept in Object-Oriented Programming, enabling flexibility and reusability.

Inheritance:

Inheritance is a core concept in Object-Oriented Programming that allows one class to inherit the properties and behaviors (fields and methods) of another class.
It promotes code reuse, hierarchical classification, and extensibility.

Abstraction:

Abstraction is an OOP concept that focuses on hiding internal implementation details and only showing the essential features of an object.
Think of it like driving a car: You use the steering wheel and pedals without knowing how the engine or transmission actually works.

Introduction to java..

Pavithraarunachalam — Thu, 10 Jul 2025 13:03:01 +0000

what is java?

Java is a high-level, object-oriented programming language used to build web apps, mobile applications, and enterprise software systems. It is known for its Write Once, Run Anywhere capability, which means code written in Java can run on any device that supports the Java Virtual Machine (JVM).

Features of java:

1.Platform independence:
java's bytecode can be executed on any platform with the application JVM.

2.Object oriented:
Everything is treated as an object (real-world style).Helps organize and reuse code.

3.Simple:
Java's syntax is inspired by c++ and c.
4.Robust and secure:
Java has feature like memory management,strong type checking,and exception handling to ensure to bust ans secure programs

5.Multithreading:
Can do many tasks at once (like downloading and playing music together).Uses threads easily.
6.Dynamic:
Java supports dynamic memory allocation and garbage collection,simplifying memory management.

7.High performance:
Fast enough with Just-In-Time (JIT) compiler Slower than C++, but optimized for many tasks.

Java Architecture

Java Source Code
You write your Java program in plain text files with .java extension.
Java Compiler
The Java compiler (javac) converts your .java files into bytecode (.class files).
Bytecode is a kind of machine language, but it’s not for any specific computer — it’s for the Java Virtual Machine (JVM).
Java Virtual Machine (JVM)
The JVM reads and runs the bytecode.
It acts like a translator between the bytecode and your computer’s actual hardware.
This is why Java programs can run on any device that has a JVM — this is called "Write Once, Run Anywhere".
Java Runtime Environment (JRE)
The JRE includes the JVM plus some libraries and tools to run Java programs.
If you only want to run Java programs (not write or compile), you need the JRE.
Java Development Kit (JDK)
The JDK includes the JRE plus tools to write and compile Java code (like the compiler and debugger).
Developers use the JDK to create Java programs.

Today learned about promise in javascript.

Pavithraarunachalam — Mon, 30 Jun 2025 17:44:52 +0000

what is promise in javascript?

In JavaScript, a Promise is an object representing the eventual completion or failure of an asynchronous operation and its resulting value. It provides a structured way to handle asynchronous code, making it more manageable and readable than traditional callback-based approaches.

Basic Syntax:

const login =new promise((resolve,reject)=>{
let pass=true;
if(pass)
{
resolve();
}
else{
reject();
}
})

States of a Promise:

Pending – Initial state, neither fulfilled nor rejected.
Fulfilled – The operation completed successfully.
Rejected – The operation failed.

Creating a Promise:

A new Promise is created using the Promise constructor. This executor function receives two arguments: resolve andreject.

resolve(value) — called when the operation succeeds

reject(error) — called when it fails

Once you call either resolve or reject, the promise becomes settled (fulfilled or rejected) and cannot change.

Example:

<script>


     function login(){
        return new Promise((resolve,reject)=>{
        let password = true;
        if(password){
            resolve();
        }else{
            reject();
        }
    })
    }

    login()
    .then(()=> console.log("successfully login..."))
    .catch(()=>  console.log("invalid password..."))


</script>

A day of code,fun and learning at the JVM meetup in chennai.

Pavithraarunachalam — Sun, 29 Jun 2025 17:57:26 +0000

Yesterday, my friends and I attended the JVM meetup in Chennai. The event was organized by the JVM team, and they conducted various fun and educational activities related to Java.

As part of the activities, we were divided into teams of five. Each team was given 5 minutes to choose a team name and select a team leader. We named our team "5 Star".

After that, a Java debugging challenge was displayed on the screen. Each team was given 45 seconds to answer the question. If the time was up and the team couldn't answer, the question would be passed to the next team.

Since we are all freshers, we knew only a little bit of the answers, but we participated with enthusiasm and learned a lot.

Once the session ended, we had a short relaxation break, where we were given two Jim Jam biscuit baskets and juice.

Then, the presentation session started. During the session, the speakers explained the concepts of JAMStack and Spring AI.

JAM Stack:

JAMstack is a modern way to build websites. It stands for:

J – JavaScript (used to make the website interactive)

A – APIs (used to get data from a server or other services)

M – Markup (HTML pages that are shown to users)

Instead of using a traditional server, JAMstack sites are fast because they are mostly pre-built and served from a Content Delivery Network (CDN).

INTRODUCTION OT SPRING AI:

Spring AI is a project by the Spring team that simplifies integrating Artificial Intelligence (AI) and Large Language Models (LLMs) like OpenAI, Hugging Face, Ollama, or local models into Spring Boot applications.

What Is Spring AI?

Spring AI provides tools and pre-built integrations to:

Connect to AI models (like GPT, LLaMA, Claude, etc.)

Use AI features (text generation, embeddings, image generation)

Make it easy to build intelligent Java applications.