DEV Community: PRIYA K

Exception Handling in Java

PRIYA K — Fri, 22 May 2026 05:43:36 +0000

An exception is an event, which occurs during the execution of a program,that disrupts the normal flow of the program's instructions.
An exception is an error that happens while the program is running.
Because of that error, the normal execution stops.

Example

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

        int a = 10;
        int b = 0;

        System.out.println(a / b);

        System.out.println("Program Ends");
    }
}

What happens?
a / b
means:
10 / 0
Division by zero is not allowed.
So Java throws:
Arithmetic Exception

Program stops before:

System.out.println("Program Ends");

This is called:
disrupting the normal flow of the program.

When an error occurs within a method,the method creates an object and hands it off to the runtime system.

When error occurs:
Java creates an exception object
sends it to JVM/runtime system.

Example

public class Main {
    static void divide() {
        int x = 10 / 0;
    }
    public static void main(String[] args) {
        divide();
    }
}

What happens?
Inside:
divide()
error occurs.

Java creates object:
Arithmetic Exception object and gives it to JVM.
The object, called an exception object,contains information about the error.

The exception object stores:
error type
error message
line number
method details

Example

Exception in thread "main"
java.lang.Arithmetic Exception: / by zero

Information stored:
Information Value
Exception type Arithmetic Exception
Error message / by zero
Thread main

Including its type and state of the program.

Java remembers:
where error happened
what methods were running
current program state

Example

static void test() {
    int a = 10 / 0;
}

Java remembers:

error inside test()

line number
method calls

Creating an exception object is called throwing an exception
Creating an exception object and handing it to the runtime system is called throwing an exception.
Java sends the exception to JVM.

This process is called:
throwing an exception

Example
Automatic throwing:

int x = 10 / 0;

Java automatically throws:
Arithmetic Exception
Manual throwing
throw new Arithmetic Exception();
Here programmer throws exception manually.

After a method throws an exception.
After a method throws an exception,
the runtime system attempts to find something to handle it.

JVM searches for:
catch
block to handle the exception.

Example

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

Output:
Cannot divide by zero
Now program does not crash.

The set of possible somethings.
The set of possible "somethings" to handle the exception is the ordered list of methods that had been called

Java checks method calls one by one.
It searches where exception can be handled.

“The list of methods is known as call stack”
The order of method calls is called:
Call Stack

Example of Call Stack
class Main {

static void method1() {
    method2();
}

static void method2() {
    method3();
}

static void method3() {
    int x = 10 / 0;
}

public static void main(String[] args) {
    method1();
}

}

Flow
main()
↓
method1()
↓
method2()
↓
method3()
↓
Exception occurs

This chain is called:
Call Stack
Stack Trace

Java prints:
Exception in thread "main"
java.lang.Arithmetic Exception: / by zero.

This shows:
where exception started
how methods were called

Simple Summary
Exception Runtime error
Exception Object Object containing error info
Throwing Exception Sending exception to JVM
Handling Exception Using try-catch
Call Stack Order of method calls
Stack Trace Printed error path

The runtime system searches the call stack for a method that contains a block of code that can handle the exception.
When an exception occurs:
JVM checks method calls one by one searches for a catch block
This searching happens in the call stack.

Example

class Main {

    static void method1() {
        method2();
    }

    static void method2() {
        int x = 10 / 0;
    }

    public static void main(String[] args) {
        method1();
    }
}

What happens?
Call stack:
main()
↓
method1()
↓
method2()

Exception occurs inside:
method2()

JVM starts searching:
method2()
method1()
main()
for a catch block.

This block of code is called an exception handler.
The catch block is called:
Exception Handler
because it handles the exception.

Example

try {
    int x = 10 / 0;
}
catch (ArithmeticException e) {
    System.out.println("Error handled");
}

Here:
catch (ArithmeticException e)
is the exception handler.

The search begins with the method in which the error occurred
JVM first checks the method where exception happened.

Example

static void method2() {

    try {
        int x = 10 / 0;
    }

    catch (ArithmeticException e) {
        System.out.println("Handled in method2");
    }
}

Output:
Handled in method2
JVM found handler immediately in same method.

And proceeds through the call stack in reverse order proceeds through the call stack in the reverse order
If handler is not found:
JVM goes backward through method calls.

Example

class Main {

    static void method1() {
        method2();
    }

    static void method2() {
        int x = 10 / 0;
    }

    public static void main(String[] args) {

        try {
            method1();
        }

        catch (ArithmeticException e) {
            System.out.println("Handled in main");
        }
    }
}

Flow
main()
↓
method1()
↓
method2()

Exception in method2.
No catch there.
JVM moves backward:
method2 → method1 → main
Finally handler found in main().

Output:
Handled in main

When an appropriate handler is found,the runtime system passes the exception to the handler.
If matching catch block is found:
JVM sends exception object to catch block,catch block executes.

Example

try {
    int x = 10 / 0;
}

catch (Arithmetic Exception e) {
    System.out.println(e);
}

Output:
java.lang.ArithmeticException: / by zero

The exception object is passed into:
e

An exception handler is considered appropriate, if the type of the exception object thrown matches the type that can be handled by the handler.
Catch type must match exception type.

Example

try {
    int x = 10 / 0;
}

catch (ArithmeticException e) {
    System.out.println("Handled");
}

Exception type:
Arithmetic Exception
Catch type:
Arithmetic Exception
So handled successfully.

Example
try {
int x = 10 / 0;
}

catch (Null PointerException e) {
System.out.println("Handled");
}

Not handled.

Because:
Arithmetic Exception ≠ Null Pointer Exception

The exception handler chosen is said to catch the exception.
When catch block handles error:
Exception is caught

Example

catch (Arithmetic Exception e)

This block catches the exception.

If the runtime system exhaustively searches all methods on the call stack without finding an appropriate exception handler

If JVM cannot find matching catch block anywhere:
exception remains unhandled

Example

class Main {

    public static void main(String[] args) {

        int x = 10 / 0;
    }
}

No try-catch.
JVM searches:
main()
No handler found.

the runtime system terminates
the runtime system (and consequently the program)
terminates
Program stops immediately.
Output

Exception in thread "main"
java.lang.ArithmeticException: / by zero

Program crashes.

Exception occurs
↓
JVM creates exception object
↓
Searches current method
↓
Searches call stack backward
↓
Matching catch found
YES → Handle exception
NO → Program terminates

Example

class Main {
    static void test() {
        int x = 10 / 0;
    }

    public static void main(String[] args) {

        try {
            test();
        }

        catch (ArithmeticException e) {
            System.out.println("Exception handled");
        }

        System.out.println("Program continues");
    }
}

Output:
Exception handled
Program continues

Because JVM found appropriate handler in main().

String Methods in Java

PRIYA K — Thu, 21 May 2026 04:56:55 +0000

In Java, instance methods are methods called using an object.
Example:

