DEV Community: Preethi Nandhagopal

hashCode(),toString() and clone()

Preethi Nandhagopal — Sun, 05 Oct 2025 04:18:51 +0000

What is hashcode()?

hashCode() provides a numeric representation of an object for faster searching in hash-based collections.
If two objects are equal, they must return the same hash code, but the reverse is not always true.

What is toString()?

toString() is a method in the Object class (the root class of all Java classes).
Its purpose is to return a string representation of an object.
When you print an object (using System.out.println(object)), Java internally calls that object’s toString() method.
Default toString() → className + "@" + hashcode.
We override it to provide meaningful output of object state.
Often used in debugging, logging, and printing objects.

What is clone()?

clone() is a method in the Object class that is used to create a copy of an object.
The new object will have the same values as the original object.
To use clone(), a class must implement the Cloneable interface; otherwise, it throws CloneNotSupportedException.

Types of Cloning:

Shallow Copy (default clone):
Copies object’s fields as they are.
If the object contains references to other objects, only the references are copied (not the actual objects).
Deep Copy (custom clone):
Copies not only the object but also the objects it refers to.
Requires overriding clone() or using serialization.

StringBuffer/StringBuilder

Preethi Nandhagopal — Sun, 05 Oct 2025 04:16:01 +0000

Disadvantages of String:

Immutability leads to memory usage
Slower performance in modifications
High Garbage Collection (GC) load
Less efficient for dynamic text
Concatenation using + inside loops is costly

Notes:

Good for constant and read-only text.
Bad for frequent modifications → use StringBuilder / StringBuffer instead.

What is StringBuilder?

StringBuilder is a mutable (changeable) sequence of characters.
Unlike String (which is immutable), when you modify a StringBuilder object, it does not create a new object in memory — it updates the same object.
It was introduced in Java 1.5 to provide a faster, non-synchronized alternative to StringBuffer.
Faster than StringBuffer because it is not synchronized (not thread-safe).
Efficient for concatenation, insertion, deletion inside loops or large text operations.
Found in the package: java.lang.StringBuilder.

What is StringBuffer in Java?

StringBuffer is a mutable sequence of characters (like StringBuilder).
The main difference: StringBuffer is synchronized → which means thread-safe (can be safely used by multiple threads).
It was introduced in Java 1.0, before StringBuilder.
Because of synchronization, it is slower than StringBuilder, but safer in multithreaded programs.
Found in the package: java.lang.StringBuffer.

Common Methods in StringBuilder and StringBuffer:

append()->Adds text at the end
insert()->Inserts text at given index
replace()->Replaces characters in range
delete()->Deletes characters in range
reverse()->Reverses the string
capacity()->Returns current capacity
length()->Returns current length
charAt()->Returns char at index

How StrinBuilder Difference from StringBuffer?

StringBuffer is synchronized (thread-safe, but slower,Multithreaded program).
StringBuilder is not synchronized (faster, but not thread-safe,single threaded program).

LinkedHashSet and Queue

Preethi Nandhagopal — Tue, 30 Sep 2025 13:05:41 +0000

LinkedHashSet:

A LinkedHashSet is a class in Java that:
Implements the Set interface
It is part of java.util package.

Key Features:

Unique Elements -> Like all sets, it does not allow duplicates.
Maintains Insertion Order -> Unlike HashSet (which is unordered), LinkedHashSet keeps elements in the same order you inserted them.
Allows null -> Can store one null element.
Performance -> Almost same as HashSet (O(1) average time for add, remove, contains).
Slightly slower than HashSet because it also maintains a linked list for order.

Methods in LinkedHashSet:

Since it extends HashSet, it has the same methods:
add(E e) – add element
remove(Object o) – remove element
contains(Object o) – check if present
size() – number of elements
clear() – remove all elements
isEmpty() – check if empty

Queue:

Queue is a collection interface used to hold elements before processing, typically in FIFO (First-In-First-Out) order.
It is part of the Java Collections Framework and defined in:
java.util.Queue

Key Points:

Interface → Queue is an interface, not a class.
Order → Elements are usually processed in FIFO order, though some implementations (like PriorityQueue) order them differently.
Duplicates → Allowed.
Nulls → Some implementations allow one null (like LinkedList), but PriorityQueue does not.

Common Queue Methods:
(Specializes methods of Collection)

