java core

Java Basic Syntax
Java programs are built around classes. Each class can hold variables (data storage) and methods
(functions that perform actions). The main method is where a Java program starts running. The
System.out.println statement lets you print messages to the console.
Example: Hello World program
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
Data Types in Java

Java has various data types to represent different kinds of data. Some common ones include:
int: Stores whole numbers (e.g., 10, -5)
double: Stores decimal numbers (e.g., 3.14, -12.5)
char: Stores a single character (e.g., 'A', '$')
boolean: Stores true or false values
int num = 10;
double pi = 3.14;
char letter = 'A';
boolean flag = true;
Primitive vs. Non-Primitive Data Types

Primitive: These data types hold the actual value themselves. Examples are int, double, and char.
Non-Primitive: These data types hold references to objects in memory. An example is String which
stores text.
// Primitive data type
int num = 10;
// Non-primitive data type

String str = "Hello";
Java Identifiers
Identifiers are names you give to elements in your code like variables, methods, and classes. They
must start with a letter, underscore (_), or dollar sign ($), followed by letters, digits, underscores, or
dollar signs.
int myVariable = 10;
double averageScore = 85.5;
Java Operators
Java provides different operators to perform various operations on data. These include:
Arithmetic: +, -, *, / (for addition, subtraction, multiplication, and division)
Relational: ==, !=, <, >, <=, >= (for comparing values)
Logical: && (AND), || (OR), ! (NOT)
int a = 10;
int b = 5;
int sum = a + b; // Addition
int product = a * b; // Multiplication
Java Variables
Variables act like containers that hold data. They have a data type and a name, and their values can
change during program execution.
int num1 = 10;
double pi = 3.14;
Scope of Variables
The scope of a variable determines its visibility and lifetime within your code. Here are two main
types:
Local Variables: Declared inside methods and are only accessible within that method.
Instance Variables: Declared within a class but outside of any method, accessible throughout the
object's lifetime.
public class MyClass {
// Instance variable
int num = 10;
public void myMethod() {

// Local variable
int localVar = 20;
System.out.println("Instance variable: " + num);
System.out.println("Local variable: " + localVar);
}
}
Java Wrapper Classes

Wrapper classes provide a way to convert primitive data types into objects. This allows you to use
some additional functionalities available for objects.
Integer num1 = new Integer(10);
Double pi = new Double(3.14);
Taking Input from Users in Java

Explanation: Taking input from users is a fundamental aspect of interactive Java programs. It allows
users to provide data to the program during its execution, enabling dynamic behavior.
import java.util.Scanner;
public class InputExample {

Scanner scanner = new Scanner(System.in);
System.out.print("Enter your name: ");
String name = scanner.nextLine();
System.out.println("Hello, " + name + "!");
scanner.close();
}
}
Scanner Class:
The Scanner class (from java.util) is the most common and convenient way to get user input.
Create a Scanner object, typically named sc, using System.in as the input stream:
public class Main {
Scanner sc = new Scanner(System.in);
}
}
nextInt(): Reads an integer.

nextDouble(): Reads a double.
nextLine(): Reads a whole line of text (including spaces).
next(): Reads the next word (delimited by whitespace).

String name = sc.nextLine();
System.out.print("Enter your age: ");
int age = sc.nextInt();
System.out.println("Hello, " + name + "! You are " + age + " years old.");
BufferedReader Class:
BufferedReader (from java.io) is an older approach, useful for low-level character-by-character
reading.
It requires more setup, including an InputStreamReader to convert bytes to characters:
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class Main {

public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
// ...
}
}
Use readLine() to read a line of text:

String name = br.readLine();
BufferedReader is less common in modern Java due to Scanner's simplicity.
Scanner vs. BufferedReader:

Scanner: Easier to use, provides methods for various data types, throws exceptions for invalid input.
BufferedReader: More low-level, requires more setup, can be less intuitive.
Ways to Read Input from Console in Java:

Primarily through Scanner or BufferedReader as described above.
For advanced scenarios, consider low-level input streams like System.in.
Console();
Printing Output:
1. System.out.print():
Prints to the console without a newline at the end.
2. System.out.println():
Prints to the console with a newline character (\n) at the end.
System.out.println("Hello, " + name + "! You are " + age + " years old.");
Difference Between print() and println():

print() keeps the cursor on the same line after printing.
println() moves the cursor to the next line after printing.
Formatted Outputs in Java:

Use printf() or format() for precise control over output formatting.
Specify format specifiers within placeholders (%s, %d, etc.) for different data types
System.out.printf("Your name is: %s\n", name);

System.out.printf("Your age is: %d\n", age);
Fast Input-Output for Competitive Programming:
Consider libraries like FastReader or custom input/output classes.
These libraries often use buffered input/output techniques for faster performance.
Important Note: While these libraries can be helpful, focus on core concepts first, and optimize for
speed only when necessary.
Remember:
Close the Scanner object using sc.close() when you're done with it to release resources.
Handle potential exceptions (like InputMismatchException) from Scanner methods to ensure
robustness in case of invalid user input.
Decision Making in Java:
Decision making in Java involves choosing between different paths of execution based on certain
conditions.
Java provides conditional statements like if, if-else, and if-else-if ladder for decision making.
If Statement in Java:
The if statement is used to execute a block of code only if a specified condition is true.
Syntax:
java
if (condition) {
// Code to be executed if condition is true
}
If-Else Statement in Java:
The if-else statement is used to execute one block of code if a specified condition is true and another
block of code if the condition is false.
Syntax:
java
if (condition) {
// Code to be executed if condition is true
} else {
// Code to be executed if condition is false
}
If-Else-If Ladder in Java:
The if-else-if ladder is used when there are multiple conditions to be checked sequentially.
Syntax:
java
if (condition1) {
// Code to be executed if condition1 is true
} else if (condition2) {
// Code to be executed if condition2 is true
} else {
// Code to be executed if all conditions are false
}
Loops in Java:
Loops in Java are used to execute a block of code repeatedly until a certain condition is met.
Java supports for, while, do-while, and for-each loops.
For Loop:
The for loop is used to iterate over a range of values or to execute a block of code a fixed number of
times.
Syntax:
java
for (initialization; condition; update) {

// Code to be executed
}
While Loop:
The while loop is used to repeatedly execute a block of code as long as a specified condition is true.
Syntax:
java
while (condition) {
}
Do-While Loop:
The do-while loop is similar to the while loop, but it guarantees that the block of code is executed at
least once before checking the condition.
Syntax:
java
do {
} while (condition);
For Each Loop:
The for-each loop is used to iterate over elements in an array or collection sequentially.
Syntax:
for (datatype element : array/collection) {

}
Continue Statement in Java:
The continue statement is used to skip the current iteration of a loop and proceed to the next
iteration.
It is often used within loops to skip certain iterations based on a condition.
Break Statement in Java:
The break statement is used to exit a loop prematurely.

It can be used to terminate the loop based on a certain condition or to exit the loop immediately.
Usage of Break in Java:
break can be used in various scenarios, such as:

Terminating a loop when a specific condition is met.
Breaking out of nested loops.
Exiting a switch statement.
Return Statement in Java:
The return statement is used to exit a method and optionally return a value to the caller.
It is often used to return a result or terminate the execution of a method prematurely.
Certainly! Here's an explanation of each type of operator along with examples:
Arithmetic Operator:
Arithmetic operators are used to perform mathematical operations on operands.

Examples include addition +, subtraction -, multiplication *, division /, and modulus %.
int a = 10;
int b = 5;
int sum = a + b; // Addition
int difference = a - b; // Subtraction
int product = a * b; // Multiplication
int quotient = a / b; // Division
int remainder = a % b; // Modulus
Unary Operator:
Unary operators operate on a single operand.
Examples include unary plus +, unary minus -, increment ++, and decrement --.
int x = 5;
int y = -x; // Unary minus
int z = ++x; // Pre-increment
int w = x--; // Post-decrement
Assignment Operator:
Assignment operators are used to assign values to variables.

Examples include =, +=, -=, *=, /=, and %=.
java
int a = 10;
a += 5; // Equivalent to a = a + 5
Relational Operator:
Relational operators are used to compare two values.

Examples include equal to ==, not equal to !=, greater than >, less than <, greater than or equal to >=,
and less than or equal to <=.
int a = 10;
int b = 5;
boolean result = a > b; // Greater than
Logical Operator:
Logical operators are used to perform logical operations on boolean values.
Examples include logical AND &&, logical OR ||, and logical NOT !.
boolean x = true;
boolean y = false;
boolean result = x && y; // Logical AND
Ternary Operator:
Ternary operator is a conditional operator that takes three operands.

Syntax: condition ? expression1 : expression2
If the condition is true, expression1 is evaluated; otherwise, expression2 is evaluated.
int a = 10;
int b = 5;
int max = (a > b) ? a : b; // Ternary operator to find the maximum of two numbers
Bitwise Operator:
Bitwise operators perform operations on individual bits of operands.

Examples include bitwise AND &, bitwise OR |, bitwise XOR ^, bitwise complement ~, left shift <<,
and right shift >>.
int a = 5; // 101 in binary

int b = 3; // 011 in binary
int result = a & b; // Bitwise AND (result is 1)
Introduction of Strings in Java:

Strings in Java represent sequences of characters and are objects of the java.lang.String class.
They can be created using string literals or by using the String class constructor. String literals are
stored in the string pool, a special memory area in the Java heap, to conserve memory and facilitate
efficient string reuse. Here's an example:
String str1 = "Hello, World!"; // Using string literal
String str2 = new String("Hello, World!"); // Using String constructor
In this example, both str1 and str2 represent the same string, but they are stored differently in
memory.
Why Strings are Immutable in Java?:
Strings in Java are immutable, meaning their values cannot be changed once they are created. This
immutability ensures that once a string is created, its contents remain constant throughout its
lifetime. There are several reasons for this design choice:
Security: Immutable strings are safe to share across different parts of a program, including libraries
and frameworks, without the risk of unexpected modifications.
Thread Safety: Immutable strings are inherently thread-safe, as they cannot be modified
concurrently by multiple threads.
Caching: String literals are cached in the string pool, allowing multiple references to the same string
literal to point to the same memory location. This saves memory and improves performance by
reducing the number of string objects created.
StringBuffer class in Java and StringBuilder class in Java:
StringBuffer and StringBuilder are classes provided by Java for string manipulation. They
both allow for mutable sequences of characters, meaning their contents can be modified after they
are created. However, they differ in terms of thread safety and performance:
StringBuffer: This class is thread-safe, meaning its methods are synchronized to prevent concurrent
access issues in multi-threaded environments. While this synchronization ensures thread safety, it
can lead to performance overhead in single-threaded scenarios.
StringBuilder: This class is not thread-safe, but it offers better performance than StringBuffer in
single-threaded scenarios. Since it does not perform synchronization, it is more efficient when only a
single thread is accessing the string.
Here's an example demonstrating the usage of StringBuffer and StringBuilder:
StringBuffer buffer = new StringBuffer("Hello");
StringBuilder builder = new StringBuilder("World");
buffer.append(", Java!"); // Modify StringBuffer
builder.append(", Java!"); // Modify StringBuilder

Strings vs StringBuffer vs StringBuilder in Java:
Strings, StringBuffer, and StringBuilder are all used for handling strings in Java, but they
have different characteristics and usage scenarios:
Strings: Immutable and thread-safe, suitable for situations where the value should not change.
They are commonly used for representing constant values and for text manipulation where
immutability is desired.
StringBuffer: Mutable and thread-safe, suitable for multi-threaded scenarios where string
manipulation is required. It is slower than StringBuilder due to the overhead of
synchronization.
StringBuilder: Mutable but not thread-safe, suitable for single-threaded scenarios where
performance is critical. It is faster than StringBuffer because it does not perform
synchronization.
Choose the appropriate class based on the specific requirements of your application.
StringJoiner in Java:
StringJoiner is a utility class introduced in Java 8 to simplify the task of joining multiple strings
with a delimiter. It allows you to construct sequences of characters separated by a specified
delimiter, with optional prefix and suffix. Here's an example:
StringJoiner joiner = new StringJoiner(", ", "[", "]");
joiner.add("Apple");
joiner.add("Banana");
joiner.add("Orange");
String result = joiner.toString(); // Output: "[Apple, Banana, Orange]"
In this example, the StringJoiner joins the strings "Apple", "Banana", and "Orange" with a
comma and space as the delimiter, and encloses the result within square brackets.
Java String Programs:
Java strings offer a wide range of methods and functionalities for string manipulation. Here are some
common operations:
String Manipulation: Concatenation, substring extraction, replacing characters, converting

case, trimming whitespace, etc.
String Searching and Matching: Searching for substrings, checking for containment,
checking equality, comparing strings, etc.
String Parsing: Splitting strings into substrings, tokenizing based on delimiters, formatting
strings, etc.
String Formatting: Using String.format() or printf() methods to format strings with

placeholders, such as %s for strings, %d for integers, %f for floating-point numbers, etc.
Here's a simple example demonstrating some of these operations:

// String manipulation
String str = "Hello, World!";
String newStr = str.substring(0, 5); // Extract substring "Hello"
// String searching and matching

boolean contains = str.contains("World"); // Check if string contains "World"
// String parsing
String[] tokens = str.split(", "); // Split string into tokens
// String formatting
String formattedStr = String.format("Length of '%s' is %d", str, str.length());
These operations showcase the versatility and power of Java strings for various programming tasks.
Introduction to Arrays in Java:

Arrays in Java are used to store multiple values of the same type under a single variable name. They
provide a way to work with collections of values efficiently.
// Declaration and initialization of an array of integers

int[] numbers = {1, 2, 3, 4, 5};
In this example, numbers is an array of integers containing five elements. Each element can be
accessed using its index (e.g., numbers[0] refers to the first element).
Declaration and Initialization of Arrays in Java:

Arrays can be declared and initialized in various ways:
// Declaring an array of strings with a specified size

String[] names = new String[5];
names[0] = "Alice";
names[1] = "Bob";
// ...
// Declaring and initializing an array using the 'new' keyword

double[] scores = new double[]{98.5, 87.0, 92.5};
Here, names is an array of strings with a size of 5. Elements of the array can be accessed using index
numbers, starting from 0.
Multi-Dimensional Arrays / Initializing 2D Arrays in Java:

Java supports multi-dimensional arrays, such as 2D arrays:
// Declaration and initialization of a 2D array

int[][] matrix = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
In this example, matrix is a 2D array with 3 rows and 3 columns. Elements can be accessed using two
indices, one for the row and one for the column.
Jagged Array in Java:

Jagged arrays are arrays of arrays where each row can have a different number of elements:
// Declaration and initialization of a jagged array

int[][] jaggedArray = {
{1, 2},
{3, 4, 5},
{6, 7, 8, 9}
};
In this example, jaggedArray is a jagged 2D array where the first row has 2 elements, the second row
has 3 elements, and the third row has 4 elements.
Final Arrays in Java:

Arrays can be declared as final, meaning the reference to the array cannot be changed, but the
elements of the array can be modified:
final int[] finalArray = {1, 2, 3};

finalArray[0] = 10; // Valid
// finalArray = new int[]{4, 5, 6}; // Error: Cannot assign a new array to finalArray
Here, finalArray is a final array, so you cannot reassign it to a new array, but you can still modify its
elements.
Reflect Arrays in Java:

The java.lang.reflect.Array class provides static methods to dynamically create and access arrays:
import java.lang.reflect.Array;
Object array = Array.newInstance(int.class, 3);