String s = "Java";
System.out.println(s.length());

Here length() is an instance method.

Common properties
Access modifier → public
Constructor → No (these are methods)
Final → Most methods are not declared final
Called using object

Example:

String s = "Java";
s.length();

1. length()
Returns number of characters.

String s = "Java";
System.out.println(s.length());

Output:
4

2. charAt(int index)
Returns character at index.

String s = "Java";
System.out.println(s.charAt(2));

Output:
v

3. substring()
Extracts part of string.

String s = "Java";
System.out.println(s.substring(1,3));

Output:
av

4. equals()
Compares content.

String a = "java";
String b = "java";
System.out.println(a.equals(b));

Output:
true

5. equalsIgnoreCase()
Ignores uppercase/lowercase.

String a = "JAVA";
System.out.println(a.equalsIgnoreCase("java"));

Output:
true

6. compareTo()
Compares alphabetically.

System.out.println("apple".compareTo("banana"));

Output:
negative value

7. contains()
Checks if string exists.

String s = "Java Programming";
System.out.println(s.contains("Java"));

Output:
true

8. concat()
Joins strings.

String s = "Java";
System.out.println(s.concat(" SQL"));

Output:
Java SQL

9. toUpperCase()
Converts to uppercase.

String s = "java";
System.out.println(s.toUpperCase());

Output:
JAVA

10. toLowerCase()
Converts to lowercase.

String s = "JAVA";
System.out.println(s.toLowerCase());

Output:
java

11. trim()
Removes spaces at beginning/end.

String s = "  Java  ";
System.out.println(s.trim());

Output:
Java

12. startsWith()
Checks starting characters.

String s = "Java";
System.out.println(s.startsWith("Ja"));

Output:
true

13. endsWith()
Checks ending characters.

String s = "Java";
System.out.println(s.endsWith("va"));

Output:
true

14. indexOf()
Returns first index.

String s = "Java";
System.out.println(s.indexOf("a"));

Output:
1

15. replace()
Replaces characters.

String s = "Java";
System.out.println(s.replace('a','o'));

Output:
Jovo

16. split()
Splits string into array.

String s = "A-B-C";
String[] arr = s.split("-");

Output array:
A
B
C

Constructor of String
Constructors create String objects.

Example:
String s = new String("Java");

Some constructors:
Constructor
public String()
public String(String original)
public String(char[] value)
public String(byte[] bytes)
Simple summary

String instance methods:
are mostly public
called using object
return different types
help in:
searching
comparing
extracting
converting
modifying strings (by creating new strings)

String in Java

PRIYA K — Wed, 20 May 2026 05:51:06 +0000

In Java, String is a class used to store a sequence of characters (text).
Example:

String name = "Priya";

Here "Priya" is a string.

A string can store:
words
sentences
symbols
characters
So, String means text data in Java.

Two ways of creating String
1. Using string literal

String s1 = "Hello";

Most common way.
Java stores it in the string pool.
Memory efficient.

Example

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

        String a = "Java";
        String b = "Java";

        System.out.println(a == b);
    }
}

Output:
true

Because both a and b point to the same object in the String pool.

String Pool
Java stores string literals in a special memory area called the String Constant Pool.

2. Using new keyword

String s2 = new String("Hello");

Creates a new object explicitly.
Stored in heap memory.

Example

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

        String s1 = new String("Java");
        String s2 = new String("Java");

        System.out.println(s1);
        System.out.println(s2);

        System.out.println(s1 == s2);
        System.out.println(s1.equals(s2));
    }
}

Output
Java
Java
false
true

new keyword creates a new object
Object is created in heap memory
Even if "Java" already exists, Java creates another new object

Same for:

String s2 = new String("Java");

So s1 and s2 are different objects.

Why s1 == s2 is false

System.out.println(s1 == s2);

Output:
false

== compares memory address/reference
s1 and s2 are different objects in memory

Why s1.equals(s2) is true

System.out.println(s1.equals(s2));

Output:
true

equals() compares actual content
Both strings contain "Java"

Memory Representation

    String s1 = new String("Java");
    String s2 = new String("Java");

Heap Memory
s1 ---> "Java" (Object 1)

s2 ---> "Java" (Object 2)
Two separate objects are created.

Difference
String Literal Using new
String s = "abc"; String s = new String("abc");
Stored in string pool Stored in heap
Reuses existing object Creates new object
Memory efficient Creates separate object

Why strings are immutable
Immutable means: once created, the value cannot be changed.

Example:

String s = "Hello";
s.concat(" World");
System.out.println(s);

Output:
Hello

Because concat() creates a new string, old one stays same.

Reason why Java made String immutable
Security
String is used in passwords, file paths, URLs.
If mutable, values could be changed unexpectedly.
Memory saving
String pool can safely share objects.
Thread safety
Multiple threads can use the same string safely.
Performance
Hashcode caching and reuse are easier.

example

String s = "abc";
s = s + "d";

"abc" remains unchanged.
New object "abcd" is created.
s now points to new object.

So String is immutable because Java protects data and improves memory efficiency.

In Java, String belongs to the java.lang package.
Compact Strings (compact1, compact2, compact3)

In newer Java versions, String internally stores characters in a memory-saving way. This is called Compact Strings. It means Java stores simple English text using less memory.

Example 1 (compact1)

String s1 = "hello";

Contains only English letters.
Java stores it efficiently (1 byte per character internally).

Example 2 (compact2)

String s2 = "java";

Also only English letters.
Stored in compact form.

Example 3 (compact3)

String s3 = "தமிழ்";

Contains Tamil characters.
Java cannot use compact Latin storage here.
It uses more bytes internally.

Why Java uses compact strings?
saves memory
improves performance
automatic (programmer does not control it)

So, Compact String is an internal optimization of java.lang.String

java.lang.Object
Object is the parent class of all classes in Java.
Every class automatically inherits from Object.
So String also comes from Object.

Object → String

That means:
String is a child class of Object.

java.lang.String
This is the full package name.
package → java.lang
class → String

So:
String s = "Hello";

actually means:

java.lang.String s = "Hello";

All Implemented Interfaces
Serializable, CharSequence, Comparable
This means String implements these interfaces.

Serializable
A string object can be converted into bytes and saved/transferred.

Example:
save object to file
send through network

CharSequence
String is a sequence of characters.

Example:
String name = "Priya";

Characters:
P r i y a
So String stores characters in order.

Comparable
String objects can be compared.

Example:
String a = "apple";
String b = "banana";
System.out.println(a.compareTo(b));

Java compares alphabetically.

java.lang.Object
        ↑
   java.lang.String

String inherits from Object and implements:

String is a class in java.lang, child of Object, and it can:
store characters
compare strings
be saved/transferred as data

public final class String

public → String can be used anywhere in Java.
final → String class cannot be inherited (you cannot extend it).
class String → String is a predefined class in Java.