boolean add(E e) Inserts element, throws exception if full
boolean offer(E e) Inserts element, returns false if full
E remove() Removes head, throws exception if empty
E poll() Removes head, returns null if empty
E element() Retrieves head, throws exception if empty
E peek() Retrieves head, returns null if empty

LinkedList

Preethi Nandhagopal — Tue, 30 Sep 2025 13:00:40 +0000

LinkedList:

A LinkedList in Java is a doubly linked list implementation of the List and Deque interfaces, best when you need fast insertions and deletions but not random access.
A LinkedList is a linear data structure that stores elements in nodes, where each node contains:
The data (element)
A reference (pointer) to the next node
A reference (pointer) to the previous node (in case of doubly linked list)

Key Points:

Part of Java Collections Framework -> Defined in java.util package.
Implements List, Deque, Queue interfaces.
Dynamic size -> Unlike arrays, it can grow or shrink dynamically.
Allows duplicates & null -> Unlike Set, it allows duplicate elements and multiple null values.
Not synchronized -> Multiple threads can cause issues if not handled properly. Use Collections.synchronizedList() if needed.

Common Methods:

add(E e), addFirst(E e), addLast(E e) → Add elements
remove(), removeFirst(), removeLast() → Remove elements
get(int index), getFirst(), getLast() → Access elements
contains(Object o) → Check if element exists
size() → Number of elements
clear() → Remove all elements

Advantages:

Efficient insertion & deletion (O(1) if position known).
Can be used as a List, Queue, or Deque.

Disadvantages:

Accessing an element by index is slower (O(n)) compared to ArrayList’s O(1).
More memory usage (because of storing next & prev references).

Multithreading and Thread class method

Preethi Nandhagopal — Mon, 29 Sep 2025 04:41:56 +0000

Multithreading:
In Java, multithreading is a programming concept where two or more parts of a program (called threads) execute concurrently to maximize CPU utilization.
A thread is the smallest unit of a process.
So, when we use multithreading, a single program (process) can perform multiple tasks at the same time.

Key Points about Multithreading in Java:

Concurrency – Multiple tasks run simultaneously within a program.
Lightweight – Threads are smaller and faster than processes since they share the same memory space (heap).
Independent Execution – Each thread runs independently; if one thread faces an exception, others can still continue.
Java Support – Java provides built-in support for multithreading via:
Thread class
Runnable interface
Executor framework (for advanced thread handling)

Advantages of Multithreading:

Better CPU utilization (perform multiple operations at once).
Faster execution (tasks run in parallel).
Improves responsiveness (e.g., GUI apps remain responsive while performing background tasks).

Disadvantages:

Complexity – Writing multithreaded programs is harder.
Synchronization issues – Risk of race conditions if multiple threads access shared resources.
Debugging difficulty – Errors may be non-deterministic.

Thread class method:
The Thread class in Java (in java.lang package) provides several important methods to create, control, and manage threads.

Commonly Used Thread Class Methods:
1)start():
Starts a new thread and calls the run() method internally.
You should never call run() directly; use start().
2)run():
Defines the task to be executed by the thread.
Must be overridden when extending Thread or implementing Runnable.

Wrapper Class

Preethi Nandhagopal — Sat, 27 Sep 2025 05:19:58 +0000

Wrapper Class:
In Java, a Wrapper Class is a class that wraps (or “converts”) a primitive data type into an object.
This allows primitives to be treated as objects, so you can use them in Collections or call methods on them.

Primitive Types and Their Wrapper Classes:
Primitive Type Wrapper Class
byte -> Byte
short -> Short
int -> Integer
long -> Long
float -> Float
double -> Double
char -> Character
boolean -> Boolean

Why Wrapper Classes are Needed ?
1)Collections Requirement:
Collections (like ArrayList) can store objects only, not primitives.
ArrayList list = new ArrayList<>(); // int cannot be used directly
2)Utility Methods:
Wrapper classes provide useful methods, e.g., Integer.parseInt(), Double.valueOf().
3)Type Conversion:
Convert between strings and numbers.
int num = Integer.parseInt("123");
String str = Integer.toString(123);
4)Autoboxing and Unboxing:
Java automatically converts between primitives and wrapper objects:
Integer i = 10; // autoboxing
int j = i; // unboxing