Array.set(array, 0, 1);
System.out.println(Array.get(array, 1)); // Output: 2
In this example, we dynamically create an array of integers using the Array.newInstance method and
set and get values using Array.set and Array.get methods.
Difference between util.Arrays and reflect.Arrays:

java.util.Arrays provides utility methods for manipulating arrays in a straightforward manner, while
java.lang.reflect.Array provides methods for dynamically creating and accessing arrays, mainly used
in reflection.
Java Array Programs:

You can write various programs using arrays. Here are some examples:
Binary Search
Bubble Sort
Matrix Operations
Finding Maximum or Minimum Element
Finding Duplicate Elements
String Operations (e.g., palindrome check)
OOPS Concept in Java:

Object-Oriented Programming (OOP) is a programming paradigm that revolves around the concept of
objects. Java is an object-oriented language, meaning it uses objects and classes as its main building
blocks. Objects represent real-world entities, while classes act as blueprints for creating objects.
class Car {
// Attributes
String brand;
String model;
// Method
void drive() {
System.out.println("Driving the " + brand + " " + model);
}
}
Car myCar = new Car(); // Creating an object

myCar.brand = "Toyota";
myCar.model = "Camry";
myCar.drive(); // Output: Driving the Toyota Camry
Why Java is not a purely Object-Oriented Language?
Java is not considered purely object-oriented because it supports primitive data types like int, char,
float, etc., which are not objects. Additionally, Java has static methods and variables, which belong to
the class rather than to any instance of the class.
Classes and Objects:

Classes in Java are templates for creating objects. They define the structure and behavior of objects.
Objects, on the other hand, are instances of classes. They have state (attributes) and behavior
(methods).
class MyClass {
int myVariable;
void myMethod() {
System.out.println("Hello from MyClass!");
}
}
MyClass obj = new MyClass(); // Creating an object

obj.myMethod(); // Output: Hello from MyClass!
Naming Convention in Java:

Java follows certain naming conventions to write clean and readable code. For example:
Class names should start with an uppercase letter.

Variable and method names should start with a lowercase letter and follow camelCase.
Constants should be in all uppercase letters with underscores.
class NamingConventionExample {
int myVariable;
void myMethod() {
final int MAX_VALUE = 100;
// ...
}
}
Methods in Java:
Methods in Java define behavior. They are blocks of code that perform specific tasks. Methods can
have parameters and can return values.
class MathOperations {
// Method with parameters and return value
int add(int a, int b) {
return a + b;
}
// Method without parameters and return value

void greet() {
}
}
Access Modifiers in Java:
Access modifiers control the visibility of classes, variables, methods, and constructors in Java. There
are four access modifiers: public, protected, private, and default (no modifier).
public class AccessModifiersExample {

private int privateVariable;
public void publicMethod() {
// ...
}
}
Constructors in Java:
Constructors are special methods used to initialize objects. They have the same name as the class
and are called when an object is created. Constructors can be parameterized or non-parameterized.
class Person {
String name;
// Parameterized constructor
public Person(String n) {
name = n;
}
}
These concepts form the foundation of Java programming. Understanding them is essential for
writing effective and maintainable Java code. Let me know if you need further clarification or more
examples for any specific topic!
Four Pillars of OOPS in Java:
Encapsulation: Encapsulation is the bundling of data (attributes) and methods (behaviors) that
operate on the data into a single unit (class). It helps in hiding the internal state of an object and only
exposing the necessary functionalities to the outside world.
class Person {
private String name;
private int age;
// Getter and setter methods for encapsulation

public String getName() {
return name;
}
public void setName(String name) {

this.name = name;
}
public int getAge() {

return age;
}
public void setAge(int age) {

if (age > 0) {
this.age = age;
}
}
}
Inheritance: Inheritance is a mechanism in Java where a new class (subclass) can inherit properties
and behavior from an existing class (superclass). It promotes code reusability and establishes a
relationship between classes.
class Animal {
void eat() {
System.out.println("Animal is eating");
}
}
class Dog extends Animal {

void bark() {
System.out.println("Dog is barking");
}
}
// Creating an object of subclass Dog

Dog myDog = new Dog();
myDog.eat(); // Output: Animal is eating
myDog.bark(); // Output: Dog is barking
Abstraction: Abstraction is the process of hiding the implementation details and showing only the
essential features of an object. In Java, abstraction is achieved using abstract classes and interfaces.
// Abstract class
abstract class Shape {
abstract void draw(); // Abstract method
}
// Concrete subclass
class Circle extends Shape {
void draw() {
System.out.println("Drawing a circle");
}
}
Polymorphism: Polymorphism means having many forms. In Java, polymorphism can be achieved
through method overloading and method overriding. It allows objects of different classes to be
treated as objects of a common superclass.
// Method overloading
return a + b;
}
double add(double a, double b) {

return a + b;
}
}
// Method overriding
class Animal {
void makeSound() {
System.out.println("Animal is making a sound");
}
}

void makeSound() {
}
}
Interfaces in Java:
Interfaces in Java define a contract that classes must adhere to. They contain only method signatures
(without implementation) and constants. Classes implement interfaces to provide specific behavior.
Interfaces are used to achieve abstraction and provide a way for unrelated classes to communicate
with each other.
// Interface
interface Animal {
void eat();
void sleep();
}
// Class implementing the interface

class Dog implements Animal {
public void eat() {
System.out.println("Dog is eating");
}
public void sleep() {

System.out.println("Dog is sleeping");
}
}
These four pillars of OOP, along with interfaces, are fundamental concepts in Java programming.
Understanding and applying them correctly leads to well-structured and maintainable code. Let me
know if you need further explanation or additional examples!
Introduction to Inheritance in Java:

Inheritance is a fundamental concept in object-oriented programming (OOP) that allows a new class
(subclass or derived class) to inherit attributes and methods from an existing class (superclass or
base class). In Java, inheritance promotes code reusability and establishes a relationship between
classes. Subclasses can extend the functionality of superclasses by inheriting their properties and
behaviors.
Inheritance and Constructors:

In Java, when a subclass is created, it automatically inherits the constructors of its superclass. If the
superclass has a parameterized constructor, the subclass constructor must call it using the super()
keyword as the first statement in its constructor. If no constructor is explicitly defined in the
superclass, Java provides a default constructor.
Multiple Inheritance in Java:

Java does not support multiple inheritance for classes. Multiple inheritance refers to a scenario
where a subclass inherits from more than one superclass. This is not allowed in Java to avoid the
diamond problem, where ambiguity arises if two superclasses have a common superclass. However,
Java supports multiple inheritance through interfaces, where a class can implement multiple
interfaces.
Interfaces and Inheritance:

Interfaces in Java provide a way to achieve multiple inheritance. An interface is a reference type that
can contain only constants and abstract methods. A class implements an interface, thereby inheriting
the abstract methods declared in the interface. By implementing multiple interfaces, a class can
achieve multiple inheritance of types.
Association, Aggregation, and Composition:

Association, aggregation, and composition are types of relationships between classes in object-
oriented design.
Association: Represents a relationship between two classes where objects of one class are related to
objects of another class.
Aggregation: Represents a "has-a" relationship where one class contains objects of another class, but
the contained objects can exist independently of the container class.
Composition: Represents a strong form of aggregation where the lifetime of the contained objects
depends on the lifetime of the container class. If the container class is destroyed, the contained
objects are also destroyed.
Difference between Inheritance in C++ and Java:
While both Java and C++ support inheritance, there are some differences between how they
implement it:
Multiple Inheritance: C++ supports multiple inheritance for classes, allowing a class to inherit from
multiple base classes. Java does not support multiple inheritance for classes to avoid the diamond
problem. However, Java supports multiple inheritance through interfaces.
Access Specifiers: In C++, the default access specifier for members of a class is private, whereas in
Java, it is package-private. Java has four access specifiers (public, protected, private, and default)
compared to C++'s three access specifiers (public, protected, and private).
Virtual Functions: In C++, member functions are virtual by default, meaning they can be overridden
in derived classes. In Java, methods are not virtual by default, and you need to explicitly declare a
method as final to prevent it from being overridden, or as abstract to force subclasses to override it.
Introduction to Encapsulation in Java:

Encapsulation is a fundamental concept in object-oriented programming (OOP) that involves
bundling the data (variables) and methods (functions) that operate on the data into a single unit
called a class. The key idea behind encapsulation is to hide the internal state of an object and only
expose the necessary functionality to the outside world. This is achieved by marking the internal data
members as private and providing public methods (getter and setter methods) to access and modify
the data.
In Java, encapsulation is typically implemented using access modifiers (private, protected, default,
public) to control the visibility and accessibility of class members. Private instance variables are used
to store the object's state, and public methods are provided to manipulate this state while hiding the
implementation details from the outside world. Encapsulation promotes data hiding, access control,
modularity, and security in Java programs.
Difference between Encapsulation and Abstraction:

While encapsulation and abstraction are closely related concepts in OOP, they serve different
purposes and focus on different aspects of software design:
Encapsulation:
Encapsulation involves bundling the data (variables) and methods (functions) that operate on the
data into a single unit called a class.
It focuses on hiding the internal state of an object and controlling access to it by using access
modifiers (private, protected, default, public).
Encapsulation promotes data hiding, access control, modularity, and security in Java programs.
Abstraction:
Abstraction is the process of hiding the implementation details of a class and showing only the
essential features or behavior of an object to the outside world.
It involves defining a clear and concise interface for interacting with objects, while hiding the internal
complexity and implementation details.
Abstraction allows you to work at a higher level of abstraction by focusing on what an object does
rather than how it does it.
In Java, abstraction is often achieved using abstract classes and interfaces, which define method
signatures without providing the implementation details. Subclasses then provide their own
implementations of these methods.
In summary, encapsulation is about bundling data and methods into a single unit and controlling
access to the internal state of an object, while abstraction is about hiding the implementation details
of a class and providing a simplified interface for interacting with objects. Both encapsulation and
abstraction are important principles in Java programming and are often used together to create
modular, maintainable, and extensible code.
Introduction to Polymorphism in Java:

Polymorphism is a core concept in object-oriented programming (OOP) that allows objects of
different types to be treated as objects of a common superclass. It enables a single interface to
represent multiple types of objects, allowing for flexibility and code reusability. Polymorphism in Java
is achieved through method overriding and method overloading.
Difference between Inheritance and Polymorphism:

Inheritance: Inheritance is a mechanism by which a subclass inherits properties and behaviors from a
superclass. It establishes an "is-a" relationship between classes, where a subclass is a specific type of
the superclass. Inheritance promotes code reuse and allows for the creation of hierarchical class
structures.
Polymorphism: Polymorphism, on the other hand, refers to the ability of an object to take on
multiple forms. It allows objects of different classes to be treated as objects of a common superclass.
Polymorphism enables dynamic method invocation, where the appropriate method implementation
is determined at runtime based on the actual type of the object.
Runtime Polymorphism in Java:
Runtime polymorphism, also known as dynamic polymorphism or late binding, occurs when a
method in a subclass overrides a method with the same signature in its superclass. The decision of
which method to call is made at runtime based on the actual type of the object. Runtime
polymorphism allows for more flexible and dynamic behavior, as the method implementation can
vary depending on the specific type of the object.
Compile-Time vs Runtime Polymorphism:

Compile-Time Polymorphism: Also known as static polymorphism or early binding, compile-time
polymorphism occurs when the method to be invoked is determined at compile time based on the
method signature. Method overloading is an example of compile-time polymorphism, where
multiple methods with the same name but different parameters can coexist in the same class.
Runtime Polymorphism: Runtime polymorphism, as discussed earlier, occurs when the method to be
invoked is determined at runtime based on the actual type of the object. Method overriding is an
example of runtime polymorphism, where a subclass provides a specific implementation of a method
defined in its superclass.
Understanding polymorphism is essential for writing flexible and extensible Java code. It allows for
the creation of robust and maintainable systems by enabling dynamic method invocation and
facilitating code reuse. Polymorphism promotes loose coupling and high cohesion, making it a
fundamental principle in object-oriented design.
Example 1: Runtime Polymorphism

class Animal {
void makeSound() {
System.out.println("Animal is making a sound");
}
}

void makeSound() {
}
}
class Cat extends Animal {

void makeSound() {
System.out.println("Cat is meowing");
}
}
public class RuntimePolymorphismExample {

Animal animal1 = new Dog(); // Upcasting
Animal animal2 = new Cat(); // Upcasting
animal1.makeSound(); // Output: Dog is barking

animal2.makeSound(); // Output: Cat is meowing
}
}
In this example:
We have a superclass Animal with a method makeSound().

We have two subclasses Dog and Cat that override the makeSound() method with their specific
implementations.
In the main method, we create objects of the Dog and Cat classes and assign them to variables of
type Animal. This is known as upcasting.
When we call the makeSound() method on these objects, the JVM determines the actual type of the
object at runtime and calls the appropriate method accordingly. This is an example of dynamic
method dispatch or runtime polymorphism.
Example 2: Compile-Time Polymorphism
// Method overloading
return a + b;
}
double add(double a, double b) {

return a + b;
}
}
public class CompileTimePolymorphismExample {

MathOperations math = new MathOperations();
int sum1 = math.add(10, 20); // Calls int version of add method

double sum2 = math.add(10.5, 20.5); // Calls double version of add method
System.out.println("Sum1: " + sum1); // Output: Sum1: 30

System.out.println("Sum2: " + sum2); // Output: Sum2: 31.0
}
}
In this example:
We have a class MathOperations with two overloaded versions of the add method.
One version accepts two int parameters, and the other accepts two double parameters.
In the main method, we create an object of the MathOperations class and call the add method with
different parameter types. The appropriate method implementation is determined at compile time
based on the method signature. This is an example of static method dispatch or compile-time
polymorphism.
Introduction to Constructors in Java:

A constructor in Java is a special type of method that is automatically called when an object of a class
is created. It is used to initialize the newly created object and allocate memory for it. Constructors
have the same name as the class and may or may not have parameters. If no constructor is explicitly
defined in a class, Java provides a default constructor with no parameters.
Example of Constructor:

// Default constructor
public MyClass() {
System.out.println("Constructor called");
}

// Creating an object of MyClass
MyClass obj = new MyClass(); // Constructor called
}
}
Copy Constructor in Java:

A copy constructor is a constructor that initializes an object by copying the values of another object
of the same class. It allows you to create a new object with the same state as an existing object. Copy
constructors are useful for creating deep copies of objects, especially when dealing with mutable
objects.
public class Person {

private String name;
// Copy constructor
public Person(Person other) {
this.name = other.name;
}

Person person1 = new Person("Alice");
Person person2 = new Person(person1); // Creating a copy of person1
}
}
Constructor Overloading:
Constructor overloading is a concept where a class can have multiple constructors with different
parameter lists. It allows for the creation of objects using different initialization parameters. The
compiler determines which constructor to call based on the number and types of arguments passed
during object creation.
public class Rectangle {

private int length;
private int width;
// Constructor with parameters

public Rectangle(int length, int width) {
this.length = length;
this.width = width;
}
// Constructor without parameters (default constructor)

public Rectangle() {
this.length = 0;
this.width = 0;
}
}
Constructor Overriding:
In Java, constructors cannot be overridden like methods. However, a subclass can call the constructor
of its superclass using the super() keyword to perform initialization tasks defined in the superclass
constructor before initializing its own members.
public class Parent {

public Parent() {
System.out.println("Parent constructor");
}
}
public class Child extends Parent {

public Child() {
super(); // Calling the constructor of the superclass
System.out.println("Child constructor");
}
}
Constructor Chaining:
Constructor chaining refers to the process of calling one constructor from another constructor within
the same class or from a superclass constructor. This allows for code reuse and helps in avoiding
duplicate initialization code.