extends Object
String is a child class of Object.
In Java, every class indirectly comes from Object.

So:
Object → String
implements Serializable, Comparable, CharSequence

This means String implements these interfaces:
Serializable
String objects can be saved to a file or sent over a network.

Comparable
Strings can be compared.

Example:

String a = "apple";
String b = "banana";
System.out.println(a.compareTo(b));

CharSequence
String is a sequence of characters.
Example:

String s = "abc";

contains characters:
a b c
“The String class represents character strings”
It means:
String is used to store text.

Example:

String name = "Priya";

Here "Priya" is a string.

“All string literals … are instances of this class”
A string literal means text inside quotes:

"abc"
"hello"
"java"
These are all objects of String.
Example:

String str = "abc";

Java automatically creates a String object.
“Strings are constant; their values cannot be changed”
This means String is immutable.
Once created, its value cannot change.
Example:

String s = "hello";
s = s + " world";

This does not change the old object.
Java creates a new string object "hello world".

“String buffers support mutable strings”
If you want to change string content without creating many new objects, Java provides:
StringBuffer
StringBuilder
These are mutable (changeable).

Example

String str = "abc";

Java directly creates a string object with "abc".

char data[] = {'a', 'b', 'c'};
String str = new String(data);

character array is created:
{'a', 'b', 'c'}
That array is passed to String constructor.
It becomes "abc".

Both produce the same output:
abc

String stores text.
It is a class in java.lang.
It is immutable (cannot change after creation).
It inherits from Object.
It implements interfaces like Serializable, Comparable, and CharSequence.
"abc" and new String(data) both create string objects.

Examples of using String
Example 1

System.out.println("abc");

Prints the string directly.

Output:
abc

Example 2

String cde = "cde";
System.out.println("abc" + cde);

"abc" and "cde" are joined using +.

Output:
abccde

joins two strings. This is called string concatenation.

Example 3

String c = "abc".substring(2,3);
substring(start, end)
start index = 2
end index = 3 (excluded)

String "abc" index:
a b c
0 1 2

So:

"abc".substring(2,3)

takes character at index 2 → "c"

Output:
c

Example 4

String d = cde.substring(1,2);
cde = "cde"

Index:
c d e
0 1 2
substring(1,2) → "d"

Output:
d

String methods
String class has many methods.
It can:
examine characters
compare strings
search text
extract substring
convert uppercase/lowercase

Example:

String name = "Priya";
System.out.println(name.length());
System.out.println(name.toUpperCase());
System.out.println(name.toLowerCase());

Output:
5
PRIYA
priya

+ operator support
Java gives special support for:

String a = "Hello";
String b = "World";
System.out.println(a + b);

Output:
HelloWorld

Internally Java converts this to:

StringBuilder sb = new StringBuilder();
sb.append(a);
sb.append(b);

So + uses:
StringBuilder
or StringBuffer

Object to String conversion
Any object can be converted to string using:

toString()

Example:

Integer num = 10;
System.out.println(num.toString());

Output:
10
Because every class inherits from Object.

NullPointerException
If you pass null to some String methods, Java may throw:
Example:

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

Error:
NullPointerException
Because s points to nothing.

UTF-16 format
Java stores strings internally in UTF-16.
That means it supports many world languages:
English
Tamil
Hindi
Chinese

Example:

String s = "தமிழ்";

This works because Java uses Unicode.

Index values in String
Each character has an index.
Example:

String word = "java";

Indexes:
j a v a
0 1 2 3
You can access characters using:

word.charAt(2)

Output:
v

Unicode supplementary characters
Some special symbols/emojis need 2 positions.
Example:
String emoji = "😊";
Though it looks like 1 symbol, internally UTF-16 may use 2 char positions.

String in Java:
stores text
supports concatenation with +
supports substring
supports searching/comparing
uses UTF-16 Unicode
immutable
supports many methods like:
length()
charAt()
substring()
toUpperCase()
toLowerCase()

Dynamic Binding in Java

PRIYA K — Tue, 19 May 2026 07:32:35 +0000

Dynamic binding means:
The method that gets executed is decided at runtime, based on the actual object.
It is also called:
Runtime binding
Late binding
This happens mainly with method overriding.

Example

class Animal {
    void sound() {
        System.out.println("Animal sound");
    }
}

class Dog extends Animal {
    void sound() {
        System.out.println("Dog barks");
    }
}

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

        Animal a = new Dog();
        a.sound();
    }
}

Output
Dog barks

Why?

Animal a = new Dog();

means:
reference type = Animal
object type = Dog
At compile time, Java sees Animal.
But at runtime, actual object is Dog, so Java calls:

Dog's sound()

This is dynamic binding.

Which method is called? → sound()
Which actual object exists? → Dog
Executes Dog’s overridden method

Example
Parent class = general remote
Child class = TV remote / AC remote
Pressing same button behaves differently depending on actual device.

Dynamic vs Static Binding
Static Binding Dynamic Binding
Decided at compile time Decided at runtime
Method overloading Method overriding
Faster Slightly slower
Early binding Late binding

Static Binding Example

class Test {
    static void show() {
        System.out.println("Hello");
    }
}

Static methods are bound at compile time.

Dynamic Binding Example
Animal a = new Dog();
a.sound();

Bound at runtime.
Easy memory trick

Overriding + object created at runtime = dynamic binding

Final Keyword in Java

PRIYA K — Thu, 14 May 2026 05:52:03 +0000

In Java, final means something cannot be changed further. It can be applied to variables, methods, and classes — but the effect is different in each case.

1. Final Variable
A final variable can be assigned only once. After that, its value cannot change.

class Demo {
    final int age = 20;

    void display() {
        // age = 25;  // Error: cannot change final variable
        System.out.println(age);
    }
}

Why use it?
When you want a constant value, like PI, fixed ID, etc.

Example:

final double PI = 3.14;

2. Final Method
A final method cannot be overridden by a child class.

class Parent {
    final void show() {
        System.out.println("Parent method");
    }
}

class Child extends Parent {
    // void show() { }   // Error: cannot override final method
}

Why use it?
To prevent subclasses from changing the original behavior of a method.

3. Final Class
A final class cannot be inherited (extended).

final class Vehicle {
    void run() {
        System.out.println("Running");
    }
}

// class Car extends Vehicle { }  // Error: cannot inherit final class

Why use it?
When you want to stop other classes from inheriting it.

A common example is String class in Java — String is final, so no class can extend it.

Pattern Printing 2

PRIYA K — Wed, 13 May 2026 04:45:08 +0000

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

        int num = 1;

        for (int row = 1; row <= 5; row++) {

            for (int col = 1; col <= 6 - row; col++) {
                System.out.print(num + " ");
                num++;
            }

            System.out.println();
        }
    }
}