Notes:
Primitive → basic data type, faster, stored in stack, no methods.
Wrapper Class → object version of primitive, stored in heap, can be used in Collections, has useful methods.

Why Objects are in Heap, Not Stack?

Dynamic Size:
Objects can vary in size at runtime.
Stack memory is fixed and small → not suitable for variable-size objects.
Long Lifetime:
Objects may need to live beyond the method that created them.
Stack variables disappear when the method ends.
Heap objects can stay as long as they are referenced.
Shared Access:
Multiple methods or threads may access the same object.
Stack memory is method-specific → cannot be shared.
Garbage Collection:
Heap allows automatic memory management using Garbage Collector.
Stack is automatically cleared, but you cannot track object references globally.

Set, HashSet, TreeSet and its Methods

Preethi Nandhagopal — Sat, 27 Sep 2025 05:02:35 +0000

Set:
A Set is a collection that does not allow duplicate elements. It models the mathematical set abstraction, which means each element is unique.

HashSet:
HashSet is a class in Java that implements the Set interface.
It stores unique elements, does not maintain insertion order, allows one null element, and provides fast operations using a hash table.

Key features:

HashSet is a class in java.util package.
It implements the Set interface.
It stores unique elements only (no duplicates allowed).
It does not maintain insertion order.
It allows one null element.
Internally, it uses a hash table for storage, which provides fast access.

Commonly Used Methods:

add(E e) → adds element.
remove(Object o) → removes element.
contains(Object o) → checks if element exists.
isEmpty() → checks if set is empty.
size() → number of elements.
clear() → removes all elements.
iterator() → to iterate through elements.

TreeSet:

TreeSet is a class in Java that implements the NavigableSet interface and is based on a Red-Black Tree (a type of self-balancing binary search tree).
It is best when you need a sorted collection of unique elements and want efficient searching and range queries.
Requires elements to be comparable (either implement Comparable or provide a Comparator).
Slower than HashSet for add/search/remove (because HashSet is O(1), TreeSet is O(log n)).

Key Features of TreeSet:

Sorted Order -> Stores elements in ascending (natural) order by default (like numbers in increasing order, strings in alphabetical order).
You can also provide a custom comparator to define your own sorting.
Unique Elements -> Like all sets, it does not allow duplicates.
No Null Elements -> Unlike HashSet, TreeSet does not allow null values (will throw NullPointerException).
Performance -> All basic operations (add, remove, search) take O(log n) time because of the Red-Black tree.
Implements NavigableSet -> Provides additional methods like first(), last(), ceiling(), floor(), headSet(), tailSet(), subSet() etc.

TreeSet Methods:

TreeSet implements NavigableSet, so it has all methods of Set, SortedSet, and NavigableSet.

Basic Set Methods:

boolean add(E e) → Adds an element (returns false if already present).
boolean remove(Object o) → Removes an element if present.
boolean contains(Object o) → Checks if the element exists.
void clear() → Removes all elements.
int size() → Returns the number of elements.
boolean isEmpty() → Checks if the set is empty.

List , ArrayList and Methods

Preethi Nandhagopal — Sat, 27 Sep 2025 04:44:50 +0000

List:

A List in Java is an ordered collection from the Collection framework that allows duplicate elements and provides index-based access.
Common implementations are ArrayList, LinkedList, Vector, and Stack.

Key Features of List:

1)Ordered collection → Elements are stored in insertion order.
2)Allows duplicates → Same element can appear more than once.
3)Index-based access → You can access elements using an index (like arrays).
4)Dynamic in size → Unlike arrays, lists can grow or shrink at runtime.
5)Supports CRUD operations → add, remove, update, search, etc.

Common Implementations of List:

ArrayList → Fast for searching, slow for insertion/deletion in middle.
LinkedList → Fast for insertion/deletion, slower for searching.
Vector → Similar to ArrayList but thread-safe.
Stack → Follows LIFO (Last In First Out) principle.

ArrayList:

An ArrayList in Java is a resizable array implementation of the List interface.
It allows duplicate elements, maintains insertion order, and provides fast index-based access, but is not synchronized by default.

Key features of ArrayList:

ArrayList is a class in java.util package.
It is a resizable array implementation of the List interface.
It stores elements in insertion order.
It allows duplicate elements.
It provides index-based access to elements.

Commonly Used Methods:

add(E e) -> Add element
add(int index, E e) -> Insert at position
get(int index) → Get element by index
set(int index, E e) -> Update element
remove(int index) / remove(Object o) → Remove element
size() → Number of elements
contains(Object o) -> Checks if element exists
clear() → Removes all elements
addAll(Collection c) -> Adds all elements from another collection.
removeAll(Collection c) -> Removes all elements that exist in another collection.
retainAll(Collection c) -> Keeps only the elements that exist in another collection (intersection).
isEmpty() -> Checks if the ArrayList is empty.
indexOf(Object o) -> Returns the index of the first occurrence of the element.
lastIndexOf(Object o) -> Returns the index of the last occurrence of the element.subList(int fromIndex, int toIndex)
Returns a part of the list (view).
toArray() -> Converts ArrayList into an array.
clone() -> Creates a shallow copy of the ArrayList.

Disadvantages of an Array, Framework and Collection

Preethi Nandhagopal — Fri, 26 Sep 2025 06:29:26 +0000

Disadvantages of Array:
1)Fixed Size
2)Wasted Memory or Insufficient Capacity
3)Only Homogeneous Data
4)No Built-in Methods for Advanced Operations:
Arrays don’t provide ready-made methods like searching, sorting, or resizing.
You need to write logic manually or use Arrays utility class, which is limited.
5)Memory Contiguity Requirement:
Arrays require continuous memory allocation.
For very large arrays, this may lead to OutOfMemoryError.
6)No Type Safety for Object Arrays:
When you create an array of objects, you can insert child class objects, but this may cause runtime errors if misused.

Frameworks:
A framework is a predefined set of classes, libraries, and tools provided by developers (or organizations) that helps you build applications more easily.

Keypoints of Frameworks:
1}Reusable Code – Provides pre-built functions and classes.
2)Standardization – Ensures developers follow common coding practices.
3)Productivity – Saves time because you don’t need to reinvent common features.
4)Integration – Comes with tools for database access, security, web handling, etc.

Benefits of Frameworks:
1)Faster Development:
Frameworks provide ready-made components, so you don’t need to code everything from scratch.
Example: Spring Boot, Spring, Hibernate etc.
2)Reusability:
Common tasks (like database connections, authentication, logging) are already available.
You can reuse code across multiple projects.
3)Consistency & Standardization:
All developers follow the same structure, making the code more organized and readable.
4)Security:
Many frameworks have built-in security features (like protection against SQL injection, XSS attacks, CSRF, etc.).
5)Testability:
Frameworks often come with built-in testing support (e.g., JUnit for unit testing in Java frameworks).

Collection:
A Collection in Java is a group of objects (called elements) that can be stored, retrieved, and manipulated together.
Java provides the Collection Framework (in java.util package) which gives ready-made classes and interfaces to store and process data efficiently.

Collection Framework Hierarchy:
Collection (Interface)
List → ArrayList, LinkedList, Vector, Stack
Set → HashSet, LinkedHashSet, TreeSet
Queue → PriorityQueue, ArrayDeque
Note:There’s also Map (HashMap, TreeMap, LinkedHashMap), but strictly speaking Map is not part of Collection interface, it’s part of the framework.

Keywords in Exception

Preethi Nandhagopal — Sun, 21 Sep 2025 11:07:42 +0000

Keywords in Exception:
1.What is try?

The try block contains the code that might throw an exception.
Only one try is allowed, but it can be followed by multiple catch blocks and/or one finally block.
Without a catch or finally, try cannot exist alone.
A try block written inside another try block is called a nested try.

What is catch?

The catch block is used to handle exceptions that occur inside the try block.
Each catch block can handle a specific type of exception (e.g., ArithmeticException, NullPointerException).
Multiple catch blocks allow different handling strategies for different exceptions.

try and catch in Java
In Java, exception handling is done using try, catch, finally, throw, and throws.
The most commonly used ones are try and catch, which work together to handle runtime errors (exceptions) gracefully, without stopping the program abruptly.

What is finally? The finally block in Java is used with try and catch for code that must execute no matter what happens (exception occurs or not). It is mostly used for resource cleanup (closing files, database connections, releasing memory, etc.).

Key Points:

Always Executes->Code inside finally will run whether an exception occurs or not.
Works with or without catch->You can use try-finally (without catch) if you only want cleanup logic.
Execution Order->First, try executes → if exception occurs, catch executes → then finally executes.
Common Use Case->Closing resources like file streams, sockets, database connections, etc.
Runs Even if Exception Not Caught->Even if there is no matching catch block, finally still executes before program ends.

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

Key Points:

Declaration, not handling->throws is used to declare exceptions, not to handle them.
Handling is done using try-catch.
Placed in Method Signature->Comes after the method parameters.
Example: void myMethod() throws IOException, SQLException { // code }
Used for Checked Exceptions->Mainly used to declare checked exceptions (like IOException, SQLException) because the compiler forces you to handle or declare them.
Multiple Exceptions->A method can declare multiple exceptions separated by commas.

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

Key Points:

Used to Actually Throw Exception->Unlike throws (which declares), throw is used inside a method to trigger an exception.
Example: throw new ArithmeticException("Cannot divide by zero");
Must be Inside a Method/Block->Cannot be used in method declaration (that’s throws).
Always used inside method, constructor, or block.

Exception Handling

Preethi Nandhagopal — Fri, 19 Sep 2025 05:46:59 +0000

Exception Handling:
Exception handling is a mechanism in Java that deals with runtime errors, allowing the program to continue its normal flow instead of crashing.
An exception is an unwanted or unexpected event that occurs during the execution of a program, disrupting its normal flow.

Keypoints:

Exceptions are problems that occur during execution, not syntax errors.
When an exception occurs, Java throws the exception object.
If not handled, the program terminates abnormally.
Exception handling helps catch and deal with these problems.

Exception:
An exception in Java is an event that disrupts the normal flow of a program’s execution. It usually occurs due to errors or unexpected situations at runtime, such as:

Division by zero
Accessing a null object
File not found
Invalid input from the user When an exception occurs, the normal flow of the program is interrupted, and Java creates an exception object that contains information about the errors.

Error:
An error in Java is a serious problem that arises during the execution of a program and typically cannot be handled or recovered from by the program itself.
Errors are usually caused by issues outside the application's control and indicate problems with the environment in which the program is running.

Examples of error:

OutOfMemoryError->Happens when the JVM runs out of memory.
StackOverflowError->Happens due to infinite recursion or excessive memory use in the call stack.
VirtualMachineError->Issues with the JVM itself.

Types of Exceptions:
Checked Exception:
Definition:
Checked exceptions are exceptions that are checked at compile-time.
The compiler ensures that these exceptions are either caught using try-catch or declared using the throws keyword in the method signature.

Key Features:

The program must handle them explicitly.
They typically occur due to external conditions, like file I/O errors or database problems.
If you don't handle them, the compiler will give an error.

Example:
IOException->Input/output errors->Reading from or writing to a file that doesn't exist.
FileNotFoundException->File cannot be found->Opening a file path that does not exist.

Unchecked Exceptions (Runtime Exceptions):
Definition:
Unchecked exceptions are exceptions that are checked at runtime, not at compile-time. The compiler does not require you to handle them explicitly.

Key Features:

They are usually programming bugs or logic errors.
Handling them is optional, but ignoring them can cause program crashes.
They are subclasses of RuntimeException.

Example:
ArithmeticException->Invalid arithmetic operation->Dividing by zero.
NullPointerException->Accessing a null reference->Calling a method on a null object.

Throwable Class:
Root class for all exceptions and errors.
It can be thrown or caught.
Provides methods like:

getMessage()
printStackTrace()
getCause()

Some basic keywords in Exceptions Handling:
try – Block where you write code that might throw an exception.
catch – Block that handles the exception.
finally – Block that executes after try-catch, whether an exception occurred or not.
throw – Used to explicitly throw an exception.
throws – Declares exceptions that a method might throw.

Static and Non Static Block

Preethi Nandhagopal — Tue, 16 Sep 2025 05:21:14 +0000

Static and Non Static Block:
A static block is a special block that gets executed once when the class is loaded into memory. It's used to initialize static variables or to perform setup operations
before the main method runs.

A block is a group of statements enclosed within curly braces {}. It defines a scope where variables can be declared and logic can be grouped.
Block and Constructor are called when an object is created.

Order of Execution:

Static block(s) → executed when the class is loaded (only once).

Instance block(s) → executed every time an object is created, before the constructor.

Constructor → executed after instance blocks when an object is created.

Main method → executed after class loading and static block execution.