private int value;
// Constructor with parameters
public MyClass(int value) {
this.value = value;
}
// Constructor chaining using this keyword

public MyClass() {
this(0); // Calls the constructor with parameters
}
}
Private Constructors and Singleton Class:

A private constructor is a constructor that is inaccessible from outside the class. It is typically used to
prevent the instantiation of a class and to enforce a singleton pattern, where only one instance of the
class can exist.
public class Singleton {

private static Singleton instance;
// Private constructor
private Singleton() {
// Initialization code
}
// Static method to get the instance of Singleton

public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
In this example, the Singleton class has a private constructor, preventing other classes from creating
instances of Singleton directly. The static getInstance() method is used to provide access to the single
instance of the class.
These examples illustrate various aspects of constructors in Java, including their usage, overloading,
chaining, and the singleton pattern.
There are two types of methods in Java:

Predefined Method length(), equals(), compareTo(), sqrt()
User-defined Method
Accessor- get
Mutator- set
Introduction to Methods in Java:

Methods in Java are blocks of code that perform specific tasks. They are defined within classes and
are used to encapsulate behavior. Methods can accept input parameters, perform operations, and
return results.
public class MethodsExample {

// Instance method
public void greet() {
}
// Static method
MethodsExample obj = new MethodsExample();
obj.greet(); // Call the instance method
}
}
Different Method Calls in Java:

Java supports several ways to call methods:
public class MethodCallsExample {

// Instance method
public void instanceMethod() {
System.out.println("Instance method");
}
// Static method
public static void staticMethod() {
System.out.println("Static method");
}

MethodCallsExample obj = new MethodCallsExample();
// Instance method call

obj.instanceMethod(); // Call instance method using object
// Static method call

staticMethod(); // Call static method using class name
}
}
Difference between Static Methods and Instance Methods in Java:

Static Methods: Belong to the class rather than any instance of the class. They can be called using the
class name directly. Static methods cannot access instance variables directly.
Instance Methods: Belong to instances of the class. They can access instance variables directly.
Instance methods can be called after creating an instance of the class.
public class StaticVsInstanceMethods {

// Instance method
public void instanceMethod() {
System.out.println("Instance method");
}
// Static method
public static void staticMethod() {
System.out.println("Static method");
}
StaticVsInstanceMethods obj = new StaticVsInstanceMethods();
// Instance method call

obj.instanceMethod(); // Call instance method using object
// Static method call

staticMethod(); // Call static method using class name
}
}
Abstract Methods in Java:

Abstract methods are declared without implementation in abstract classes or interfaces. They
provide a way to specify the method signature without providing the method body. Subclasses must
implement abstract methods unless they are also declared as abstract.
// Abstract class with abstract method

abstract void draw(); // Abstract method
}
// Concrete subclass implementing abstract method

void draw() {
System.out.println("Drawing Circle");
}
}
public class AbstractMethodsExample {

Shape shape = new Circle(); // Creating object of subclass
shape.draw(); // Calling abstract method
}
}
Method Overriding in Java:
Method overriding occurs when a subclass provides a specific implementation of a method that is
already defined in its superclass.
// Superclass
class Animal {
void sound() {
System.out.println("Animal makes a sound");
}
}
// Subclass overriding method

void sound() {
System.out.println("Dog barks");
}
}
public class MethodOverridingExample {

Animal animal = new Dog(); // Upcasting
animal.sound(); // Calls overridden method in Dog class
}
}
Method Overloading in Java:

Method overloading occurs when a class has multiple methods with the same name but different
parameter lists.
public class MethodOverloadingExample {

// Method with same name but different parameter
void display(int a) {
System.out.println("Value of a: " + a);
}
// Overloaded method
void display(int a, int b) {
System.out.println("Value of a: " + a + ", Value of b: " + b);
}

MethodOverloadingExample obj = new MethodOverloadingExample();
obj.display(10); // Call first method
obj.display(20, 30); // Call overloaded method
}
}
Method Overloading Vs Method Overriding:

Method Overloading: Involves multiple methods in the same class with the same name but different
parameter lists. Overloading is determined at compile time (static polymorphism).
Method Overriding: Involves a method in a subclass with the same name, return type, and
parameter list as a method in its superclass. Overriding is determined at runtime (dynamic
polymorphism).
// Superclass
class Animal {
void sound() {
System.out.println("Animal makes a sound");
}
}
// Subclass overriding method

void sound() {
System.out.println("Dog barks");
}
}
public class OverloadingVsOverriding {

// Overloaded method
void sound(String type) {
System.out.println(type + " makes a sound");
}

Animal animal = new Dog(); // Upcasting
animal.sound(); // Calls overridden method in Dog class
OverloadingVsOverriding obj = new OverloadingVsOverriding();

obj.sound("Cat"); // Calls overloaded method
}
}
Java Interfaces:
Interfaces in Java are like blueprints of a class. They define a set of methods that a class
implementing the interface must provide. Interfaces allow for multiple inheritance in Java, as a class
can implement multiple interfaces.
// Interface declaration
interface Printable {
void print();
}
// Class implementing the interface

class MyClass implements Printable {
public void print() {
System.out.println("Printing...");
}
}
In this example, Printable is an interface with one method print(). The MyClass implements this
interface and provides the implementation for the print() method.
Interfaces and Inheritance in Java:

Interfaces in Java can extend other interfaces. When an interface extends another interface, it
inherits the methods of the parent interface. This allows for a form of multiple inheritance in Java.
// Interface extending another interface

interface Printable {
void print();
}
interface Showable extends Printable {

void show();
}
// Class implementing multiple interfaces

class MyClass implements Showable {
public void print() {
System.out.println("Printing...");
}
public void show() {

System.out.println("Showing...");
}
}
Here, Showable extends Printable, and MyClass implements Showable. As a result, MyClass must
provide implementations for both print() and show() methods.
Difference between Interface and Class in Java:

In Java, classes and interfaces are both reference types, but they have significant differences:
Class: Can contain fields, constructors, and methods with implementations.

Interface: Cannot contain fields or constructors, only method declarations (without implementations)
and constants (static final fields).
Functional Interface:
A functional interface is an interface that contains exactly one abstract method. It can contain
multiple default or static methods.
// Functional Interface
@FunctionalInterface
interface MyFunctionalInterface {
void myMethod(); // Abstract method
default void defaultMethod() {

System.out.println("Default method");
}
}
In this example, MyFunctionalInterface is a functional interface with one abstract method
myMethod() and one default method defaultMethod().
Nested Interface:
An interface declared inside another interface or a class is called a nested interface. It is used to
logically group related interfaces.
interface OuterInterface {
void outerMethod();
// Nested interface
interface InnerInterface {
void innerMethod();
}
}
Here, InnerInterface is a nested interface declared inside OuterInterface. It is accessible only through
an instance of OuterInterface.
Marker Interface:
A marker interface is an interface that has no methods or fields. It serves as a tag for classes that
implement it, providing metadata about the class.
// Marker Interface
interface Marker {
// No methods
}
class MyClass implements Marker {

// MyClass implements Marker interface
}
In this example, Marker is a marker interface with no methods. MyClass implements Marker to
indicate that it belongs to a certain category.
Comparator Interface:
The Comparator interface in Java is used for sorting collections of objects. It contains two methods:
compare() and equals().
import java.util.Comparator;
class Student {
int rollno;
String name;
int age;
// Constructor, getters and setters omitted for brevity

}
class AgeComparator implements Comparator<Student> {

public int compare(Student s1, Student s2) {
return s1.age - s2.age;
}
}
Here, AgeComparator is a class that implements the Comparator interface to define a custom sorting
order based on the age of Student objects.
Need of Wrapper classes in Java:

Wrapper classes in Java are used to convert primitive data types into objects. They provide a way to
treat primitive data types as objects, allowing them to be used in situations where objects are
required. Wrapper classes also provide utility methods for converting between primitive data types
and performing various operations.
How to create instances of Wrapper classes:

You can create instances of wrapper classes using constructors or static factory methods. Here's an
example of creating instances of Integer and Double wrapper classes:
Integer intObj = new Integer(10); // Using constructor

Double doubleObj = Double.valueOf(3.14); // Using valueOf() method
Character class in Java:

The Character class in Java is a wrapper class that encapsulates a char value. It provides utility
methods for working with characters, such as converting characters to upper or lower case, checking
if a character is a digit or letter, etc.
Character ch = 'A';
System.out.println(Character.isUpperCase(ch)); // Output: true
Byte class in Java:

The Byte class in Java is a wrapper class that encapsulates a byte value. It provides utility methods for
working with byte values, such as converting bytes to strings, parsing bytes from strings, etc.
Byte byteObj = Byte.valueOf((byte) 100);

System.out.println(byteObj.byteValue()); // Output: 100
Short class in Java:
The Short class in Java is a wrapper class that encapsulates a short value. It provides utility methods
for working with short values, such as converting shorts to strings, parsing shorts from strings, etc.
Short shortObj = Short.valueOf((short) 200);

System.out.println(shortObj.shortValue()); // Output: 200
Integer class in Java:

The Integer class in Java is a wrapper class that encapsulates an int value. It provides utility methods
for working with integer values, such as converting integers to strings, parsing integers from strings,
etc.
Integer intObj = Integer.valueOf(1000);

System.out.println(intObj.intValue()); // Output: 1000
Long class in Java:

The Long class in Java is a wrapper class that encapsulates a long value. It provides utility methods
for working with long values, such as converting longs to strings, parsing longs from strings, etc.
Long longObj = Long.valueOf(1000000L);

System.out.println(longObj.longValue()); // Output: 1000000
Float class in Java:

The Float class in Java is a wrapper class that encapsulates a float value. It provides utility methods
for working with float values, such as converting floats to strings, parsing floats from strings, etc.
Float floatObj = Float.valueOf(3.14f);

System.out.println(floatObj.floatValue()); // Output: 3.14
Double class in Java:

The Double class in Java is a wrapper class that encapsulates a double value. It provides utility
methods for working with double values, such as converting doubles to strings, parsing doubles from
strings, etc.
Double doubleObj = Double.valueOf(2.71828);
System.out.println(doubleObj.doubleValue()); // Output: 2.71828
Boolean class in Java:
The Boolean class in Java is a wrapper class that encapsulates a boolean value. It provides utility
methods for working with boolean values, such as converting booleans to strings, parsing booleans
from strings, etc.
Boolean boolObj = Boolean.valueOf(true);

System.out.println(boolObj.booleanValue()); // Output: true
Autoboxing and Unboxing:

Autoboxing is the automatic conversion of primitive data types into their corresponding wrapper
classes. Unboxing is the automatic conversion of wrapper class objects back into their primitive data
types. Java provides support for autoboxing and unboxing, making it easier to work with primitive
data types and their corresponding wrapper classes.
Integer intObj = 10; // Autoboxing

int intValue = intObj; // Unboxing
Type Conversion in Java:

Type conversion in Java involves converting data from one data type to another. It can be either
implicit or explicit. Implicit conversion occurs automatically by the compiler, while explicit conversion
requires manual intervention using casting.
int intValue = 10;

double doubleValue = intValue; // Implicit conversion
double doubleValue = 3.14;

int intValue = (int) doubleValue; // Explicit conversion (casting)
These examples illustrate various aspects of wrapper classes in Java, including their usage, creation,
and conversion. They demonstrate how wrapper classes provide a way to work with primitive data
types as objects and perform type conversions as needed.
List of all Java Keywords:
abstract
assert
boolean
break
byte
case
catch
char
class
const
continue
default
do
double
else
enum
extends
final
finally
float
for
goto
if
implements
import
instanceof
int
interface
long
native
new
null
package
private
protected
public
return
short
static
strictfp
super
switch
synchronized
this
throw
throws
transient
try
void
volatile
while
Important Keywords in Java:
super: Used to refer to the superclass of the current object.
final: Used to declare constants, make methods or classes immutable, or prevent method overriding
or class inheritance.
abstract: Used to declare abstract classes or methods, which are incomplete and must be
implemented by subclasses.
static: Used to create class-level variables or methods that can be accessed without creating an
instance of the class.
this: Used to refer to the current object within an instance method or constructor.
enum: Used to define a fixed set of constants (enumerated types).
Super Keyword:
The super keyword in Java is used to refer to the superclass of the current object. It can be used to
access superclass methods, constructors, or variables.
class Parent {
void display() {
System.out.println("Parent class method");
}
}
class Child extends Parent {

void display() {
super.display(); // Call superclass method
System.out.println("Child class method");
}
}
Final Keyword:
The final keyword in Java is used to declare constants, make methods or classes immutable, or
prevent method overriding or class inheritance.
final class FinalClass {

// Class body
}
class SubClass extends FinalClass { // Compilation error: Cannot inherit from final class
// Class body
}
Abstract Keyword:
The abstract keyword in Java is used to declare abstract classes or methods, which are incomplete
and must be implemented by subclasses.
abstract class AbstractClass {

abstract void abstractMethod(); // Abstract method
}
class ConcreteClass extends AbstractClass {

void abstractMethod() {
// Method implementation
}
}
Static Keyword:
The static keyword in Java is used to create class-level variables or methods that can be accessed
without creating an instance of the class.
class MyClass {
static int count = 0; // Static variable
static void incrementCount() { // Static method

count++;
}
}
This Keyword:
The this keyword in Java is used to refer to the current object within an instance method or
constructor. It is often used to disambiguate between instance variables and method parameters.
class MyClass {
int value;
MyClass(int value) {
this.value = value; // Assign parameter value to instance variable
}
}
Enum Keyword in Java:

The enum keyword in Java is used to define a fixed set of constants (enumerated types).
enum Day {
SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY
}
Transient Keyword in Java:

The transient keyword in Java is used to indicate that a field should not be serialized when the class is
serialized.
class MyClass implements Serializable {

transient int sensitiveData; // This field won't be serialized
}
Volatile Keyword in Java:

The volatile keyword in Java is used to indicate that a variable's value may be changed by multiple
threads simultaneously. It ensures that the variable is always read from and written to main memory,
rather than CPU caches.
class SharedResource {
volatile int sharedVariable;
}
Final, Finally, and Finalize in Java:

final: Used to declare constants, make methods or classes immutable, or prevent method overriding
or class inheritance.
finally: Used in exception handling to define a block of code that will be executed regardless of
whether an exception is thrown or not.
finalize: A method called by the garbage collector before reclaiming the memory occupied by an
object. It's rarely used due to its unpredictable nature.
These keywords play crucial roles in Java programming, providing essential functionalities and
features
Introduction to Access Modifiers in Java:
Access modifiers in Java are keywords that define the accessibility or visibility of classes, methods,
variables, and constructors within a Java program. They help in encapsulation, which is a
fundamental principle of object-oriented programming. Access modifiers restrict the access to
certain members of a class, ensuring proper data hiding and encapsulation.
Public vs Protected vs Package vs Private Access Modifier in Java:

Public:
Members declared as public are accessible from anywhere within the program, including other
classes, packages, and even outside the package.
They have the widest scope of accessibility.
Example: Public methods for accessing and modifying class attributes.
Protected:
Members declared as protected are accessible within the same package and by subclasses
(regardless of the package).
They are not accessible to non-subclasses outside the package.
Example: Protected variables or methods in a superclass that should be accessible to its subclasses.
Package-Private (Default):
Also known as default access, members without any access modifier are accessible only within the
same package.
They are not visible to classes outside the package.
Example: Variables and methods that are only relevant within a specific package.
Private:
Members declared as private are accessible only within the same class.
They are not accessible outside the class, including subclasses and other classes in the same package.
Example: Private helper methods used internally within a class.
Access Modifiers Vs Non-Access Modifiers in Java:
Access Modifiers:
Control the visibility and accessibility of classes, methods, variables, and constructors.
Include public, protected, default (package-private), and private.
Ensure proper encapsulation and data hiding.
Essential for defining the API of a class and managing access to its members.
Non-Access Modifiers:
Do not control access but provide additional functionalities or characteristics to classes, methods,
variables, or constructors.
Include final, static, abstract, synchronized, volatile, transient, and others.
Modify the behavior or properties of members without affecting their visibility.
Used for defining constants, enforcing thread-safety, managing memory, and more.

public static final int CONSTANT = 100; // Non-access modifier: static and final
public synchronized void synchronizedMethod() {} // Non-access modifier: synchronized
}
In summary, access modifiers regulate the accessibility of members within a Java program, while
non-access modifiers alter their behavior or properties. Understanding and properly applying these
modifiers are crucial for designing well-structured and secure Java applications.
How are Java objects stored in memory:

In Java, objects are stored in the heap memory. When you create an object using the new keyword,
memory is allocated from the heap to store the object's instance variables and methods. Each object
has its memory space allocated dynamically, and it remains in memory until it is no longer referenced
and becomes eligible for garbage collection.
class MyClass {
private int value;

this.value = value;
}
public int getValue() {

return value;
}
}
public class Main {

// Object creation
MyClass obj = new MyClass(10);
System.out.println("Object created with value: " + obj.getValue());
}
}
Stack vs Heap memory allocation:

Stack Memory:
Used for storing method invocations and local variables.
Managed automatically by the JVM.
Memory is reclaimed when a method invocation or variable goes out of scope.
public class StackExample {

int x = 10; // Stored in stack memory
int y = 20; // Stored in stack memory
int z = x + y; // Stored in stack memory
System.out.println("Sum: " + z);
}
}
Heap Memory:
Used for storing objects and instance variables.
Managed by the programmer via garbage collection.
Objects remain in memory until they are no longer referenced.
class MyClass {
private int value;

this.value = value;
}
public int getValue() {

return value;
}
}
public class HeapExample {

// Object creation (stored in heap memory)
System.out.println("Object created with value: " + obj.getValue());
}
}
Types of memory areas allocated by JVM:
Heap Memory: Stores objects and instance variables.
Stack Memory: Stores method invocations and local variables.
Method Area (PermGen/Metaspace): Stores class metadata, static variables, and constant pool.
PC Register: Stores the address of the next instruction being executed.
Native Method Stack: Stores native method information.
Garbage Collection in Java:
Garbage collection is the process of automatically reclaiming memory occupied by objects that are
no longer in use. Java's garbage collector identifies and removes unreferenced objects from the
heap, freeing up memory for new objects.
Types of JVM Garbage Collectors in Java:

Serial Garbage Collector: Uses a single thread for garbage collection and is suitable for small
applications.
Parallel Garbage Collector: Uses multiple threads for garbage collection, increasing throughput by
utilizing multiple CPU cores.
Concurrent Mark-Sweep (CMS) Garbage Collector: Minimizes pause times by performing garbage
collection concurrently with application execution.
G1 Garbage Collector: Garbage First (G1) collector divides the heap into regions and performs
garbage collection incrementally.
Memory leaks in Java:

A memory leak occurs when objects are no longer needed by an application but are not properly
deallocated, causing memory usage to increase continuously. Common causes of memory leaks in
Java include unintentional object retention, static references, and unclosed resources like streams or
database connections.
Java Virtual Machine (JVM) Stack Area:

The JVM stack area is used to store method invocations and local variables. Each thread in a Java
program has its own JVM stack, which contains frames for each method invocation. Each frame
stores local variables, operand stacks, and other information related to the method execution. The
size of the stack is fixed and defined when the thread is created.
Understanding Java memory management is crucial for writing efficient and reliable Java
applications. Proper memory management practices help prevent memory leaks, optimize
performance, and ensure the stability of Java applications.
Classes and Objects in Java:

In Java, a class is a blueprint for creating objects. It defines the attributes (fields) and behaviors
(methods) that objects of the class will have. An object is an instance of a class. It represents a real-
world entity and can be manipulated through its methods.
Here's an example of a class Car with fields (model and year) and a method (drive()):
class Car {
String model;
int year;
public Car(String model, int year) {

this.model = model;
this.year = year;
}
public void drive() {

System.out.println("Driving the " + model);
}
}
In the Main class, we create an instance of Car and access its fields and methods:
public class Main {

Car myCar = new Car("Toyota Camry", 2022);
System.out.println("My car model: " + myCar.model);
System.out.println("My car year: " + myCar.year);
myCar.drive();
}
}
Class vs Interface:
A class in Java is a blueprint for objects that contain fields and methods. An interface is a reference
type that can contain only constants, method signatures, default methods, static methods, and
nested types. Classes can implement interfaces, inheriting the abstract method definitions declared
in the interface.
Here's an example of an interface Animal and a class Dog implementing it:
interface Animal {
void eat();
void sleep();
}
class Dog implements Animal {

@Override
public void eat() {
System.out.println("Dog is eating");
}
@Override
public void sleep() {
System.out.println("Dog is sleeping");
}
}
We create an instance of Dog and call its methods:
public class Main {

Dog dog = new Dog();
dog.eat();
dog.sleep();
}
}
Singleton Class in Java:
Singleton is a design pattern that restricts the instantiation of a class to one object. To implement a
Singleton in Java, you typically make the constructor private and provide a static method that returns
the same instance every time it's called.
Here's an example of a Singleton class Singleton:
class Singleton {
private static Singleton instance;
private Singleton() {}
public static Singleton getInstance() {

if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
We retrieve the singleton instance in the Main class:
public class Main {

Singleton singleton1 = Singleton.getInstance();
Singleton singleton2 = Singleton.getInstance();
System.out.println(singleton1 == singleton2); // Output: true
}
}
Object Class in Java:
In Java, java.lang.Object is the root class of all classes. It provides methods like equals(), hashCode(),
and toString(), which can be overridden in subclasses. The toString() method returns a string
representation of the object.
Here's an example of overriding the toString() method:

class MyClass {
private int number;
public MyClass(int number) {

this.number = number;
}
@Override
public String toString() {
return "MyClass{" +
"number=" + number +
'}';
}
}
We use the toString() method implicitly in the Main class:
public class Main {

System.out.println(obj); // Output: MyClass{number=10}
}
}
Inner Class in Java:
An inner class is a class defined within another class in Java. It can access the members of the
enclosing class, including private members.
Here's an example of an inner class Inner within the Outer class:
class Outer {
private int outerVar = 100;
class Inner {
void display() {
System.out.println("Outer variable: " + outerVar);
}
}
}
We create instances of both classes in the Main class:
public class Main {

Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.display();
}
}
Abstract Classes in Java:
Abstract classes in Java cannot be instantiated on their own and are meant to be subclassed. They
may contain abstract methods, which are meant to be implemented by subclasses.
Here's an example of an abstract class Shape with an abstract method area():

abstract double area();
}

double radius;
Circle(double radius) {
this.radius = radius;
}
@Override
double area() {
return Math.PI * radius * radius;
}
}
We instantiate the Circle class in the Main class:
public class Main {

Circle circle = new Circle(5);
System.out.println("Area of circle: " + circle.area());
}
}
Throwable Class in Java:
java.lang.Throwable is the superclass of all errors and exceptions in Java. It has two main subclasses:
Error and Exception. Errors represent serious problems not expected to be caught by a program,
while exceptions represent conditions that a program should catch and handle.
Here's an example of catching an ArithmeticException:
public class Main {

try {
int result = 5 / 0; // Attempting to divide by zero
} catch (ArithmeticException e) {
System.out.println("Error: " + e.getMessage());
} finally {
System.out.println("Finally block executed");
}
}
}
In this example, 5 / 0 throws an ArithmeticException, which is caught in the catch block, and the
finally block always executes.
Creating a Package in Java:

To create a package in Java, you need to follow these steps:
Choose a package name: A package name should be unique and should follow the Java naming
conventions (e.g., reverse domain name, all lowercase).
Create a directory structure: Create a directory structure matching the package name. Each
subdirectory in the path corresponds to a segment of the package name.
Place your classes in the appropriate directory: Place your Java source files (*.java) in the directory
matching the package name.
Add package declaration: At the top of each Java source file, add a package declaration specifying the
package name.
Here's an example of creating a package named com.example.mypackage:
src
└── com
└── example
└── mypackage
└── MyClass.java
// MyClass.java
package com.example.mypackage;

// class implementation
}
To compile Java files in packages, navigate to the parent directory of the com directory and compile
using the -d option to specify the destination directory for the compiled .class files:
javac -d . src/com/example/mypackage/MyClass.java
Commonly Used Java Packages:
java.util Package:
The java.util package contains utility classes and data structures for various purposes such as
collections, date and time manipulation, random number generation, etc.
Some commonly used classes/interfaces in java.util package are:

ArrayList, LinkedList, HashSet, HashMap: Data structures for collections.
Date, Calendar, DateFormat, SimpleDateFormat: Date and time manipulation.
Random: For generating random numbers.
Scanner: For reading input from various sources.
java.lang Package:
The java.lang package is implicitly imported into every Java program and contains fundamental
classes and interfaces.
It includes classes like String, Object, Math, System, etc.
String: For manipulating strings.
Object: The root class of all Java classes.
Math: Provides mathematical functions like sqrt(), pow(), etc.
System: Provides access to system-related properties and methods.
java.io Package:
The java.io package provides classes for input and output operations.
It includes classes like File, InputStream, OutputStream, Reader, Writer, etc.
File: Represents files and directories on the file system.
InputStream and OutputStream: For reading from and writing to byte streams.
Reader and Writer: For reading from and writing to character streams.
These packages provide essential functionality for Java programming and are extensively used in
various Java applications.
1. Collections class in Java:

The Collections class in Java provides various static methods to operate on collections such as
sorting, searching, shuffling, etc.
Here's an example of sorting a list of strings using the sort() method of the Collections class:
import java.util.*;
public class Main {

List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
names.add("Charlie");
System.out.println("Before sorting: " + names);

Collections.sort(names);
System.out.println("After sorting: " + names);
}
}
2. Collection Interface in Java:
The Collection interface is the root interface in the Java Collections Framework. It provides methods
to manipulate collections such as add(), remove(), contains(), etc.
Here's an example demonstrating the usage of the Collection interface:
import java.util.*;
public class Main {

Collection<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
System.out.println("Names collection: " + names);

System.out.println("Size of collection: " + names.size());
System.out.println("Contains 'Bob'? " + names.contains("Bob"));
names.remove("Charlie");
System.out.println("After removing 'Charlie': " + names);
}
}
3. List Interface in Java:
The List interface represents an ordered collection of elements. It allows duplicate elements and
provides positional access to elements.
Here's an example using the List interface:
import java.util.*;
public class Main {

List<String> colors = new ArrayList<>();
colors.add("Red");
colors.add("Green");
colors.add("Blue");
System.out.println("Colors list: " + colors);

System.out.println("Element at index 1: " + colors.get(1));
colors.remove("Green");
System.out.println("After removing 'Green': " + colors);
}
}
4. Queue Interface in Java:
The Queue interface represents a collection designed for holding elements prior to processing. It
typically follows the FIFO (First-In-First-Out) order.
Here's an example demonstrating the usage of the Queue interface:
import java.util.*;
public class Main {

Queue<String> queue = new LinkedList<>();
queue.offer("Alice");
queue.offer("Bob");
queue.offer("Charlie");
System.out.println("Queue: " + queue);

System.out.println("Peek: " + queue.peek());
System.out.println("Poll: " + queue.poll());
System.out.println("Updated Queue: " + queue);
}
}
5. Map Interface in Java:
The Map interface represents a collection of key-value pairs. It does not allow duplicate keys and
each key can map to at most one value.
Here's an example demonstrating the usage of the Map interface:
import java.util.*;
public class Main {

Map<String, Integer> ages = new HashMap<>();
ages.put("Alice", 30);
ages.put("Bob", 25);
ages.put("Charlie", 35);
System.out.println("Ages Map: " + ages);

System.out.println("Age of Bob: " + ages.get("Bob"));
ages.remove("Charlie");
System.out.println("Updated Map: " + ages);
}
}
6. Set in Java:
The Set interface represents a collection of elements where each element is unique. It does not allow
duplicate elements.
Here's an example demonstrating the usage of the Set interface:
import java.util.*;
public class Main {

Set<String> fruits = new HashSet<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Apple"); // Duplicate, will not be added
System.out.println("Fruits Set: " + fruits);

System.out.println("Contains 'Banana'? " + fruits.contains("Banana"));
fruits.remove("Banana");
System.out.println("Updated Set: " + fruits);
}
}
7. Iterator in Java:
The Iterator interface provides a way to iterate over elements of a collection sequentially. It allows
you to remove elements from the underlying collection safely during iteration.
Here's an example demonstrating the usage of the Iterator interface:
import java.util.*;
public class Main {

List<Integer> numbers = new ArrayList<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
Iterator<Integer> iterator = numbers.iterator();

while (iterator.hasNext()) {
int num = iterator.next();
System.out.println(num);
}
}
}
8. Comparator in Java:
The Comparator interface provides a way to define custom ordering for objects. It is used to compare
objects for sorting purposes.
Here's an example demonstrating the usage of the Comparator interface:

import java.util.*;
public class Main {

List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
// Custom comparator to sort names in reverse order

Comparator<String> comparator = (s1, s2) -> s2.compareTo(s1);
Collections.sort(names, comparator);
System.out.println("Sorted names in reverse order: " + names);

}
}
9. Difference between Comparator and Comparable in Java:

Comparable is implemented by a class to provide a natural ordering of its instances. It defines a
single method compareTo() to compare objects.
Comparator is used to define custom ordering for objects and is external to the element being
compared. It defines a method compare() to compare two objects.
The key difference is that Comparable affects the natural ordering of objects, while
Comparator provides additional flexibility for defining different ordering criteria.
1. ArrayList in Java:
ArrayList is a part of the Java Collections Framework and provides dynamic arrays that can grow as
needed. It implements the List interface and allows for dynamic resizing of arrays.
import java.util.ArrayList;
import java.util.List;
public class Main {

// Creating an ArrayList
List<String> arrayList = new ArrayList<>();
// Adding elements
arrayList.add("Apple");
arrayList.add("Banana");
arrayList.add("Orange");
// Accessing elements
System.out.println("Elements in ArrayList: " + arrayList);
// Iterating through elements

for (String fruit : arrayList) {
System.out.println(fruit);
}
}
}
2. Vector class in Java:

Vector is similar to ArrayList but is synchronized, which means it is thread-safe. However, it is slower
than ArrayList because of synchronization.
import java.util.Vector;
public class Main {

// Creating a Vector
Vector<String> vector = new Vector<>();
// Adding elements
vector.add("Apple");
vector.add("Banana");
vector.add("Orange");
System.out.println("Elements in Vector: " + vector);

for (String fruit : vector) {
}
}
}
3. Stack class in Java:

Stack is a subclass of Vector and represents a last-in, first-out (LIFO) stack of objects.
import java.util.Stack;
public class Main {

// Creating a Stack
Stack<String> stack = new Stack<>();
// Pushing elements
stack.push("Apple");
stack.push("Banana");
stack.push("Orange");
System.out.println("Elements in Stack: " + stack);
// Popping elements
while (!stack.isEmpty()) {
System.out.println("Popped: " + stack.pop());
}
}
}
4. LinkedList in Java:
LinkedList is a doubly-linked list implementation of the List and Deque interfaces. It provides better
performance for insertions and deletions but slower access to elements compared to ArrayList.
import java.util.LinkedList;
public class Main {

// Creating a LinkedList
LinkedList<String> linkedList = new LinkedList<>();
// Adding elements
linkedList.add("Apple");
linkedList.add("Banana");
linkedList.add("Orange");
System.out.println("Elements in LinkedList: " + linkedList);

for (String fruit : linkedList) {
}
}
}
5. AbstractList and AbstractSequentialList:

AbstractList is an abstract implementation of the List interface, providing common methods like
add(), remove(), and get().
AbstractSequentialList is an abstract implementation of the List interface optimized for sequential

access.
These classes are typically used as base classes for creating custom list implementations
6. CopyOnWriteArrayList:
CopyOnWriteArrayList is a thread-safe variant of ArrayList where all mutative operations like add, set,
and remove are implemented by making a fresh copy of the underlying array.
import java.util.concurrent.CopyOnWriteArrayList;
public class Main {

// Creating a CopyOnWriteArrayList
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
// Adding elements
list.add("Apple");
list.add("Banana");
list.add("Orange");
System.out.println("Elements in CopyOnWriteArrayList: " + list);
}
}
7. Custom ArrayList in Java:

You can create a custom ArrayList by extending the AbstractList class and implementing its abstract
methods.
import java.util.AbstractList;
import java.util.Arrays;
public class CustomArrayList<E> extends AbstractList<E> {
private Object[] elements;
private int size;
public CustomArrayList(int initialCapacity) {

elements = new Object[initialCapacity];
}
@Override
public E get(int index) {
if (index < 0 || index >= size) {
throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
}
return (E) elements[index];
}
@Override
public int size() {
return size;
}
@Override
public boolean add(E element) {
if (size == elements.length) {
grow();
}
elements[size++] = element;
return true;
}
private void grow() {

int newSize = elements.length * 2;
elements = Arrays.copyOf(elements, newSize);
}
// Other methods like remove, addAll, etc. can be implemented similarly

// Using custom ArrayList
CustomArrayList<String> customList = new CustomArrayList<>(3);
customList.add("Apple");
customList.add("Banana");
customList.add("Orange");
customList.add("Mango"); // Will resize internally
System.out.println("Custom ArrayList: " + customList);
}
}
AbstractQueue:
AbstractQueue is an abstract class that provides a skeletal implementation of the Queue interface. It
simplifies the implementation of custom queues by providing default implementations for some
methods.
import java.util.AbstractQueue;
import java.util.Iterator;
public class MyQueue<E> extends AbstractQueue<E> {

// Implementations for abstract methods
}
ArrayBlockingQueue:
ArrayBlockingQueue is a bounded blocking queue backed by an array. It provides thread-safe

operations for adding and removing elements, blocking if necessary until space is available or an
element is available for retrieval.
import java.util.concurrent.ArrayBlockingQueue;
public class Main {
public static void main(String[] args) throws InterruptedException {
ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<>(5);
queue.put(1);
queue.put(2);
queue.put(3);
int firstElement = queue.take();
System.out.println("Removed element: " + firstElement);
}
}
ConcurrentLinkedQueue:
ConcurrentLinkedQueue is a non-blocking, thread-safe queue based on linked nodes. It's highly

concurrent and provides efficient operations for adding and removing elements.
import java.util.concurrent.ConcurrentLinkedQueue;
public class Main {

ConcurrentLinkedQueue<Integer> queue = new ConcurrentLinkedQueue<>();
queue.add(1);
queue.add(2);
queue.add(3);
System.out.println(queue.poll());
}
}
LinkedBlockingQueue:
LinkedBlockingQueue is a blocking queue with linked nodes. It can optionally have a maximum
capacity. It provides blocking operations for adding and removing elements.
import java.util.concurrent.LinkedBlockingQueue;
public class Main {
LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<>();
queue.add(1);
queue.add(2);
queue.add(3);
}
}
LinkedTransferQueue:
LinkedTransferQueue is an unbounded transfer queue based on linked nodes. It's suitable for
scenarios where producers may be faster than consumers. It supports both blocking and non-
blocking transfer operations.
import java.util.concurrent.LinkedTransferQueue;
public class Main {

LinkedTransferQueue<Integer> queue = new LinkedTransferQueue<>();
// Usage of LinkedTransferQueue
}
}
PriorityBlockingQueue:
PriorityBlockingQueue is a thread-safe priority queue based on a priority heap. Elements are ordered
by their natural ordering or by a specified comparator.
import java.util.concurrent.PriorityBlockingQueue;
public class Main {

PriorityBlockingQueue<Integer> queue = new PriorityBlockingQueue<>();
queue.add(3);
queue.add(1);
queue.add(2);
}
}
Deque in Java:
Deque is a double-ended queue that allows insertion and removal of elements from both ends.
import java.util.Deque;
import java.util.LinkedList;
public class Main {

Deque<Integer> deque = new LinkedList<>();
deque.addFirst(1);
deque.addLast(2);
System.out.println(deque.pollFirst());
}
}
ArrayDeque:
ArrayDeque is a resizable-array implementation of the Deque interface.
import java.util.ArrayDeque;
public class Main {

ArrayDeque<Integer> deque = new ArrayDeque<>();
deque.addFirst(1);
deque.addLast(2);
}
}
ConcurrentLinkedDeque:
ConcurrentLinkedDeque is a non-blocking, thread-safe deque based on linked nodes.
import java.util.concurrent.ConcurrentLinkedDeque;
public class Main {

ConcurrentLinkedDeque<Integer> deque = new ConcurrentLinkedDeque<>();
deque.addFirst(1);
deque.addLast(2);
}
}
LinkedBlockingDeque:
LinkedBlockingDeque is a bounded blocking deque based on linked nodes.

import java.util.concurrent.LinkedBlockingDeque;
public class Main {

LinkedBlockingDeque<Integer> deque = new LinkedBlockingDeque<>();
deque.addFirst(1);
deque.addLast(2);
}
}
PriorityQueue in Java:
PriorityQueue is a queue where elements are ordered according to their natural ordering or by a
specified comparator.
import java.util.PriorityQueue;
public class Main {

PriorityQueue<Integer> queue = new PriorityQueue<>();
queue.add(3);
queue.add(1);
queue.add(2);
}
}
EnumMap:
EnumMap is a specialized implementation of the Map interface designed for use with enum keys.
It's highly efficient and provides constant-time performance for the basic operations.
import java.util.EnumMap;
enum Day { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY; }
public class Main {

EnumMap<Day, String> enumMap = new EnumMap<>(Day.class);
enumMap.put(Day.MONDAY, "First day");
enumMap.put(Day.TUESDAY, "Second day");
System.out.println(enumMap.get(Day.MONDAY));
}
}
HashMap:
HashMap is a widely-used implementation of the Map interface based on hashing.

It provides constant-time performance for basic operations (average case).
import java.util.HashMap;
import java.util.Map;
public class Main {

Map<String, Integer> hashMap = new HashMap<>();
hashMap.put("One", 1);
hashMap.put("Two", 2);
System.out.println(hashMap.get("One"));
}
}
Working of HashMap:
HashMap internally uses an array of linked lists (buckets) to store key-value pairs.
The hash code of the key is used to compute the index where the key-value pair will be stored.
Collisions (when two keys have the same hash code) are resolved by chaining (using linked lists).
Traverse through a HashMap in Java:
There are multiple ways to traverse through a HashMap. One common approach is to iterate over its
entry set.
import java.util.HashMap;
public class Main {

Map<String, Integer> hashMap = new HashMap<>();
hashMap.put("One", 1);
hashMap.put("Two", 2);
for (Map.Entry<String, Integer> entry : hashMap.entrySet()) {
System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
}
}
}
WeakHashMap:
WeakHashMap is an implementation of the Map interface where keys are weakly referenced.
Entries with weakly referenced keys are automatically removed by the garbage collector.
import java.util.WeakHashMap;
public class Main {

WeakHashMap<Integer, String> weakHashMap = new WeakHashMap<>();
Integer key = new Integer(1);
weakHashMap.put(key, "Value");
key = null; // Key becomes eligible for garbage collection
System.gc(); // Trigger garbage collection
System.out.println(weakHashMap.isEmpty()); // true
}
}
LinkedHashMap:
LinkedHashMap is a subclass of HashMap that maintains the insertion order of its entries.
It provides predictable iteration order (the order in which keys were inserted).
import java.util.LinkedHashMap;
public class Main {

Map<String, Integer> linkedHashMap = new LinkedHashMap<>();
linkedHashMap.put("One", 1);
linkedHashMap.put("Two", 2);
linkedHashMap.put("Three", 3);
for (Map.Entry<String, Integer> entry : linkedHashMap.entrySet()) {
System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
}
}
}
IdentityHashMap:
IdentityHashMap is an implementation of the Map interface that uses reference equality for key
comparison instead of object equality.
It compares keys using the == operator rather than the equals() method.
import java.util.IdentityHashMap;
public class Main {

IdentityHashMap<String, Integer> identityHashMap = new IdentityHashMap<>();
String key1 = new String("key");
String key2 = new String("key");
identityHashMap.put(key1, 1);
identityHashMap.put(key2, 2);
System.out.println(identityHashMap.size()); // Output: 2
}
}
ConcurrentHashMap:
ConcurrentHashMap is a thread-safe implementation of the Map interface designed for concurrent

access from multiple threads.
It divides the map into segments to allow multiple threads to operate on different segments
simultaneously.
import java.util.concurrent.ConcurrentHashMap;
public class Main {

ConcurrentHashMap<String, Integer> concurrentHashMap = new ConcurrentHashMap<>();
concurrentHashMap.put("One", 1);
concurrentHashMap.put("Two", 2);
System.out.println(concurrentHashMap.get("One"));
}
}
Dictionary:
Dictionary is an abstract class representing a mapping between keys and values. It's a legacy class
and has been replaced by the Map interface. Dictionary is part of older Java versions and is not
commonly used in modern Java programming.
import java.util.Dictionary;
import java.util.Hashtable;
public class Main {

Dictionary<String, Integer> dictionary = new Hashtable<>();
dictionary.put("One", 1);
dictionary.put("Two", 2);
System.out.println(dictionary.get("One"));
}
}
HashTable:
HashTable is an implementation of the Map interface that provides synchronization for concurrent
access. It's thread-safe but has been largely replaced by ConcurrentHashMap due to its better
scalability.
import java.util.Hashtable;
public class Main {

Map<String, Integer> hashTable = new Hashtable<>();
hashTable.put("One", 1);
hashTable.put("Two", 2);
System.out.println(hashTable.get("One"));
}
}
SortedMap:
SortedMap is an interface extending the Map interface that maintains its keys in sorted order.
Implementations include TreeMap and others.
import java.util.SortedMap;
import java.util.TreeMap;
public class Main {

SortedMap<String, Integer> sortedMap = new TreeMap<>();
sortedMap.put("Two", 2);
sortedMap.put("One", 1);
System.out.println(sortedMap.firstKey()); // Output: One
}
}
TreeMap:
TreeMap is an implementation of the SortedMap interface that uses a red-black tree to store its
entries. It maintains its keys in sorted order, allowing efficient retrieval of elements based on their
natural ordering or a specified comparator.
import java.util.TreeMap;
public class Main {

TreeMap<String, Integer> treeMap = new TreeMap<>();
treeMap.put("Two", 2);
treeMap.put("One", 1);
System.out.println(treeMap.firstKey()); // Output: One
}
}
Stack:
Stack is a subclass of Vector that represents a last-in, first-out (LIFO) stack of objects. It provides
methods for pushing elements onto the stack, popping elements off the stack, and accessing the top
element.
import java.util.Stack;
public class Main {

Stack<Integer> stack = new Stack<>();
stack.push(1);
stack.push(2);
stack.push(3);
System.out.println("Top element: " + stack.peek()); // Output: 3
System.out.println("Popped element: " + stack.pop()); // Output: 3
}
}
Vector:
Vector is a synchronized implementation of the List interface that is similar to ArrayList but provides
synchronized access to its elements. It's thread-safe but has been largely replaced by more efficient
alternatives such as ArrayList and LinkedList.
import java.util.Vector;
public class Main {

Vector<Integer> vector = new Vector<>();
vector.add(1);
vector.add(2);
vector.add(3);
System.out.println("First element: " + vector.firstElement()); // Output: 1
System.out.println("Last element: " + vector.lastElement()); // Output: 3
}
}
AbstractSet:
Since AbstractSet is an abstract class, we'll demonstrate its usage by extending it to create a custom
set implementation.
import java.util.AbstractSet;
import java.util.Iterator;
public class CustomSet<E> extends AbstractSet<E> {

private int size;
private Object[] elements;
public CustomSet() {
size = 0;
elements = new Object[10]; // Initial capacity
}
@Override
public Iterator<E> iterator() {
return new Iterator<E>() {
private int index = 0;
@Override
public boolean hasNext() {
return index < size;
}
@Override
public E next() {
return (E) elements[index++];
}
};
}
@Override
public int size() {
return size;
}
@Override
public boolean add(E e) {
elements[size++] = e;
return true;
}
}
EnumSet:
EnumSet is specifically designed to work with enum elements.

import java.util.EnumSet;
enum Color { RED, GREEN, BLUE }
public class Main {

EnumSet<Color> colors = EnumSet.of(Color.RED, Color.GREEN);
System.out.println(colors); // Output: [RED, GREEN]
}
}
HashSet:
HashSet is a widely-used implementation of the Set interface that uses hashing to store elements.
It provides constant-time performance for basic operations on average.
import java.util.HashSet;
import java.util.Set;
public class Main {

// Create a HashSet
Set<String> hashSet = new HashSet<>();
// Add elements
hashSet.add("Apple");
hashSet.add("Banana");
hashSet.add("Orange");
// Print elements
for (String fruit : hashSet) {
}
}
}
TreeSet:
TreeSet is an implementation of the SortedSet interface that uses a red-black tree to store elements
in sorted order.
It maintains elements in ascending order by default, or based on a specified comparator.
import java.util.TreeSet;
public class Main {

// Create a TreeSet
Set<Integer> treeSet = new TreeSet<>();
// Add elements
treeSet.add(3);
treeSet.add(1);
treeSet.add(2);
// Print elements
for (int num : treeSet) {
}
}
}
SortedSet:
SortedSet is an interface extending the Set interface that maintains its elements in sorted order.
It provides methods for accessing the first and last elements, and for retrieving elements within a
specified range.
import java.util.SortedSet;
public class Main {

// Create a SortedSet (TreeSet is the common implementation)
SortedSet<Integer> sortedSet = new TreeSet<>();
// Add elements
sortedSet.add(3);
sortedSet.add(1);
sortedSet.add(2);
// Print elements
for (int num : sortedSet) {
}
}
}
LinkedHashSet:
LinkedHashSet is a subclass of HashSet that maintains the insertion order of its elements.
It provides predictable iteration order (the order in which elements were inserted).
import java.util.LinkedHashSet;
public class Main {

// Create a LinkedHashSet
Set<String> linkedHashSet = new LinkedHashSet<>();
// Add elements
linkedHashSet.add("Apple");
linkedHashSet.add("Banana");
linkedHashSet.add("Orange");
// Print elements
for (String fruit : linkedHashSet) {
}
}
}
NavigableSet:
NavigableSet is an interface extending the SortedSet interface that provides navigation methods for
retrieving elements based on their position in the set.
Implementations include TreeSet and others.
import java.util.NavigableSet;
public class Main {

// Create a NavigableSet (TreeSet is the common implementation)
NavigableSet<Integer> navigableSet = new TreeSet<>();
// Add elements
navigableSet.add(3);
// Print elements in descending order

for (int num : navigableSet.descendingSet()) {
}
}
}
ConcurrentSkipListSet:
ConcurrentSkipListSet is a thread-safe implementation of the NavigableSet interface based on skip

lists.
It provides high concurrency for concurrent access from multiple threads.
import java.util.NavigableSet;
import java.util.concurrent.ConcurrentSkipListSet;
public class Main {

// Create a ConcurrentSkipListSet
NavigableSet<String> concurrentSkipListSet = new ConcurrentSkipListSet<>();
// Add elements
concurrentSkipListSet.add("Apple");
concurrentSkipListSet.add("Banana");
concurrentSkipListSet.add("Orange");
// Print elements
for (String fruit : concurrentSkipListSet) {
}
}
}
CopyOnWriteArraySet:
CopyOnWriteArraySet is a thread-safe implementation of the Set interface backed by a copy-on-write

array.
It provides thread-safe iteration without locking the set, making it suitable for scenarios with a large
number of reads and few writes.
import java.util.concurrent.CopyOnWriteArraySet;
public class Main {

// Create a CopyOnWriteArraySet
Set<String> copyOnWriteArraySet = new CopyOnWriteArraySet<>();
// Add elements
copyOnWriteArraySet.add("Apple");
copyOnWriteArraySet.add("Banana");
copyOnWriteArraySet.add("Orange");
// Print elements
for (String fruit : copyOnWriteArraySet) {
}
}
}
Exceptions in Java:
Exceptions in Java represent abnormal conditions that occur during the execution of a program.
They disrupt the normal flow of the program and can be handled using exception handling
mechanisms.
Types of Exceptions:
Exceptions in Java are broadly classified into two types: Checked Exceptions and Unchecked
Exceptions.
Checked exceptions are checked at compile time, and the programmer is forced to handle them
using try-catch blocks or declaring them in the method signature using the throws keyword.
Unchecked exceptions, also known as runtime exceptions, are not checked at compile time. They
typically result from programming errors and are subclasses of RuntimeException.
Difference between Checked and Unchecked Exceptions:
Checked exceptions must be either caught by the code using a try-catch block or declared in the
method signature using the throws keyword. Examples include IOException, SQLException.
Unchecked exceptions do not need to be declared or caught explicitly. They are typically
programming errors that occur at runtime. Examples include NullPointerException,
ArrayIndexOutOfBoundsException.
Try, Catch, Finally, Throw, and Throws:
try: It defines a block of code in which exceptions may occur.

catch: It is used to handle exceptions. It catches the exception thrown in the try block.
finally: It is a block of code that is always executed whether an exception is handled or not. It's
typically used for cleanup operations.
throw: It is used to explicitly throw an exception.
throws: It is used in method signatures to declare that the method may throw certain exceptions.
Flow control in Try-catch block:
When an exception occurs in the try block, the control is transferred to the corresponding catch
block.
If an exception is not caught in the try block, it propagates up the call stack until it's caught by a catch
block or the program terminates.
The finally block is executed after the try block, regardless of whether an exception occurred or not.
I'll continue with the remaining topics in the next message to avoid exceeding the message limit.
Let's continue with explanations and code examples for the remaining topics:
Throw vs Throws:
throw is used to explicitly throw an exception within a method.

throws is used in the method signature to declare that the method may throw certain exceptions.
// Example of using throw

public void checkAge(int age) {
if (age < 18) {
throw new IllegalArgumentException("Age must be at least 18");
}
// Other code
}
// Example of using throws

public void readFile() throws IOException {
// Code to read a file
}
Final vs Finally vs Finalize:
final is a keyword used to declare constants, immutable objects, or to prevent method overriding and
class inheritance.
finally is a block of code that is always executed after the try block, whether an exception is thrown
or not.
finalize is a method called by the garbage collector on an object before it is reclaimed. It's not
recommended to rely on it for resource cleanup.
User-defined custom exception:
You can create custom exceptions by extending the Exception class or one of its subclasses.
// Custom exception class
class CustomException extends Exception {
public CustomException(String message) {
super(message);
}
}
// Throwing custom exception

public void validateAge(int age) throws CustomException {
if (age < 18) {
throw new CustomException("Age must be at least 18");
}
}
Chained Exceptions:
Chained exceptions allow you to associate one exception with another. They provide more
information about the cause of an exception.
try {
// Some code that may throw an exception
} catch (IOException e) {
throw new MyException("Error occurred while processing data", e);
}
Null Pointer Exceptions:
A null pointer exception occurs when you try to access a member or method of an object that is null.
String str = null;
System.out.println(str.length()); // This will throw a NullPointerException
Exception handling with method Overriding:
When overriding a method that declares checked exceptions in its parent class, subclasses can only
declare the same exceptions or subclasses of them. However, they are not forced to declare
unchecked exceptions.
class Parent {
void method() throws IOException {}
}
class Child extends Parent {

// Valid override
void method() throws FileNotFoundException {}
// Valid override
void method() throws EOFException {}
// Invalid override - Unchecked exceptions can be thrown without declaration

void method() {}
}
Introduction to Multithreading in Java:

Multithreading in Java allows concurrent execution of multiple threads within a single process. This
allows programs to perform multiple tasks simultaneously, improving efficiency and responsiveness.
public class MultithreadingExample extends Thread {

public void run() {
System.out.println("Thread running...");
}

MultithreadingExample thread = new MultithreadingExample();
thread.start();
}
}
Lifecycle and Stages of a Thread:

Threads in Java have several stages in their lifecycle: new, runnable, running, blocked, and
terminated.
public class ThreadLifecycleExample {

Thread thread = new Thread(() -> {
System.out.println("Thread is running...");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread is finished.");
});
System.out.println("Thread state: " + thread.getState());

thread.start();
System.out.println("Thread state after start(): " + thread.getState());
try {
thread.join();
}
System.out.println("Thread state after join(): " + thread.getState());

}
}
Thread Priority in Java:

Threads in Java can have priorities ranging from 1 to 10, where 1 is the lowest priority and 10 is the
highest. By default, threads inherit the priority of their parent thread.
public class ThreadPriorityExample {

Thread thread1 = new Thread(() -> {
System.out.println("Thread 1 running...");
});

});
// Set thread priorities

thread1.setPriority(Thread.MIN_PRIORITY); // Minimum priority
thread2.setPriority(Thread.MAX_PRIORITY); // Maximum priority
thread1.start();
thread2.start();
}
}
Main Thread in Java:
In Java, every program has a main thread that executes the main method. This main thread is the
entry point of the program.
public class MainThreadExample {

Thread mainThread = Thread.currentThread();
System.out.println("Main thread name: " + mainThread.getName());
System.out.println("Main thread priority: " + mainThread.getPriority());
}
}
Thread class:
The Thread class in Java is the fundamental class for creating and managing threads. You can create a
thread by extending the Thread class and overriding its run() method.
public class MyThread extends Thread {

public void run() {
}

MyThread thread = new MyThread();
thread.start();
}
}
Runnable interface:
The Runnable interface in Java provides a way to create a thread without extending the Thread class.
Instead, you implement the Runnable interface and pass it to a Thread object.
public class MyRunnable implements Runnable {

public void run() {
System.out.println("Runnable running...");
}

Thread thread = new Thread(new MyRunnable());
thread.start();
}
}
How to name a thread:

Naming threads in Java is helpful for debugging and monitoring purposes. You can set the name of a
thread using the setName() method or by passing the name as an argument to the Thread
constructor.
public class ThreadNamingExample {

});
thread1.setName("WorkerThread1");

}, "WorkerThread2");
thread1.start();
thread2.start();
}
}
In this example, thread1 is named using the setName() method, and thread2 is named by passing the
name directly to the Thread constructor. Naming threads can make it easier to identify them when
debugging or analyzing thread behavior. Let me know if you have any questions about this topic or if
you'd like to move on to the next one!
start() method in thread:

The start() method in Java is used to begin the execution of a thread. When you call the start()
method on a Thread object, it causes the JVM to schedule the thread for execution, and eventually,
the run() method of the thread is invoked.
public class StartMethodExample {
Thread thread = new Thread(() -> {
});
thread.start(); // Start the thread

}
}
In this example, the start() method is called on the thread object, causing the JVM to start executing
the thread. It's important to note that you should never call the run() method directly if you want to
start a new thread. Always use the start() method to ensure proper thread execution. Let me know if
you need further clarification or examples!
Difference between run() and start() Method:

The main difference between the run() and start() methods in Java threads lies in how they initiate
the execution of a thread.
run(): The run() method contains the code that defines the task or behavior of the thread. When you
call the run() method directly, it executes the code in the current thread, without creating a new
thread.
start(): The start() method is used to begin the execution of a new thread. When you call the start()
method, it schedules the thread for execution and eventually invokes the run() method in a separate
thread.
public class RunVsStartExample extends Thread {

public void run() {
}

RunVsStartExample thread = new RunVsStartExample();
// Calling run() method directly

thread.run(); // Executes in the main thread
// Calling start() method
thread.start(); // Starts a new thread and executes run() in that thread
}
}
In this example, calling thread.run() executes the run() method in the main thread, while calling
thread.start() starts a new thread and executes the run() method in that separate thread. It's
important to use start() to create and execute threads properly in Java. Let me know if you need
further clarification or examples!
sleep() method:
The sleep() method in Java is used to pause the execution of a thread for a specified amount of time.
It temporarily suspends the thread's execution, allowing other threads to run in the meantime.
public class SleepMethodExample {

System.out.println("Thread 1 is running...");
try {
Thread.sleep(2000); // Pause execution for 2 seconds
}
System.out.println("Thread 1 is awake after sleeping...");

}
}
In this example, the execution of "Thread 1" is paused for 2 seconds using the sleep() method. This
allows other threads to execute during that time. After the sleep period, "Thread 1" resumes
execution. The sleep() method can be useful for adding delays or controlling the timing of threads in
a multithreaded program. Let me know if you have any questions or if you'd like to explore another
topic!
Daemon thread:
In Java, a daemon thread is a special type of thread that runs in the background, providing services
to other threads or performing tasks that are not critical to the application's operation. Daemon
threads are typically used for tasks like garbage collection or monitoring.
public class DaemonThreadExample {

Thread daemonThread = new Thread(() -> {
while (true) {
System.out.println("Daemon thread running...");
try {
Thread.sleep(1000);
}
}
});
// Set the thread as daemon

daemonThread.setDaemon(true);
daemonThread.start();
System.out.println("Main thread exiting...");

}
}
In this example, daemonThread is set as a daemon thread using the setDaemon(true) method.
Daemon threads will automatically terminate when all non-daemon threads have finished executing
or when the main thread exits. Let me know if you need further clarification or examples on this
topic!
Thread Pool in Java:

A thread pool in Java is a collection of pre-initialized threads that are available for executing tasks.
Thread pools help manage and reuse threads, which can improve performance by reducing the
overhead of thread creation.
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExample {

// Create a thread pool with 5 threads
ExecutorService executor = Executors.newFixedThreadPool(5);
// Submit tasks to the thread pool

for (int i = 0; i < 10; i++) {
executor.execute(new Task(i));
}
// Shutdown the executor

executor.shutdown();
}
}
class Task implements Runnable {

private final int taskId;
public Task(int taskId) {

this.taskId = taskId;
}
@Override
public void run() {
System.out.println("Task " + taskId + " is executing by thread: " +
Thread.currentThread().getName());
}
}
In this example, a thread pool with 5 threads is created using Executors.newFixedThreadPool(5).
Then, 10 tasks are submitted to the thread pool using the execute() method. The thread pool
manages the execution of these tasks among its available threads. Finally, the shutdown() method is
called to gracefully shut down the thread pool after all tasks have been completed. Let me know if
you need more information or examples!
Thread Group in Java:

A thread group in Java is a way to organize and manage threads. Threads can belong to a thread
group, which allows you to perform operations on multiple threads simultaneously, such as
interrupting or suspending them.
public class ThreadGroupExample {

ThreadGroup group = new ThreadGroup("MyThreadGroup");
// Create threads and add them to the thread group

Thread thread1 = new Thread(group, new Task(), "Thread1");
Thread thread2 = new Thread(group, new Task(), "Thread2");
// Start the threads

thread1.start();
thread2.start();
// Display information about the thread group

group.list();
}
}
class Task implements Runnable {

@Override
public void run() {
System.out.println("Task running in thread: " + Thread.currentThread().getName());
}
}
In this example, a new thread group named "MyThreadGroup" is created. Two threads, thread1 and
thread2, are then created and added to this thread group. When group.list() is called, it displays
information about the threads in the group, including their names and states. Thread groups can be
useful for managing and monitoring related threads within an application. Let me know if you have
any questions!
Thread Safety in Java:

Thread safety in Java refers to the ability of a program to execute correctly in a multithreaded
environment, where multiple threads may access shared resources concurrently. Ensuring thread
safety is crucial to prevent data corruption and ensure the correctness of the program's behavior.
public class ThreadSafetyExample {

private static int count = 0;

for (int i = 0; i < 10000; i++) {
increment();
}
});

for (int i = 0; i < 10000; i++) {
increment();
}
});
thread1.start();
thread2.start();
try {
thread1.join();
thread2.join();
}
System.out.println("Count: " + count);

}
public synchronized static void increment() {

count++;
}
}
In this example, count is a shared variable accessed by multiple threads. To ensure thread safety, the
increment() method is declared as synchronized, which allows only one thread to execute it at a
time. This prevents race conditions and ensures that the increment operation is performed
atomically. As a result, the final value of count will always be the sum of increments performed by
both threads. Let me know if you need further clarification or examples!
ShutdownHook:
In Java, a shutdown hook is a thread that is executed when the JVM is shutting down, either
normally or due to an external event such as a user interrupt or a system shutdown. Shutdown hooks
are useful for performing cleanup tasks or saving state before the program exits.
public class ShutdownHookExample {

// Registering a shutdown hook
Runtime.getRuntime().addShutdownHook(new Thread(() -> {
System.out.println("Shutdown hook executed");
// Perform cleanup tasks or save state here
}));
// Simulate program execution

System.out.println("Program is running...");
try {
Thread.sleep(3000); // Simulate some work
}
System.out.println("Program finished.");
}
}
In this example, a shutdown hook is registered using the addShutdownHook() method of the
Runtime class. The provided thread will be executed when the JVM is shutting down. Shutdown
hooks can be used to release resources, close connections, or perform other cleanup tasks to ensure
the program exits gracefully. Let me know if you have any questions
Multithreading Tutorial:
A multithreading tutorial in Java typically covers various aspects of concurrent programming,
including creating and managing threads, synchronization, thread safety, and advanced topics like
thread pools and deadlock prevention. It provides hands-on examples and explanations to help
developers understand how to write multithreaded applications effectively.
A comprehensive multithreading tutorial would be quite extensive, covering topics such as:
Creating threads using the Thread class and the Runnable interface
Managing thread lifecycle and states
Thread synchronization mechanisms like synchronized blocks, locks, and volatile keyword
Understanding thread safety and techniques to achieve it
Handling exceptions and errors in multithreaded environments
Using thread pools for efficient resource management
Dealing with common multithreading issues like deadlock and livelock
Best practices and patterns for writing multithreaded code
Such a tutorial would typically include code examples, explanations, and possibly exercises for
practice. Let me know if you'd like more specific information or examples on any of these topics!
Synchronization in Java:
Synchronization in Java is the process of controlling access to shared resources by multiple threads
to avoid data corruption and ensure consistency. In Java, synchronization can be achieved using the
synchronized keyword, which can be applied to methods or code blocks.
public class SynchronizationExample {

private int count = 0;
public synchronized void increment() {
count++;
}

SynchronizationExample syncExample = new SynchronizationExample();

for (int i = 0; i < 10000; i++) {
syncExample.increment();
}
});

for (int i = 0; i < 10000; i++) {
}
});
thread1.start();
thread2.start();
try {
thread1.join();
thread2.join();
}
System.out.println("Count: " + syncExample.count);

}
}
In this example, the increment() method is synchronized, which means only one thread can execute
it at a time. This prevents race conditions and ensures that the count variable is updated atomically.
Synchronization in Java is essential for maintaining thread safety in multithreaded programs. Let me
know if you need further explanation or examples!
Java Synchronization:
Java synchronization ensures that only one thread can access a shared resource at a time, preventing
concurrent access and potential data corruption. This is achieved using the synchronized keyword,
which can be applied to methods or code blocks.
public void increment() {

synchronized (this) {
count++;
}
}


for (int i = 0; i < 10000; i++) {
}
});

for (int i = 0; i < 10000; i++) {
}
});
thread1.start();
thread2.start();
try {
thread1.join();
thread2.join();
}

}
}
In this example, the increment() method is synchronized using a synchronized block with the this
keyword as the monitor. This ensures that only one thread can execute the critical section of code
(incrementing the count variable) at a time, maintaining thread safety. Let me know if you have any
questions or need further clarification!
Importance of Thread synchronization in Java:

Thread synchronization is crucial in Java multithreading to prevent race conditions and ensure data
consistency when multiple threads access shared resources concurrently. Without synchronization,
concurrent access to shared data can lead to unpredictable behavior and data corruption.


count++;
}


for (int i = 0; i < 10000; i++) {
}
});

for (int i = 0; i < 10000; i++) {
}
});
thread1.start();
thread2.start();
try {
thread1.join();
thread2.join();
}

}
}
In this example, without synchronization, the count variable may not be updated correctly due to
race conditions. However, by synchronizing the increment() method, we ensure that only one thread
can execute it at a time, preventing data corruption and ensuring the correctness of the program's
behavior. Let me know if you need further explanation!
Method and Block Synchronization in Java:

In Java, synchronization can be applied at both the method level and the block level. Method
synchronization synchronizes the entire method, while block synchronization allows you to
synchronize specific blocks of code within a method.
Method Synchronization:

count++;
}
// Other synchronized methods...

}
Block Synchronization:

private Object lock = new Object();
public void increment() {

synchronized (lock) {
count++;
}
}
// Other methods...
}
In method synchronization, the synchronized keyword is applied to the entire method signature,
ensuring that only one thread can execute the method at a time. In block synchronization, the
synchronized block is used to synchronize specific blocks of code within a method, allowing for finer-
grained control over synchronization. Both approaches help prevent race conditions and ensure
thread safety in multithreaded programs. Let me know if you need further clarification!
Local frameworks vs thread synchronization:

In Java multithreading, developers often face the choice between using local frameworks or
implementing their own thread synchronization mechanisms. Local frameworks typically refer to
libraries or frameworks that provide higher-level abstractions for managing concurrency, while
thread synchronization involves implementing synchronization primitives directly in the code.
Local Frameworks:
Java provides built-in concurrency utilities such as the java.util.concurrent package, which includes
classes like ExecutorService, ThreadPoolExecutor, ConcurrentHashMap, etc.
These frameworks offer higher-level abstractions and thread-safe data structures, making it easier to
write concurrent programs with less risk of errors.
They handle many low-level details of concurrency management, such as thread creation, pooling,
scheduling, and synchronization, allowing developers to focus on application logic.
Thread Synchronization:
Thread synchronization involves using low-level synchronization primitives such as synchronized

keyword, wait(), notify(), notifyAll(), Lock, Semaphore, etc., to coordinate access to shared resources.
While more complex and error-prone than using local frameworks, thread synchronization offers
finer-grained control over concurrency and can be necessary for implementing specific
synchronization patterns or optimizing performance.
It requires a deeper understanding of multithreading concepts and may require more effort to
implement and maintain.
Choosing between local frameworks and thread synchronization depends on factors such as the
complexity of the application, performance requirements, and developer expertise. In general, it's
advisable to use local frameworks whenever possible to leverage their built-in concurrency utilities
and avoid reinventing the wheel. However, in certain cases where specific synchronization patterns
or optimizations are needed, custom thread synchronization may be necessary. Let me know if you
have any questions or need further clarification!
Difference between Atomic, Volatile, and Synchronized in Java:
Atomic Variables:
Atomic variables are classes in the java.util.concurrent.atomic package that provide atomic
operations on single variables without requiring synchronization.
They ensure that read-modify-write operations are performed atomically, preventing race conditions.
Examples include AtomicInteger, AtomicLong, AtomicBoolean, etc.
Atomic variables are suitable for scenarios where fine-grained synchronization is needed on
individual variables.
Volatile Keyword:
The volatile keyword in Java is used to mark a variable as volatile, meaning its value may be modified
by different threads.
When a variable is declared as volatile, the Java memory model ensures that changes to the
variable's value are visible to all threads immediately.
However, volatile only guarantees visibility and does not provide atomicity or synchronization for
compound actions.
It is commonly used for flags or status variables that are accessed by multiple threads.
Synchronized Keyword:
The synchronized keyword in Java is used to create synchronized blocks or methods, ensuring that
only one thread can execute a synchronized block or method at a time.
It provides both atomicity and visibility guarantees, ensuring that changes made by one thread are
visible to other threads and preventing race conditions.
synchronized blocks or methods acquire and release locks, allowing only one thread to enter a
synchronized block or execute a synchronized method at a time.
It is suitable for protecting critical sections of code or shared resources.
In summary, atomic variables provide atomic operations on single variables, volatile ensures visibility
of variable changes across threads, and synchronized provides both atomicity and visibility
guarantees along with mutual exclusion. Each mechanism serves different purposes and should be
chosen based on the specific requirements of the application. Let me know if you need further
clarification!
Deadlock in Multithreading:
Deadlock in multithreading occurs when two or more threads are blocked forever, waiting for each
other to release resources that they need. This situation arises when threads acquire locks on
resources in a non-deterministic order and then wait indefinitely for other threads to release the
locks they need.
Example of Deadlock:
public class DeadlockExample {

private static final Object resource1 = new Object();
private static final Object resource2 = new Object();

synchronized (resource1) {
System.out.println("Thread 1: Locked resource 1");
try {
Thread.sleep(100);
}
System.out.println("Thread 1: Waiting for resource 2");
}
}
});

try {
Thread.sleep(100);
}
System.out.println("Thread 2: Waiting for resource 1");
}
}
});
thread1.start();
thread2.start();
}
}
In this example, thread1 locks resource1 and waits for resource2, while thread2 locks resource2 and
waits for resource1. Since neither thread can proceed without releasing the resource it holds, both
threads remain blocked indefinitely, resulting in a deadlock. Deadlocks are a common issue in
multithreaded programming and must be carefully avoided or resolved. Let me know if you need
further explanation!
Deadlock Prevention and Avoidance:

Deadlock prevention and avoidance are strategies used to mitigate the risk of deadlock in
multithreaded programs. These strategies aim to ensure that threads do not enter into a deadlock
situation where they are blocked indefinitely waiting for each other.
Deadlock Prevention:
Deadlock prevention involves ensuring that the conditions necessary for deadlock cannot occur.
One approach is to impose a total ordering on resources and require that threads always request
resources in the same order.
Another approach is to use timeouts or
cancellation mechanisms to detect potential deadlock situations and take corrective action.
Additionally, limiting the maximum number of resources a thread can hold or releasing resources
after a certain period of time can help prevent deadlock.
Deadlock Avoidance:
Deadlock avoidance involves dynamically analyzing the resource allocation graph to determine if
granting a resource request will lead to deadlock.
Algorithms like Banker's algorithm use a combination of resource allocation and resource request
information to determine if granting a request will result in a safe state (i.e., avoiding deadlock).
By carefully managing resource allocation and tracking the state of resources and threads, deadlock
avoidance techniques aim to ensure that resources are allocated in a way that avoids the possibility
of deadlock.
Both deadlock prevention and avoidance strategies aim to ensure that threads can make progress
without getting stuck in a deadlock situation. However, they may incur additional overhead and
complexity in the program logic. It's important to carefully design and implement these strategies
based on the specific requirements and characteristics of the multithreaded application. Let me
know if you need further explanation or examples!
Difference between Lock and Monitor in Concurrency:
Locks:
Locks are explicit objects that threads can acquire and release to control access to shared resources.
They offer more flexibility and features, such as reentrant locking and timed locking.
Examples include ReentrantLock and ReadWriteLock.
Monitors:
Monitors are a higher-level abstraction provided by Java.

They are associated with objects, and synchronization is achieved using the synchronized keyword.
Monitors automatically handle locking and unlocking, making synchronization simpler.
In short, locks provide more control and flexibility, while monitors offer simplicity and ease of use.
Reentrant Lock:
A ReentrantLock in Java is a type of lock that allows threads to enter into a lock multiple times
without causing a deadlock. It provides the same functionality as synchronized blocks but with
additional features such as fairness, timeouts, and the ability to interrupt threads waiting for the
lock.
Example:
import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockExample {

private static final ReentrantLock lock = new ReentrantLock();

lock.lock();
try {
System.out.println("Thread 1 acquired the lock");
Thread.sleep(2000); // Simulate some work
} finally {
lock.unlock();
System.out.println("Thread 1 released the lock");
}
});

lock.lock();
try {
System.out.println("Thread 2 acquired the lock");
} finally {
lock.unlock();
System.out.println("Thread 2 released the lock");
}
});
thread1.start();
thread2.start();
}
}
In this example, ReentrantLock is used to protect a critical section of code. Both threads can acquire
the lock multiple times without causing a deadlock because ReentrantLock allows reentrant locking.
After acquiring the lock, it's essential to release it using the unlock() method to ensure proper
synchronization and avoid deadlock. Let me know if you need further clarification!
File Class in Java:
The File class in Java represents a file or directory path on the filesystem.
It provides methods for querying information about the file or directory, such as its name, path, size,
existence, and permissions.
The File class does not provide methods for reading or writing file contents; it's primarily used for file
manipulation and querying metadata.
How to Create Files in Java:

You can create a new file in Java using the createNewFile() method of the File class.
Here's an example:
File file = new File("example.txt");

try {
if (file.createNewFile()) {
System.out.println("File created successfully.");
} else {
System.out.println("File already exists.");
}
}
How to Read Files in Java:
You can read the contents of a file in Java using various classes such as FileInputStream,
BufferedReader, or Scanner.
Here's an example using BufferedReader:
try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {

String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
}
How to Write on Files in Java:
You can write data to a file in Java using classes such as FileOutputStream, BufferedWriter, or
PrintWriter.
Here's an example using BufferedWriter:
try (BufferedWriter writer = new BufferedWriter(new FileWriter("example.txt"))) {
writer.write("Hello, world!");
}
How to Delete a File in Java:
You can delete a file in Java using the delete() method of the File class.
Here's an example:

if (file.delete()) {
System.out.println("File deleted successfully.");
} else {
System.out.println("Failed to delete the file.");
}
package proj1;
import java.io.File;
import java.io.FileWriter;
public class FileHandling {

// File f = new File("D:\\nit\\proj1\\txt.txt");
// if (f.exists()){
// System.out.println("exists");
// }else{
// System.out.println("not exists");
// }
// try{
// File f = new File("D:\\nit\\proj1\\txt2.txt");
// if (f.createNewFile()){
// System.out.println("created");
// }else{
// System.out.println("not created");
// }
//
// }
// catch(Exception e){
// System.out.println("error");
// }
try{
File f = new File("D:\\nit\\proj1\\txt2.txt");
File f2 = new File("D:\\nit\\proj1\\txt.txt");
FileWriter w = new FileWriter(f);

w.write("one \n");
w.write("two \n");
w.write("three \n");
w.close();
Scanner s = new Scanner(f);

while (s.hasNext()){
System.out.println(s.nextLine());
}
if(f2.delete()){
System.out.println("deleted");
}else{
System.out.println("not deleted");
}
}
catch(Exception e){
System.out.println("error");
}
}
}
File Permissions:
File permissions control who can read, write, and execute a file. In Java, you can set file permissions
using the setReadable, setWritable, and setExecutable methods of the File class.
Example:

file.setReadable(true); // Set the file readable
file.setWritable(true); // Set the file writable
file.setExecutable(false); // Set the file not executable
FileReader:
FileReader is used to read character streams from files. It reads data character by character.
Example:
try (FileReader reader = new FileReader("example.txt")) {

int data;
while ((data = reader.read()) != -1) {
System.out.print((char) data);
}
}
FileWriter:
FileWriter is used to write character streams to files. It writes data character by character.
Example:
try (FileWriter writer = new FileWriter("example.txt")) {

}
FileDescriptor class:
FileDescriptor class represents a handle to an open file or an open socket.

Example:
FileDescriptor out = FileDescriptor.out;

try (PrintWriter writer = new PrintWriter(new FileOutputStream(out))) {
writer.println("Hello, world!");
}
RandomAccessFile class:
RandomAccessFile provides random access to files. It allows reading or writing at any position within
the file.
Example:
try (RandomAccessFile file = new RandomAccessFile("example.dat", "rw")) {

file.seek(5); // Move to position 5
file.writeBytes("Hello"); // Write data at position 5
file.seek(0); // Move to beginning of the file
byte[] buffer = new byte[10];
file.read(buffer); // Read data from the beginning
System.out.println(new String(buffer));
}
How to write Regex expressions:

// Matches the literal string "hello"
String regex = "hello";
// Matches "hello", where "." matches any single character
String regex2 = "h.llo";
2. Matcher class:
String text = "The quick brown fox jumps over the lazy dog.";
String regex = "fox"; // Pattern to search for
// Compile the regex pattern

Pattern pattern = Pattern.compile(regex);
// Create a Matcher object

Matcher matcher = pattern.matcher(text);
// Use Matcher to perform matching operations

if (matcher.find()) {
System.out.println("Match found at index " + matcher.start());
} else {
System.out.println("No match found.");
}
3. Pattern class:
String regex = "hello"; // Pattern to compile

4. Quantifiers:
String regex = "a+"; // Matches one or more occurrences of 'a'

String regex2 = "\\d{3}"; // Matches exactly three digits
5. Character class:
String regex = "[abc]"; // Matches either 'a', 'b', or 'c'

String regex2 = "[a-z]"; // Matches any lowercase letter
Putting it all together:
import java.util.regex.*;
public class RegexExample {

String text = "The quick brown fox jumps over the lazy dog.";
String regex = "fox"; // Pattern to search for

// Create a Matcher object

Matcher matcher = pattern.matcher(text);
// Use Matcher to perform matching operations

if (matcher.find()) {
System.out.println("Match found at index " + matcher.start());
} else {
System.out.println("No match found.");
}
}
}
1. Introduction to Java IO:
Java IO (Input/Output) is a fundamental part of Java programming, enabling communication
between Java programs and external sources or destinations of data. It encompasses reading from
and writing to files, network connections, streams, and other input/output sources. Java IO provides
a rich set of classes and interfaces to handle various IO operations efficiently and effectively.
2. Reader Class:
The Reader class is an abstract class in Java's IO library that serves as the superclass for all classes
that read character-based input streams. It provides methods for reading characters, arrays of
characters, and lines of text from character input streams. Reader is primarily used for reading text-
based data from sources like files, network connections, and standard input streams.
Here's a basic example using Reader to read characters from a file:
import java.io.*;
public class ReaderExample {

try (Reader reader = new FileReader("example.txt")) {
int data;
while ((data = reader.read()) != -1) {
System.out.print((char) data);
}
}
}
}
In this example, we use FileReader, a subclass of Reader, to read characters from a file named
"example.txt".
3. Writer Class:
Similar to Reader, the Writer class is an abstract class in Java's IO library that serves as the superclass
for all classes that write character-based output streams. It provides methods for writing characters,
arrays of characters, and strings to character output streams. Writer is primarily used for writing text-
based data to destinations like files and network connections.
Here's a basic example using Writer to write characters to a file:
import java.io.*;
public class WriterExample {

try (Writer writer = new FileWriter("output.txt")) {
}
}
}
In this example, we use FileWriter, a subclass of Writer, to write the string "Hello, world!" to a file
named "output.txt".
4. FileInputStream:
FileInputStream is a class in Java used for reading raw bytes of data from a file. It's part of the byte-
oriented IO classes and is primarily used for reading binary data from files. FileInputStream reads
bytes of data from a file in a stream-like manner, making it suitable for reading binary files, such as
images, videos, and executable files.
Here's a basic example using FileInputStream to read bytes from a binary file:
import java.io.*;
public class FileInputStreamExample {
try (FileInputStream fis = new FileInputStream("example.bin")) {
int data;
while ((data = fis.read()) != -1) {
System.out.print(data + " ");
}
}
}
}
In this example, we use FileInputStream to read bytes from a binary file named "example.bin".
5. FileOutputStream:
FileOutputStream is used for writing raw bytes of data to a file. It's part of the byte-oriented IO
classes and is primarily used for writing binary data to files. FileOutputStream writes bytes of data to
a file in a stream-like manner, making it suitable for writing binary files, such as images, videos, and
executable files.
Here's a basic example using FileOutputStream to write bytes to a binary file:
import java.io.*;
public class FileOutputStreamExample {

try (FileOutputStream fos = new FileOutputStream("output.bin")) {
byte[] data = {65, 66, 67, 68, 69}; // ASCII values for A, B, C, D, E
fos.write(data);
}
}
}
In this example, we use FileOutputStream to write bytes to a binary file named "output.bin".
6. BufferedReader and BufferedWriter:

BufferedReader and BufferedWriter provide buffering capabilities for character-based input and
output operations, respectively. They improve performance by reading and writing data in chunks,
rather than one character at a time. BufferedReader is commonly used for reading text from files or
network connections, while BufferedWriter is used for writing text to files or network connections.
Here's a basic example using BufferedReader and BufferedWriter to read from an input file and write
to an output file:
import java.io.*;
public class BufferedReaderWriterExample {

try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"));
BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
String line;
writer.write(line);
writer.newLine(); // Add newline character
}
}
}
}
In this example, we use BufferedReader to read lines from an input file and BufferedWriter to write
them to an output file, adding a newline character after each line.
7. BufferedReader vs Scanner:
BufferedReader and Scanner are both used for reading input from various sources, but they have
different use cases. BufferedReader is efficient for reading large volumes of text from files or network
connections, while Scanner is more convenient for parsing formatted input. BufferedReader is
commonly used for reading user input from the console or reading data from files or network
streams, while Scanner is commonly used for parsing tokens from input streams.
Here's a comparison between BufferedReader and Scanner:
BufferedReader Example:
import java.io.*;
public class BufferedReaderExample {

try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
String input = reader.readLine();
System.out.println("You entered: " + input);
}
}
}
In this example, we use BufferedReader to read input from the console.
Scanner Example:
public class ScannerExample {

Scanner scanner = new Scanner(System.in);
String input = scanner.nextLine();
System.out.println("You entered: " + input);
scanner.close();
}
}
In this example, we use Scanner to read input from the console.
8. Fast I/O in Java:

For fast IO in Java, you can use BufferedReader and BufferedWriter for reading and writing text,
respectively. Additionally, you can use byte-oriented classes like InputStream and OutputStream
along with BufferedInputStream and BufferedOutputStream for reading and writing binary data
efficiently. BufferedReader and BufferedWriter provide buffering capabilities, which improve IO
performance by reading and writing data in chunks rather than one character at a time.
Here's a basic example demonstrating fast IO using BufferedReader and BufferedWriter:
import java.io.*;
public class FastIOExample {

try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out))) {
String line;
writer.write(line);
writer.newLine(); // Add newline character
writer.flush(); // Flush buffer to ensure data is written immediately
}
}
}
}
In this example, we use BufferedReader to read input from the console and BufferedWriter to write it
back to the console. We flush the buffer after writing each line to ensure immediate output.
Java IO provides a versatile and robust framework for performing input/output operations in Java
programs, catering to various needs and scenarios. Whether you're reading from files, network
connections, or standard input streams, Java IO has you covered with its comprehensive set of
classes and interfaces.
1.Lambda Expressions:
Lambda expressions provide a concise syntax for representing anonymous functions or closures.
They consist of parameters, an arrow (->), and a body. Lambda expressions can be used wherever a
functional interface is expected, enabling a more functional style of programming in Java.
// Example: Sorting a list of strings using lambda expression with Comparator

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
Collections.sort(names, (String a, String b) -> a.compareTo(b));
In this example, the lambda expression (String a, String b) -> a.compareTo(b) is used as an argument
to the sort() method. It represents a comparator function that compares two strings.
2. Streams API:
The Streams API provides a powerful way to process collections of data in Java. It introduces a fluent
programming style where operations can be chained together to perform complex data processing
tasks. Streams operate lazily and can be parallelized, offering improved performance for large
datasets.
// Example: Filtering even numbers from a list using Streams API

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
List<Integer> evenNumbers = numbers.stream()
.filter(n -> n % 2 == 0)
.collect(Collectors.toList());
Here, the stream() method creates a stream from the list of numbers. The filter() operation filters out
the even numbers, and collect() collects the filtered elements into a new list.
3. New Date/Time API:

The New Date/Time API introduces classes like LocalDate, LocalTime, LocalDateTime, Duration,
Period, etc., to handle date and time-related operations in a more fluent and safer manner compared
to the old java.util.Date and java.util.Calendar classes.
// Example: Using LocalDate from the New Date/Time API

LocalDate today = LocalDate.now();
LocalDate tomorrow = today.plusDays(1);
Period period = Period.between(today, tomorrow);
System.out.println("Tomorrow is " + tomorrow + ", which is " + period.getDays() + " day(s) away from
today.");
Here, LocalDate.now() retrieves the current date, plusDays(1) adds one day to the current date, and
Period.between() calculates the period between today and tomorrow.
4. Default Methods:
Default methods allow interfaces to provide method implementations without affecting
implementing classes. This feature enables interface evolution by allowing new methods to be added
to interfaces without breaking existing implementations.
// Example: Default method in interface

interface Vehicle {
default void start() {
System.out.println("Vehicle started");
}
}
class Car implements Vehicle {
// No need to implement start() method
}
In this example, the start() method in the Vehicle interface has a default implementation. Classes
implementing Vehicle can choose to override this method or use the default implementation.
5. Functional Interfaces:
Functional interfaces are interfaces that declare exactly one abstract method. They can have multiple
default methods or static methods, but only one abstract method. Functional interfaces are essential
for lambda expressions and method references.
// Example: Functional interface

@FunctionalInterface
interface MyFunction {
void doSomething();
}
Here, MyFunction is annotated with @FunctionalInterface to indicate that it's intended for use as a
functional interface. It declares a single abstract method doSomething().
6. Method References:
Method references provide a shorthand syntax for lambda expressions representing method
invocation. They enable you to reuse existing method implementations or constructors as lambda
expressions.
// Example: Method reference

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(System.out::println);
In this example, System.out::println is a method reference that refers to the println method of the
System.out object. It's equivalent to the lambda expression (str) -> System.out.println(str).
7. Optional class:
The Optional class is a container object that may or may not contain a non-null value. It's designed to
reduce the occurrence of NullPointerExceptions by forcing developers to handle the presence or
absence of a value explicitly.
// Example: Using Optional class

Optional<String> maybeName = Optional.ofNullable(someNullableString);
maybeName.ifPresent(name -> System.out.println("Name is: " + name));
Here, Optional.ofNullable() creates an Optional object from a nullable value. The ifPresent() method
executes the provided consumer if the value is present.
8. Stream Filter:
Stream filter is an intermediate operation in the Streams API that filters elements of a stream based
on a given predicate. It allows you to select only those elements from the stream that match the
specified criteria.
// Example: Using stream filter

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> evenNumbers = numbers.stream()
.filter(n -> n % 2 == 0)
.collect(Collectors.toList());
Here, filter() is used to retain only the elements that satisfy the condition n % 2 == 0, i.e., even
numbers.
9. Type Annotations:
Type annotations allow you to apply annotations to any type use, including variable declarations,
casts, new expressions, and more. They provide additional information to the compiler or runtime,
enabling better type checking and code analysis.
// Example: Type annotations

@NonNull String name = "John";
In this example, @NonNull is a type annotation that indicates that the variable name should not be
null. This annotation can be used by tools for static analysis or code generation.
10. String Joiner:

StringJoiner is a class introduced in Java 8 to construct sequences of characters separated by a
delimiter. It provides a more flexible and readable way to concatenate strings compared to
traditional approaches using string concatenation or StringBuilder.
// Example: Using StringJoiner

StringJoiner joiner = new StringJoiner(", ", "[", "]");
joiner.add("One").add("Two").add("Three");
System.out.println(joiner.toString()); // Output: [One, Two, Three]
Here, a StringJoiner is created with a delimiter , , prefix [, and suffix ], and elements are added to it
using the add() method. Finally, the joined string is obtained using toString().
Date Class in Java:

The Date class in Java represents a specific instant in time, with millisecond precision. It's a part of
the java.util package and has been around since the early versions of Java. However, it's important to
note that the Date class has been largely supplanted by the java.time package introduced in Java 8,
which provides a more comprehensive set of date and time APIs.
Methods of the Date Class:

The Date class provides several methods to work with dates and times, including:
getTime(): Returns the number of milliseconds since January 1, 1970, 00:00:00 GMT.
toString(): Returns a string representation of the date.
after(Date when): Checks if the date is after the specified date.
before(Date when): Checks if the date is before the specified date.
equals(Object obj): Checks if the date is equal to the specified object.
compareTo(Date anotherDate): Compares two dates for ordering.
setTime(long time): Sets the time represented by this date.
Many more...
Java Current Date and Time:
To get the current date and time in Java, you can use the java.util.Date class along with
java.util.Calendar or java.time.LocalDateTime from the java.time package.
Using java.util.Date (Legacy):
import java.util.Date;
// Get the current date and time

Date currentDate = new Date();
System.out.println("Current date and time: " + currentDate);
Using java.time.LocalDateTime (Modern):
java
Copy code
import java.time.LocalDateTime;
// Get the current date and time

LocalDateTime currentDateTime = LocalDateTime.now();
System.out.println("Current date and time: " + currentDateTime);
Compare Dates in Java:
You can compare dates in Java using methods like compareTo(), after(), before(), or by converting
dates to milliseconds and comparing them.
import java.util.Date;
Date date1 = new Date();

Date date2 = new Date();
// Compare dates using compareTo()

int comparison = date1.compareTo(date2);
if (comparison > 0) {
System.out.println("Date 1 is after Date 2");
} else if (comparison < 0) {
System.out.println("Date 1 is before Date 2");
} else {
System.out.println("Date 1 is equal to Date 2");
}
Alternatively, you can use after() and before() methods:
\
if (date1.after(date2)) {
System.out.println("Date 1 is after Date 2");
} else if (date1.before(date2)) {
System.out.println("Date 1 is before Date 2");
} else {
System.out.println("Date 1 is equal to Date 2");
}
These methods allow you to compare dates based on their chronological order. However, it's
important to note that the Date class is not recommended for new code, and it's better to use the
classes from the java.time package for date and time operations in Java 8 and later versions.

java core

Uploaded by

java core

Uploaded by

Java Basic Syntax

Data Types in Java

Primitive vs. Non-Primitive Data Types

// Non-primitive data type

public void myMethod() {

Java Wrapper Classes

Taking Input from Users in Java

public class InputExample {

nextInt(): Reads an integer.

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

public class Main {

Use readLine() to read a line of text:

BufferedReader is less common in modern Java due to Scanner's simplicity.

Scanner vs. BufferedReader:

Ways to Read Input from Console in Java:

Difference Between print() and println():

Formatted Outputs in Java:

System.out.printf("Your name is: %s\n", name);

Decision Making in Java:

for (initialization; condition; update) {

for (datatype element : array/collection) {

The break statement is used to exit a loop prematurely.

break can be used in various scenarios, such as:

Certainly! Here's an explanation of each type of operator along with examples:

Arithmetic operators are used to perform mathematical operations on operands.

Assignment operators are used to assign values to variables.

Relational operators are used to compare two values.

Ternary operator is a conditional operator that takes three operands.

Bitwise operators perform operations on individual bits of operands.

int a = 5; // 101 in binary

Introduction of Strings in Java:

Why Strings are Immutable in Java?:

StringBuffer class in Java and StringBuilder class in Java:

Here's an example demonstrating the usage of StringBuffer and StringBuilder:

StringBuffer buffer = new StringBuffer("Hello");

StringBuilder builder = new StringBuilder("World");

buffer.append(", Java!"); // Modify StringBuffer

builder.append(", Java!"); // Modify StringBuilder

StringJoiner joiner = new StringJoiner(", ", "[", "]");

String result = joiner.toString(); // Output: "[Apple, Banana, Orange]"

Java String Programs:

String Manipulation: Concatenation, substring extraction, replacing characters, converting

String Formatting: Using String.format() or printf() methods to format strings with

Here's a simple example demonstrating some of these operations:

// String searching and matching

Introduction to Arrays in Java:

// Declaration and initialization of an array of integers

Declaration and Initialization of Arrays in Java:

// Declaring an array of strings with a specified size

// Declaring and initializing an array using the 'new' keyword

Multi-Dimensional Arrays / Initializing 2D Arrays in Java:

// Declaration and initialization of a 2D array

Jagged Array in Java:

// Declaration and initialization of a jagged array

Final Arrays in Java:

final int[] finalArray = {1, 2, 3};

Reflect Arrays in Java:

Object array = Array.newInstance(int.class, 3);

Difference between util.Arrays and reflect.Arrays:

Java Array Programs:

OOPS Concept in Java:

Car myCar = new Car(); // Creating an object

Classes and Objects:

MyClass obj = new MyClass(); // Creating an object

Naming Convention in Java:

Class names should start with an uppercase letter.

// Method without parameters and return value

public class AccessModifiersExample {

Four Pillars of OOPS in Java:

// Getter and setter methods for encapsulation

public void setName(String name) {

public int getAge() {

public void setAge(int age) {

class Dog extends Animal {

// Creating an object of subclass Dog

double add(double a, double b) {