Output
1 2 3 4 5
6 7 8 9
10 11 12
13 14
15

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

        for (int row = 1; row <= 5; row++) {

            char ch = 'A';

            for (int col = 1; col <= 6 - row; col++) {
                System.out.print(ch + " ");
                ch++;
            }

            System.out.println();
        }
    }
}

Output
A B C D E
A B C D
A B C
A B
A

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

        for (int row = 1; row <= 5; row++) {

            char ch = (char)('F' - row);

            for (int col = 1; col <= 6 - row; col++) {
                System.out.print(ch + " ");
                ch--;
            }

            System.out.println();
        }
    }
}

Output
E D C B A
D C B A
C B A
B A
A

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

        for (int row = 1; row <= 5; row++) {

            for (int col = 1; col <= 5 - row; col++) {
                System.out.print(col + " ");
            }

            System.out.print("*");
            System.out.println();
        }
    }
}

Output
1 2 3 4 *
1 2 3 *
1 2 *
1 *
*

Pojo Class in Java

PRIYA K — Tue, 12 May 2026 05:22:03 +0000

POJO class in Java
POJO stands for Plain Old Java Object.
It means a simple Java class that is used to store data.
A POJO class is a simple Java class used to store and transfer data through objects.

A POJO class usually contains:
private variables (fields)
getter methods
setter methods
constructor (optional)
It does not need special inheritance or framework-specific code.

Simple Example

class Student {
    private String name;
    private int age;

    public Student() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
Using the POJO class
public class Main {
    public static void main(String[] args) {

        Student s = new Student();

        s.setName("Priya");
        s.setAge(21);

        System.out.println(s.getName());
        System.out.println(s.getAge());
    }
}

Output:
Priya
21

Why use POJO class?
A POJO is mainly used to represent real data objects.

Example:
Student details
Employee details
Bank account details

Instead of keeping many separate variables, we group related data into one object.

Why not just use normal variables?
Without POJO:
String name = "Priya";
int age = 21;

This works for one person, but for many students it becomes messy.

With POJO:
Student s1 = new Student();
Student s2 = new Student();

Each object can store separate data.

Main features of POJO
Simple class
No special restrictions
Used for storing data
Reusable
Easy to maintain

String Programs

PRIYA K — Tue, 12 May 2026 00:40:25 +0000

1.{{{{}}}}

let str="{{{{}}}}";
let end=str.length-2;
let start=1;
let temp;
let arr=[];

for(let i=0;i<str.length;i++){
      arr[i] = str[i]
    }
  while(start<end){

        temp=arr[start];
        arr[start]=arr[end];
        arr[end]=temp;
        start+=2;
        end-=2;


}
let result = "";
for (let i = 0; i < arr.length; i++) {
    result += arr[i];          // Fix 2: build result string
}
 console.log(result);

output
{}{}{}{}

2.BBBBGGGG

let str="BBBBGGGG";
let end=str.length-2;
let start=1;
let temp;
let arr=[];

for(let i=0;i<str.length;i++){
      arr[i] = str[i]
    }
  while(start<end){

        temp=arr[start];
        arr[start]=arr[end];
        arr[end]=temp;
        start+=2;
        end-=2;


}
let result = "";
for (let i = 0; i < arr.length; i++) {
    result += arr[i];          // Fix 2: build result string
}
 console.log(result);

Output
BGBGBGBG

3.IceCream

let sen = "";

let arr = [];

// convert string to array manually
for (let i = 0; i < sen.length; i++) {
    arr[i] = sen[i];
}

let left = 0;
let right = arr.length - 1;

function isVowel(ch) {
    return ch == 'a' ||
           ch == 'e' ||
           ch == 'i' ||
           ch == 'o' ||
           ch == 'u';
}

while (left < right) {

    while (left < right && !isVowel(arr[left])) {
        left++;
    }

    while (left < right && !isVowel(arr[right])) {
        right--;
    }

    // swap
    let temp = arr[left];
    arr[left] = arr[right];
    arr[right] = temp;

    left++;
    right--;
}

// print manually
let result = "";

for (let i = 0; i < arr.length; i++) {
    result = result + arr[i];
}

console.log(result);

Output
acecreim

4.a1b2c3d4

str="a1b2c3d4";
result="";

for(let i=0;i<str.length;i=i+2){
  ch=str[i]

   let count = str[i + 1];

    for (let j = 0; j <= count; j++) {
        result = result + ch;
    }
}
console.log(result);

Output
aabbbccccddddd

5.a1b2c3d4

str="a1b2c3d4";
result="";

for(let i=0;i<str.length;i=i+2){
  ch=str[i]

   let count = str[i + 1];

    for (let j = 1; j <= count; j++) {
        result = result + ch;
    }
}
console.log(result);

Output
abbcccdddd

6.abcd1234

et str = "abcd1234";

let result = "";

let mid = str.length / 2;

for (let i = 0; i < mid; i++) {

    result = result + str[i];

    result = result + str[mid + i];
}

console.log(result);

Output
a1b2c3d4

CSS

PRIYA K — Sat, 09 May 2026 03:06:09 +0000

CSS (Cascading Style Sheets)
To add Styles to HTML
Styles-->adding colors,fonts,size,borders etc..,
Css is not a programming language.Css is not a Markup language either.
CSS is a Style Sheet Language. CSS is a rule-based language.

How to define Style for HTML Elements
1.In Line

<h1 style="color:red"> Priya </h1>

2.By Using Style Tag:

<html>
<head>
<style type="text/css">
h1{
   color:blue;
  }
</style>
</head>
<h1> Boopathi </h1>

3.keep separate CSS file
name as
Style.CSS


h1{color:red}

name as
index.html


<html>
<head>
<link rel="stylesheet" href="styles/style1.css">
</head>
<h1> Priya </h1>

4.Basic Structure Of CSS

tagname{
    property:value;
      }

eg.

h1{color:red;}

5.CSS comments = (/* Comments*/)
6.code: html

<html>
<head>
<link rel="stylesheet" href="styles/style1.css">
</head>
<h1> Priya </h1>
<p> This is the book </p>

code: css

h1{
   color:red;
   font-size: 5em;
}
p{
  color:black;
 }

Multiply Property values: code: html

<html>
<head>
<link rel="stylesheet" href="styles/style1.css">
</head>
<h1> Priya </h1>
<p> This is the book </p>

code:style1.Css

p{
  color:red;
  width: 500px;
  border: 1px solid black;
}

8.Selecting Multiple Elements
code: html

<html>
<head>
<link rel="stylesheet" href="styles/style1.css">
</head>
<h1> Priya </h1>
<p> This is the book </p>

code:style1.css

p,h1{
  color:red;
  width: 500px;
  border: 1px solid black;
}

9.CSS Selectors

<!DOCTYPE HTML>
<html>
<head>
<style>
p{
  text-align:center;
  color:red;
}
</style>
</head>
<body>
  <p>At W3Schools you will find complete references.</p>
  <p id="para1"> this style </p>
  <p> matches </p>
</body>
</html>

10.id selectos= apply selectors to more than one paragraph.

<!DOCTYPE HTML>
<html>
<head>
<style>
#para1{
  text-align:center;
  color:red;
}
#para2{
  text-align:center;
  color:blue;
}
</style>
</head>
<body>
  <p>At W3Schools you will find complete references.</p>
  <p id="para1"> this style </p>
  <p id="para2"> Book </p>
  <p> matches </p>
</body>
</html>

11.class selectors

<!DOCTYPE HTML>
<html>
<head>
<style>
.abcd{
  text-align:center;
  color:red;
</style>
</head>
<body>
  <h1 class="abcd"> where the wind blows </h1>
  <p class="bcde"> how the sea seems</p>

</body>
</html>

12.more than one class (keep . before the class name)

<!DOCTYPE HTML>
<html>
<head>
<style>
p.abcd{
  text-align:center;
  color:red;
  }
p.pqrs{
  font-size:300%
  }
</style>
</head>
<body>
  <h1 class="abcd"> clear appearance </h1>
  <p class="abcd"> in the middle </p>
  <p class="abcd pqrs"> Everything Changes</p>
</body>
</html>

13.Universal Selectors

<!DOCTYPE HTML>
<html>
<head>
<style>
*{
  text-align:center;
  color:red;
</style>
</head>
<body>
  <h1> Good Morning </h1>
  <p> Red </p>
  <p id ="para1"> Red Only </p>
  <p id > This also Red Only </p>
</body>
</html>

14.CSS Attribute Selector

<!DOCTYPE HTML>
<html>
<head>
<style>
a[target] {
   background-color:yellow;
}
</style>
</head>
<body>
  <h2> CSS[attribute] Selector </h2>
  <p> see where the yellow color changes </p>
  <a href ="https://www.ilugc.in" target="_blank"> ILUGC </a>
  <a href ="https://www.wikipedia.org" target="_blank"> Wikipedia 
</a>
</body>
</html>

15.

<!DOCTYPE HTML>
<html>
<head>
<style>
a[href] {
   background-color:yellow;
}
</style>
</head>
<body>
  <h2> CSS[attribute] Selector </h2>
  <p> see where the yellow color changes </p>
  <a href ="https://www.ilugc.in" target="_blank"> ILUGC </a>
  <a href ="https://www.wikipedia.org" target="_blank"> Wikipedia 
</a>
</body>
</html>

16.CSS Attribute Selector

<!DOCTYPE HTML>
<html>
<head>
<style>
[title~=linux] {
   border: 5px solid red;
}
</style>
</head>
<body>
  <h2> [attribute~="value"] see style </h2>
  <p> attribute Style Changes </p>
  <img src="rabbit.jpeg" title="animal" width="150" height="250">  
  <img src="linux.jpeg" title="linux" width="150" height="250"> 
  <img src="linux.jpeg" title="logo of linux" width="150" height="250"> 
</body>
</html>

17.CSS Attribute Selector

<!DOCTYPE HTML>
<html>
<head>
<style>
[class |= top] {
  background:yellow;
</style>
</head>
<body>
  <h2> CSS [attribute|="value"] Selector </h2>
  <h1 class="top-header"> Day dreamers </h1>
  <p class="top-text"> what i saw  </h1>
  <p class="topcontent"> Seeing God </h1>

CSS [attribute^="value"] Selector class^ --> starts with specified value

<!DOCTYPE HTML>
<html>
<head>
<style>
[class ^= "abc"] {
  background:pink;
}
</style>
</head>
<body>
  <h1> CSS [attribute^="abcd"] Selector </h1>
  <p class="abcd"> what i saw  </h1>
  <h1 class="bcde-123">change direction </h1>
  <p class="abcdefgh"> Seeing God </h1>
</body>
</html>

CSS [attribute$="value"] Selector

<!DOCTYPE HTML>
<html>
<head>
<style>
[class $= "xyz"] {
  background:pink;
}
</style>
</head>
<body>
  <h2> CSS [attribute$="value"] Selector </h2>
  <div class="abc_xyz"> what i saw  </div>
  <div class="abc">change direction </div>
  <div class="stuvwxyz"> Seeing God </div>
  <p class ="abc-xyz">Do everything by making plans </p>
</body>
</html>

CSS [attribute*="value"] Selector

<!DOCTYPE HTML>
<html>
<head>
<style>
[class *= "xy"] {
  background:pink;
}
</style>
</head>
<body>
  <h2> CSS [attribute *="value"] Selector </h2>
  <div class="abc_xyz_1"> what i saw  </div>
  <div class="xyabz">change direction </div>
  <div class="stuvwxyz_"> Seeing God </div>
  <p class ="aby-xz">Do everything by making plans </p>
</body>
</html>

Descendant Selector

<!DOCTYPE HTML>
<html>
<head>
<style>
div p{
  background:yellow;
}
</style>
</head>
<body>
  <h2> Descendant Selector </h2>
  <div>
    <p> iam p, div between two.</p>
    <p> iam also p, div between two.</p>
    <section><p> i too p,div between two.</p></section>
  </div>
  <p> iam living in p only </p>
  <p> iam living in p only </p>
</body>
</html>

Child Selector(>)

<!DOCTYPE HTML>
<html>
<head>
<style>
div > p{
  background:yellow;
}
</style>
</head>
<body>
  <h2> Descendant Selector </h2>
  <div>
    <p> iam p, div between two.</p>
    <p> iam also p, div between two.</p>
    <section><p> i too p,div between two.</p></section>
  </div>
  <p> iam living in p only </p>
  <p> iam living in p only </p>
</body>
</html>

nth type of selectors

<!DOCTYPE HTML>
<html>
<head>
<style>
/* Select the second element of div siblings */
div: nth-of-type(2) {
    background: red;
    color:yellow;
}
/* Select the second li element in a list*/
li: nth-of-type(2) {
    background: lightgreen;
    color:red;
}
/* Select every third  element among any group: nth-of-type(3) {
    background:yellow;
}
</style>
</head>
<body>

<div>
<p> Believe yourself </p>
</div>

<div>
<p> Past memories </p>
</div>

<div>
<p> Leader </p>
</div>
<ul>
  <li> Mahatma Gandhi </li>
  <li> Nehruji </li>
  <li> Indira Gandhi </li>
  <li>  nethaji </li>
  <li> Chandra Bose </li>
</ul>
</body>
</html>

24.
document ->html-> index.html
document ->html->style ->style1.css

Text:
color --> "#ff0000","rgb(0,255,0)","red"
text-align --> Left,Right,center,Justify
text-decoration --> link
text-transform --> uppercase,lowercase,capitalize
text-indent -->

index.html

<html>
<head>
<link rel="stylesheet" href="styles/style.css">
</head>
<body>
<p class="first"> Dont Giveup! Keep on Trying! </p>
<p class="second">Even through it seems to be impossible,It will happen in your life one day</p>
<p class="third">All the very best Friends! Wait to receive the suprises in your life!!!!!</p>
</body>
</html>

style.css

p.first
{color:green;text-decoration:overline;text-transform:uppercase;test-indent:50px;}
p.second
{color:#0000ff;text-align:right;text-decoration:line-through;text-transform:lowercase;}
p.third
{color:rgb(255,0,0);text-align:center;text-decoration:underline;text-decoration:capitalize;}

25.Font:
font-family
font-style: Normal,Italic,Bold,Oblique
font-size: px,em

index.html

<html>
<head>
<link rel="stylesheet" href="styles/style.css">
</head>
<body>
<p class="first"> Dont Giveup! Keep on Trying! </p>
<p class="second">Even through it seems to be impossible,It will happen in your life one day</p>
<p class="third">All the very best Friends! Wait to receive the suprises in your life!!!!!</p>
</body>
</html>

style.css

p.first{font-family:"Tiems New Roman",Times,serif; font-style:Oblique;font-size:10;}
p.second{font-style:italic;font-size:20;}
p.third{font-style:bold;font-size:30;}

Link: decorate link by color,font-family,font size

a:link =
a:hover =
a:active =
a.vsited=

index.html


<html>
<head>
<link rel="stylesheet" href="styles/style.css">
</head>
<body>
<a href="https://freetamilebooks.com/ebooks/-eliya_tamilil_software_testing/" target="_blank"> Click here for Software Testing book </a>
</body>
</html>

style1.css

a:hover{color:red;background-color:yellow;}
a:active{color:white;background-color:black;}
a:visited{color:blue;background-color:lightgreen;}

List: Ordered List Unordered List

CSS

index.html

<html>
<head>
<link rel="stylesheet" href="styles/style1.css">
</head>
<body>

Types Of Testing

<ol>
<li> Funtional Testing </li>
<li> Non- Funtional Testing </li>
</ol>

Types of non-functional testing

<ul>
<li> Funtional Testing </li>
<li> Automation Testing </li>
</ul>
</body>
</html>

style.css

ol li{list-style-type:upper-roman;}
ol li{list-style-type:upper-circle;}

28.Visibility Property:
Display:
inline

style.css:


ol li{visibility: hidden;}
ol li{display:inline;}

TABLES:

<html>
<head>
<link rel="stylesheet" href="styles/style1.css">
</head>
<body> <table>

<tr>
<th> Name </th>
<th> Marks </th>
<th> Rank </th>
</tr>

<tr>
<th> priya </th>
<th> 450 </th>
<th> 3 </th>
</tr>

<tr>
<th> boopathi </th>
<th> 550 </th>
<th> 2 </th>
</tr>

</table></body>
</html>

style.css

table{width:"60%";height:"40%"; border:3px solid red;}
th{border:2px solid green;}
th{border:1px solid orange;}

29.

<html>
<head>
<link rel="stylesheet" href="styles/style1.css">
</head>
<body> <table>

<tr>
<th> Name </th>
<th> Marks </th>
<th> Rank </th>
</tr>

<tr>
<th> priya </th>
<th> 450 </th>
<th> 3 </th>
</tr>

<tr>
<th> boopathi </th>
<th> 550 </th>
<th> 2 </th>
</tr>

</table></body>
</html>

style.css

table{width:"60%";height:"40%"; border:3px solid red;}
th{border:2px solid green;}
th{border:1px solid orange;}

table{width:60%;height:40%;border:3px solid red;
border-collapse:collapse;}

30. Divisions:
index.html

This is the book


style.css

div{width:"60%";height:"40%"; border:3px solid red;margin:25px;}



style.css

div{width:"60%";height:"40%"; border:3px solid : red;margin:25px;padding:25px;}


31.Body Background:

index.html

1oth time success

style1.css

body{background-color:skyblue;}
body{background-image: url("../linux.jpeg");}

body{
background-image:url("../linux.jpeg");
background-repeat: repeat-x;
}



style1.css

body{background-color:skyblue;}
body{background-image: url("../linux.jpeg");}

body{
background-image:url("../linux.jpeg");
background-repeat: repeat-y;
}


style1.css

body{background-color:skyblue;}
body{background-image: url("../linux.jpeg");}

body{
background-image:url("../linux.jpeg");
background-repeat: no-repeat;
}


style1.css

body{background-color:skyblue;}
body{background-image: url("../linux.jpeg");}

body{
background-image:url("../linux.jpeg");
background-repeat: no-repeat;
background-position:right-top;
}

32. POSITIONING:static

index.html:

<!DOCTYPE html>

position: static;

1oth time failure


style1.css:

div.static {
position: static;
border: 3px solid #73AD21;
}


33.positioning:fixed
index.html:

<!DOCTYPE html>

position: static;

1oth time failure


style1.css:

div.fixed {
position: fixed;
bottom:0;
right :0;
width: 300px;
border: 3px solid #73AD21;
}


34.positioning:absolute

index.html:

<!DOCTYPE html>

position: static;

1oth time failure


style1.css:

div.absolute{
position: absolute;
top:80px;
right :0;
width: 300px;
height: 200px;
border: 3px solid #73AD21;
}


35.positioning:sticky

36.Box model - where the content should be placed inside the box
rules for box model:
- Content Edge
- Border Edge
- Padding Edge
- Margin

p{
width:200px;
border: 3px solid red;
padding: 40px 50px 60px 70px;
margin: 100px 5px 300px 400px;
}


37.VIBGYOR with html ,css

38.

<!DOCTYPE html>

Here is a span element which is red, as it is span element Here is a span element which is blue, because it inherits from its parent. Here is a span element which is red, because it is span element.


style1.css

span{
color: red;
border: 1px solid black;
}

.extra span{
color: inherit;
}


39.initial
index.html

<!DOCTYPE html>

heading

heading means what


style1.css:

div{
color: red;
border: 1px solid black;
}

h1{
color: initial;
}


40.revert property
div --> parent tag
p--> child tag

index.html:

<!DOCTYPE html>

sun shines

class ="changes"> purple flower


style1.css:

parents{
color: blue;
}
p{
color: red;
}
changes{
color: revert;
}


41.
index.html

<!DOCTYPE html>

1 2 3 4

style1.css

div.one{margin:5px;padding:5px;border:1px;solid red;float:left;text-align:center;}

div.one img{display:inline; margin:5px; border:1px solid yellow; width:170px; height:150px;}

div.one a:hover img{border:1px solid blue;}
div.two {text-align:center; font-weight:normal; width:120px; margin:5px;}


42.Opacity
index.html

<!DOCTYPE html>

1 2 3 4


style1.css

div.one{margin:5px;padding:5px;border:1px;solid red;float:left;text-align:center;}

div.one img{display:inline; margin:5px; border:1px solid yellow; width:170px; height:150px;opacity: 0.4; filter: alpha(opacity=40);}

div.one a:hover img{border:1px solid blue;opacity:1;filter: alpha(opacity=100);}
div.two {text-align:center; font-weight:normal; width:120px; margin:5px;}


43.CSS Layout:
Flex Box: flexbox is designed for one-dimensional layout
index.html((one dimension layout))

<!DOCTYPE html>

one two three

style.css

.wrapper{
display:flex;
}
.wrapper > div {
flex:1;
}


eg...

index.html

<!DOCTYPE html>

home about contact us

style.css

.wrapper{
display:flex;
}
.wrapper > div {
flex:1;
}


43.Grid layout - for two dimensional layout

index.html

<!DOCTYPE html>

one two three four five six


style.css

.wrapper{
display:grid;
grid-template-columns: 1fr 1fr 1fr;
grid-template-rows: 100px 100px;
gap: 10px;
}

44.

Java

PRIYA K — Sat, 09 May 2026 03:05:09 +0000

Java is statically Typed

1.In Java ,Need to specify the "return" ,"not Return"
"void" means not return anything

public class Shop
{
    Static String ShopName = "Priya"
    String name;
    int price;
public static void main(String[]args)
{
    Shop product1 = new Shop()
    product1.name = "abc";
    product1.price = 10;
    product1.buy();
}
}

Output
Cannot find symbol

Explanation:
If method is not declared means [Cannot Find Symbol]

[Invalid Method Declaration]
If method is not Correctly 'defined' and 'Return Type' is not given

Inside a method ,we can call another method .
Inside a method ,we cannot define it

Using Void

public class Shop
{
    Static String ShopName = "Priya"
    String name;
    int price;
public static void main(String[]args)
{
    Shop product1 = new Shop()
    product1.name = "abc";
    product1.price = 10;
    product1.buy();
}
public void buy(){
    System.out.println("Buy Method")
}

output
Buy Method

public class Shop
{
    static String ShopName = "Priya";
    String name;
    int price;

    void buy()
    {
        System.out.println("Product: " + name);
        System.out.println("Price: " + price);
        System.out.println("Shop: " + ShopName);
    }

    public static void main(String[] args)
    {
        Shop product1 = new Shop();
        product1.name = "abc";
        product1.price = 10;
        product1.buy();
    }
}

Output
Product: abc
Price: 10
Shop: Priya

public class Calculator
{
    public static void main(String[] args)
    {
        Calculator casio = new Calculator();
        casio.add(10, 20);//method calling
    }

//method definition
    public void add(int no1, int no2)
    {
        System.out.println(no1 + no2);
    }
}

Output
30

React

PRIYA K — Sat, 09 May 2026 03:04:29 +0000

1.Component
What is component?

means function return HTML elements
javaScript functions that return JSX
independent and reusable bits of code
Starts with Capital letters
in one file, multiple components

why components is used?

Reusability – use the same UI in many places
Modularity – split big UI into small parts
Easy to manage & update
Clean, organized code

Types of Functional Component
1.Functional component

syntax: JavaScript Function
State: useState()
LifeCycle:useEffect()
Hooks: supported
code length: less
performance:faster
React Recommendation:Preferred

example

function App(){
   return(
     <div>
       <h1> Hello React </h1>
       <p> This is my first React App </p>
     </div>
  );
}
export default App;

2.Class Component

syntax: ES6
State: this.state
LifeCycle:lifecycle methods
Hooks: not supported
code length: more
performance:slightly slower
React Recommendation:old

example

import React, { Component } from "react";

class App extends Component {
  render() {
    return (
      <div>
        <h1>Hello React</h1>
        <p>This is my first React App</p>
      </div>
    );
  }
}

export default App;

2.what is XML?

Xml means extensible markup language extensible means create your own tags
is a markup language used to store and transport data in a structured ,readable format.
Structured – Data is organized in a tree-like hierarchy.
Platform-independent – Can be used across different systems.
Text-based – Easy to read and debug.
user defined tags
must have closing tags
case sensitive
must be well formed (properly nested tags)
can include attributes

example

<student>
    <name>Priya</name>
    <age>20</age>
    <course>AI & Data Science</course>
</student>

3.what is JS vs JSX?
JavaScript?
JavaScript is a programming language used to add logic, behavior, and interactivity to web pages.

Features

Variables, functions, loops
Conditions (if, switch)
DOM manipulation
Works in browser & server

let name = "Priya";
function greet() {
  return "Hello " + name;
}

JSX (JavaScript XML)
JSX?
JSX is a syntax extension of JavaScript used in React to write HTML-like code inside JavaScript.

JSX is NOT a separate language

Example (JSX)

const element = <h1>Hello Priya</h1>;

Behind the scenes, JSX is converted to JavaScript:

React.createElement("h1", null, "Hello Priya");

JavaScript Array

PRIYA K — Sat, 09 May 2026 03:04:11 +0000

eg.
const marks = [20,30,40,50,60]
console.log(marks[-1])
output
undefined

const marks = [20,30,40,50,60]
const marks(marks.at(-1));
output
50

Array
In Java,array stores homogeneous elements.fixed size.
eg:
java = [10,20,30,40,50]

In Javascript,array stores heterogeneous elements.flexible size.
eg:
javascript = [10,"string",20,"priya"]

method
*logic ,*return type,*arguments

Array Methods
Array flat()
eg.
function mult(x){
return [x,x*10]
}
const myArr = [1,2,3,4,5,6]
const newArr = myArr.flapMap(mult);
output
[1, 10, 2, 20, 3, 30, 4, 40, 5, 50, 6, 60]

Array
Array iterations
forEach() is used , so we can avoid use looping methods.
logic :
The forEach() method calls a function (a callback function) once for each array element.
return :
void(nothing to return)
arguments:
call back

value,index,array
for each in functions
code
const marks = [89,88,99,"abcd"]
marks.forEach(display)
function display(value,index,array){
console.log(value,index,array)
}
output
89 0
Array(4) [ 89, 88, 99, "abcd" ]
88 1
Array(4) [ 89, 88, 99, "abcd" ]
99 2
Array(4) [ 89, 88, 99, "abcd" ]
abcd 3
Array(4) [ 89, 88, 99, "abcd" ]

4 times = display is called

object: keep the object and then call the method

arrow functions is used for only one function.
for each in arrow function
eg .
const marks = [89,88,99,"abcd"]
marks.forEach(value => console.log(value))
output
89
88
99
abcd

eg.
const marks = [89,88,99,"abcd"]
marks.forEach(value,index,array => console.log(value,index,array))
output
value is not defined

console.log is not a callback
callback depends on the before function

callback functions
eg
function display(cb){
console.log("display");
cb(); //cb(); output display
}
function add(){
console.log("add");
}
display(add)
output
display
add

eg
function display(cb){
console.log("display");
cb(); //cb(); output display
}
function add(){
console.log("add" + 10);
}
display(add)

output
display
add10

Array methods:
JavaScript Array length:
The length property returns the length (size) of an array:
Example
JavaScript Array length

 const fruits = ["banana","cherry","pineapple","mango"]
        fruits.length = 3
        console.log(fruits)
output:
Array(5) [ "banana", "cherry", "pineapple", "mango", "kiwi" ]

       const fruits = ["banana","apple","orange"];
        let size = fruits.length;
        console.log(size)
output 3

        const fruits = ["banana","apple","orange"];    
        console.log(fruits.length)
output 3
The length property can also be used to set the length of an array:
        const fruits = ["banana","cherry","pineapple","mango"]
        fruits.length = 3
        console.log(fruits)
output [ "banana", "cherry", "pineapple" ]

JavaScript Array toString():
The toString() method returns the elements of an array as a comma separated string.
Example

        const cars = ["bmw","honda","toyota","tesla"]
        let denote = cars.toString()
        console.log(denote)

output
bmw,honda,toyota,tesla

Note
Every JavaScript object has a toString() method.
The toString() method is used internally by JavaScript when an object needs to be displayed as a text (like in HTML), or when an object needs to be used as a string.

JavaScript Array join():
The join() method also joins all array elements into a string.
It behaves just like toString(), but in addition you can specify the separator:
Example

        const cars = ["bmw","honda","toyota","tesla"]
        console.log(cars.join("#"));

output:
bmw#honda#toyota#tesla

join() and toString() similarities
joins all array elements into a string.

join() vs toString()
join() : specify the separator

JavaScript Array at():
Examples

        const cars = ["bmw","honda","toyota","tesla"]
        let denote = cars.at(-3)
        console.log(denote)

output honda

The at() method returns an indexed element from an array.
The at() method returns the same as [].
Note
Many languages allow negative bracket indexing like [-1] to access elements from the end of an object / array / string.
This is not possible in JavaScript, because [] is used for accessing both arrays and objects. obj[-1] refers to the value of key -1, not to the last property of the object.

Popping and Pushing
Popping
Popping :The pop() method removes the last element from an array
Popping items out of an array
The pop() method returns the value that was "popped out"
eg..

        const cars = ["bmw","honda","toyota","tesla"]
        console.log(cars.pop())
        console.log(cars)

output
tesla
Array(4)["bmw","honda","toyota"]

Pushing
Pushing :The push() method adds a new element to an array (at the end)
Pushing items into an array.
eg..

        const cars = ["bmw","honda","toyota","tesla"]
        console.log(cars.push("aadi"))
        console.log(cars)

output
5
Array(5) [ "bmw", "honda", "toyota", "tesla", "aadi" ]
eg..

        const fruits = ["Banana", "Orange", "Apple", "Mango"];
        let length = fruits.push("Kiwi");
        console.log(length)

output
5

JavaScript Array shift():
Shifting is equivalent to popping, but working on the first element instead of the last.
The shift() method removes the first array element and "shifts" all other elements to a lower index.
eg..

        const fruits = ["Banana", "Orange", "Apple", "Mango"];
        console.log(fruits.shift()) #The shift() method returns the value that was "shifted out"
        console.log(fruits)

output
Banana
Array(3) [ "Orange", "Apple", "Mango" ]

JavaScript Array unshift():
The unshift() method adds a new element to an array (at the beginning), and "unshifts" older elements:
Example

        const fruits = ["Banana", "Orange", "Apple", "Mango"];
        console.log(fruits.unshift("dragon fruit")) #The unshift() method returns the new array length
        console.log(fruits)

output
5
Array(5) [ "dragon fruit", "Banana", "Orange", "Apple", "Mango" ]

pop and shift
remove elements

pop vs shift
pop :remove elements in last position
shift:remove elements in first position

push and unshift
add elements

push vs unshift
push: add elements in last position
unshift:add elements in first position

Changing Elements
Array elements are accessed using their index number:
Array indexes start with 0:
[0] is the first array element
[1] is the second
[2] is the third ...
Example
const fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits[0] = "Kiwi";
console.log(fruits)

Array.isArray()

        const fruits = ["Banana", "Orange", "Apple", "Mango"];
        console.log(Array.isArray(fruits))

output:
true

JavaScript Array delete():
Using delete() leaves undefined holes in the array.
Use pop() or shift() instead.
Example

const fruits = ["Banana", "Orange", "Apple", "Mango"];
delete fruits[0];
console.log(fruits)

Merging Arrays (Concatenating):
In programming languages, concatenation means joining strings end-to-end.
Concatenating arrays means joining arrays end-to-end.
The concat() method does not change the existing arrays. It always returns a new array.
The concat() method can take any number of array arguments.

JavaScript Array concat():
The concat() method creates a new array by merging (concatenating) existing arrays:
Example (Merging Two Arrays)

const myGirls = ["Cecilie", "Lone"];
const myBoys = ["Emil", "Tobias", "Linus"];
const myChildren = myGirls.concat(myBoys);
console.log(myChildren)

Example (Merging Three Arrays):

const arr1 = ["Cecilie", "Lone"];
const arr2 = ["Emil", "Tobias", "Linus"];
const arr3 = ["Robin", "Morgan"];
const myChildren = arr1.concat(arr2, arr3);
console.log(myChildren)

The concat() method can also take strings as arguments:
Example (Merging an Array with Values)

const arr1 = ["Emil", "Tobias", "Linus"];
const myChildren = arr1.concat("Peter"); 
console.log(myChildren)

Array copyWithin():
The copyWithin() method copies array elements to another position in an array.
The copyWithin() method overwrites the existing values.
The copyWithin() method does not add items to the array.
The copyWithin() method does not change the length of the array.
Examples
Copy to index 2, all elements from index 0:

          const fruits = ["Banana", "Orange", "Apple", "Mango"];
          console.log(fruits.copyWithin(2,0))
output:
["Banana", "Orange","Banana", "Orange"]

Copy to index 2, the elements from index 0 to 2:
const fruits = ["Banana", "Orange", "Apple", "Mango", "Kiwi"];
console.log(fruits.copyWithin(2, 0, 2));
output:
[ "Banana", "Orange", "Banana", "Orange", "Kiwi", "Papaya" ]

Flattening an Array:
Flattening an array is the process of reducing the dimensionality of an array.
Flattening is useful when you want to convert a multi-dimensional array into a one-dimensional array.
JavaScript Array flat():
The flat() method creates a new array with sub-array elements concatenated to a specified depth.
Example

const number = [[1,2],[3,4],[5,6]]
console.log(number.flat())

output:
[1,2,3,4,5,6]

JavaScript Array flatMap():
The flatMap() method first maps all elements of an array and then creates a new array by flattening the array.
Example

        const number = [1,2,3,4]
        console.log(number.flatMap(x => [x,x*2]))

output:
[ 1, 2, 2, 4, 3, 6, 4, 8 ]

JavaScript Array Search: