DEV Community: Deepikandas

Locators in Selenium WebDriver

Deepikandas — Sun, 17 May 2026 12:37:04 +0000

Selenium:What is WebElement?

Deepikandas — Sun, 17 May 2026 12:34:44 +0000

Selenium Webdriver Browser Commands

Deepikandas — Sun, 17 May 2026 12:33:39 +0000

Selenium WebDriver Achitecture

Deepikandas — Sun, 17 May 2026 12:31:25 +0000

What is Selenium?

Deepikandas — Sun, 17 May 2026 12:30:14 +0000

#39 LinkedList implements Queue

Deepikandas — Mon, 11 May 2026 13:49:59 +0000

Hierarchy
Collection Interface
↓
Queue Interface
↓
Deque Interface
↓
LinkedList class
Declaration as Queue

Queue q = new LinkedList();

Queue does NOT support indexing
So these are invalid concepts for Queue:
❌get(0)
❌add(2, value)
❌remove(1)
Queues work only:
front insertion/removal
FIFO operations
You process elements sequentially.
You don't jump to middle positions.
Queue Operations
Method ** Purpose**
add() Insert element
offer() Insert safely
poll() Remove first element
remove() Remove first element
peek() View first element
element() View first element

#38 Known is a Drop! LinkedList implementing List interface

Deepikandas — Sun, 10 May 2026 22:42:10 +0000

What is LinkedList in Java?
👉 LinkedList is a linear data structure implementation in Java that stores elements as nodes connected using pointers (links).

Instead of an array, it uses:
Node structure
Each node has:

data
reference to next node
reference to previous node 🔹 Key features ✔ 1. Dynamic size Grows and shrinks automatically No fixed capacity like arrays ✔ 2. Fast insert/delete No shifting required Just change links Example:

Insert B between A and C → just update pointers
✔ 3. Slow random access
list.get(5);

👉 Must traverse node-by-node → O(n) time
🔹 Constructors in LinkedList

✔ Default:

LinkedList<String> list = new LinkedList<>();

✔ From collection:

LinkedList<String> list = new LinkedList<>(otherList);

Important interfaces it implements

LinkedList implements:

List
Deque
Queue

So it can act like:

List
Stack
Queue

🔹 1. List methods (from List interface)

These work because LinkedList also behaves like a List:

add(E e)
add(int index, E e)
get(int index)
set(int index, E e)
remove(int index)
size()
contains(Object o)
indexOf(Object o)

package LinkedListPack;
import java.util.LinkedList;
import java.util.List;
public class TrainCoach {
    public void insertCoach(List list, String s) {
        System.out.println("Adding General coach after AC coaches");
        list.add(4, s);
        System.out.println(list);
    }

    public void removeCoach(List list, String s) {
        System.out.println("Removing S6 coach ");
        if (list.contains(s)) {
            list.remove(s);
            System.out.println("list" + list);
        } else {
            System.out.println("No such coach to remove from Train");
        }
    }

    public static void main(String[] args) {
        TrainCoach tc = new TrainCoach();
        List coaches = new LinkedList();
        coaches.add("Engine ");
        coaches.add("Ac Coach A1 ");
        coaches.add("AC Coach A2 ");
        coaches.add("AC coach A3 ");
        coaches.add("S1 ");
        coaches.add("S2 ");
        coaches.add("S3 ");
        coaches.add("S4 ");
        coaches.add("S5 ");
        coaches.add("S6 ");
        coaches.add("Caboose ");
        System.out.println("Coaches in train before change  " + coaches);
        tc.insertCoach(coaches, "General Coach");
        tc.removeCoach(coaches, "S6 ");
        System.out.println("Final Coaches in train   " + coaches);
    }
}

#37 Known is a Drop! List Interface

Deepikandas — Sun, 10 May 2026 01:55:11 +0000

List Interface in Java
👉 List is an interface in Java Collections Framework that represents an ordered collection of elements (sequence) where duplicates are allowed.

Key Characteristics of List
✔ Ordered collection (insertion order preserved)
✔ Allows duplicates
✔ Index-based access (like array)
✔ Part of java.util package
✔ Extends Collection interface
Static Methods in List Interface:
List interface has static methods, introduced in Java 8 (and expanded in Java 9).
Static methods in List
✔ 1. List.of() (Java 9+)

List<String> list = List.of("A", "B", "C");

👉 Creates an immutable list

No add/remove allowed
No null values allowed
Very fast and memory efficient
These static methods are utility/factory methods that belong to the interface itself, not to objects
✔ 2. List.copyOf() (Java 10+)

List<String> copy = List.copyOf(existingList);

👉 Creates an immutable copy of an existing list

Behavior:
If source is already immutable → returns same reference
Otherwise → creates new immutable list
Types of List Implementations
1. ArrayList
Fast random access
Slower insert/delete in middle
2. LinkedList
Fast insert/delete
Slower access
3. Vector
Synchronized (thread-safe)
Legacy class
4. Stack
Follows LIFO (Last In First Out)

#36 Known is a drop! Collection Framework in JAVA

Deepikandas — Sat, 09 May 2026 23:43:31 +0000

Collections Framework
│
├── Collection (interface)
│ ├── List
│ │ └── ArrayList, LinkedList, Vector (Stack via Vector)
│ │
│ ├── Set
│ │ └── HashSet, LinkedHashSet, TreeSet
│ │
│ └── Queue
│ └── Deque
│ └── LinkedList, ArrayDeque
│
├── Map (separate hierarchy)
│ ├── HashMap
│ ├── LinkedHashMap
│ └── TreeMap
│
└── Collections (utility class)

Collections Framework
├── Data Structures (ArrayList, HashMap, etc.)
├── Interfaces (List, Set, Queue, Map)
└── Utilities (Collections class)

Definition: Java Collections Framework
The Java Collections Framework is a unified architecture that provides a set of interfaces and classes to store, manage, and manipulate groups of objects efficiently.
Simple definition:
Collections in Java is a framework that provides classes and interfaces to store and manipulate groups of objects efficiently.

Collection (Interface)
Collection is a root interface in Java Collections Framework.
Key points:
It is an interface
Parent of List, Set, Queue
Defines basic operations like:
add()
remove()
size()
2. Collections (Utility Class)
👉 Collections is a utility class in java.util package.
It provides static methods to operate on collections.
Collections.sort(list);
Collections.reverse(list);
Collections.shuffle(list);
A utility class is a class that provides only reusable helper methods (usually static methods) and is not meant to be instantiated.
Key points:
It is a class
Contains only static methods
Used for:
sorting
searching
reversing
synchronizing
Why do we need the Collections Framework in Java?
The Java Collections Framework is a complete system that provides data structures + rules + utility operations to manage data efficiently.

No need to write data structures from scratch
High performance implementations
Standard structure (uniform API)
Reusability
Built-in algorithms
Easy maintenance
Limitations of arrays are one of the key reasons the Collections Framework was introduced in Java.

#35 Known is a drop! break; return; continue; yield; throw;

Deepikandas — Sat, 09 May 2026 22:06:02 +0000

1. break
Used to immediately stop a loop or switch.

for(int i=1; i<=5; i++) {
    if(i == 3) {
        break;
    }
    System.out.println(i);
}
Output:
1
2

When i == 3, loop stops completely.

2. continue
Skips current iteration and moves to next iteration.


for(int i=1; i<=5; i++) {
    if(i == 3) {
        continue;
    }
    System.out.println(i);
}

Output:

1
2
4
5

3 is skipped, but loop continues.

3. return
Ends the method execution.

public int add(int a, int b) {
    return a + b;
}

After return, nothing else in the method executes.
return;
Used in void methods.
A return statement in Java can return:
1. Primitive values
return 10;
return 3.14;
return true;
return 'A';

2. Objects
return "Hello";
return new Student();
Can return:
String
Arrays
Collections
Custom objects
Any class object
3. Arrays
return new int[]{1,2,3};
4. null
For reference types only.
return null;
Not allowed for primitive return types.
5. Nothing (void methods)
public void show() {
return;
}
or simply:
public void show() {
}

4.throw statement
A throw statement also exits the method immediately, similar to return.
That’s why they may feel similar.

Example:
public int test() {
    throw new RuntimeException();
    // no code after this executes
}

But:
return → sends result back
throw → sends exception object

5.yield

Used in switch expressions
Used in switch expressions
Only inside switch expression block
Produces switch expression result

int day = 2;

String result = switch(day) {
    case 1 -> "Monday";

    case 2 -> {
        yield "Tuesday";
    }

    default -> "Invalid";
};

#34 Known is a Drop! ArrayList

Deepikandas — Sat, 02 May 2026 12:21:52 +0000

ArrayList in Java
👉 ArrayList is a class in Java Collections Framework that implements the List interface and provides a dynamic array (resizable array).

capacity of ArrayList
When an ArrayList is created, its default capacity is 10 unless specified otherwise. The ArrayList automatically resizes itself when the number of elements exceeds its current capacity.

If the current capacity is reached, the ArrayList expands its size by approximately 50% of the old capacity, allowing for the addition of new elements without the need for creating a new array.
The resizing process ensures that there is always sufficient space to accommodate new elements, and this is managed internally.

Constructors in ArrayList:

Default Constructor ArrayList list = new ArrayList<>(); 👉 What it does: Creates an empty ArrayList Uses a default initial capacity (typically 10 internally, but lazy allocation may apply in newer JDKs) No elements stored yet 💡 Use when:

You don’t know how many elements you’ll add.

🔹 2. Constructor with Initial Capacity
ArrayList list = new ArrayList<>(20);
👉 What it does:
Allocates internal array with capacity = 20
No resizing until it exceeds 20 elements
💡 Why useful:
Improves performance when size is known in advance
Avoids repeated resizing and copying
🔹 3. Constructor with Collection
List temp = List.of("A", "B", "C");
ArrayList list = new ArrayList<>(temp);
👉 What it does:
Creates a new ArrayList
Shallow copy behavior happens here .
✔ Only references are copied
✔ Objects inside are NOT duplicated
💡 Important:
Original collection and new ArrayList are independent
Changes in one do NOT affect the other
Array vs ArrayList:

1.How to create a arraylist object in java ?
Answer:ArrayList list= new ArrayList();

2.Which package should import for using arraylist class?
Answer:import java.util.ArrayList;

3.Which inferface implemented in arraylist class ?
Answer :List Interface

4.Can you stored a value as a primitive data in arraylist ?
Answer :No.Stores Objects Only-
ArrayList nums = new ArrayList<>();

**5.What are the methods you know in arraylist ?
Answer: **add(),addAll(),removeAll(),remove(),clear(),contains(),get(),getFirst(),toArray()

6.Can you stored a value as a object in arraylist ?
Answer :yes
7.Can you please add 5 student name in arraylist and write code ?

//Answer :using add() method
public static void main(String[] args) {
        ArrayListDemo ad = new ArrayListDemo();
        String stu[] = { "Suresh", "John", "Thomas", "Mike", "Ara" };
        ArrayList student = new ArrayList();
        for (Object student1 : stu) {
            student.add(student1);
        }

8.How to remove the student in arraylist ? write code ?
Answer :remove(index value) - remove element from particular index
removeAll(collection) - removes all matching elements from another collection
remove(object) - removes first matching element
clear() - removes everything

package arraylist;
import java.util.ArrayList;
public class ArrayListDemo {
        public static void main(String[] args) {
        ArrayListDemo ad = new ArrayListDemo();
        String stu[] = { "Suresh", "John", "Thomas", "Mike", "Ara","Andi" };
        ArrayList student = new ArrayList();
        ArrayList student2 = new ArrayList();
        for (String student1 : stu) {
            student.add(student1);
        }
        System.out.println("Student array list "+student);
        ArrayList student3=student;
        System.out.println("\"Student3 array list "+student3);
        student2.addAll(student);
        System.out.println("Student 2array list  "+student2);
        student.remove(1); //remove(index)removes one element by position
        System.out.println(student);
        student2.removeAll(student);//removes all matching elements from another collection
        student.remove(student3);
        student2.clear();//Remove everything
        System.out.println(student);
        student3.remove("Ara");//removes first matching element
        System.out.println(student3);
    }
}

9.ArrayList can have duplicate value ?
Answer :Yes.It allows.

10.Is ArrayList maintain the insertion order ?
Answer :The order is exactly the same as insertion.

11.How to print the value from arraylist using for loop ?
Answer :If traditional for loop is used,get(index)is used.
for non generic in enhanced for loop- Raw type iteration-Object type is used
for Generic version of for-each loop - Instead of Object,use the type declared for array list

package arraylist;
import java.util.ArrayList;
public class ArrayListDemo {
    public static void main(String[] args) {
        ArrayList student = new ArrayList();
        student.add("Life");
        student.add("Time");
        student.add("Gratitude");
        student.add("Acceptance");
        System.out.println("_________Using Enhanced For");
        // for non generic ArrayList
        for (Object name : student) {
            System.out.println(name);
        }
        System.out.println("_______Using traditional for loop");
        for (int i = 0; i < student.size(); i++) {
            System.out.println(student.get(i));
        }
    }
}

12 How to sort a arraylist in java ?
Answer :
using Collections.sort() for ascending order
package arraylist;

import java.util.ArrayList;
import java.util.Collections;
public class ArrayListDemo {
    public static void main(String[] args) {
        ArrayList student = new ArrayList();
        student.add(90);
        student.add(89);
        student.add(54);
        student.add(9);
        Collections.sort(student);
        System.out.println(student);
    }
}

Scenario based example:
Playlist songs (normal usage)
Songs mostly accessed sequentially, not modified often.

package arraylist;
import java.util.*;

public class PlayList {

    public static void main(String[] args) {

      List music=new ArrayList();
      music.add("Avalum nanum...");
      music.add("Kpop Deamon hunter-My little soda pop.");
      music.add("I am born for this.");
      music.add("Chinnachiru vayathil...");
      music.add("vetri kodi kattu");
      play(music);
    }
    private static void play(List<String> music1) {
        for(String song : music1) {
            System.out.println("Playing......"+song);
                }
}
}

#33 Known is a drop Mark calculating system - Mini Project

Deepikandas — Sun, 26 Apr 2026 21:01:24 +0000

Mark calculating system

package twelfth;

import java.util.InputMismatchException;
import java.util.Scanner;

public class TwelfthMark {
    static String School = "Good Hope Higher secondary school";
    String name;
    int marks[] = new int[6];

    public void getName(Scanner sc) {
        while (true) {
            System.out.println("Enter the student name");
            name = sc.nextLine();
            if (!name.isBlank()) {
                break;

            }
            System.out.println("\"Name cannot be empty\"");
        }
    }

    public void printScore(double sum) {
        System.out.println("Total mark scored " + sum);
        System.out.printf("Average :%.2f\n", (sum / 6));
        double percentage = (sum / 600) * 100.0;
        System.out.printf("Percentage: %.2f%%", percentage);

    }

    public static void main(String[] args) {
        String group1[] = { "Biology", "English", "Tamil", "Maths", "Physics", "Chemistry" };
        String group2[] = { "Computer Science", "English", "Tamil", "Maths", "Physics", "Chemistry" };
        String group3[] = { "Accountancy", "English", "Tamil", "Business Studies", "Computer Science/Math",
                "Economics" };
        TwelfthMark twelfth = new TwelfthMark();
        Scanner sc = new Scanner(System.in);

        twelfth.getName(sc);

        System.out.println("Enter the group name-a.1st Group b.2nd Group c.3rd Group");

        String group = sc.nextLine();
        double sum = 0;

        switch (group.toLowerCase()) {
        case "1st Group", "a", "1" -> {
            try {
                for (int i = 0; i <= 5; i++) {
                    System.out.println("Enter the mark of  " + group1[i]);

                    twelfth.marks[i] = sc.nextInt();

                    sum = sum + twelfth.marks[i];
                }
                twelfth.printScore(sum);
            } catch (InputMismatchException e) {
                System.out.println("\"Enter only numbers\"");

            }
        }
        case "2nd Group", "b", "2" -> {
            try {
                for (int i = 0; i <= 5; i++) {
                    System.out.println("Enter the mark of  " + group2[i]);

                    twelfth.marks[i] = sc.nextInt();

                    sum = sum + twelfth.marks[i];

                }
                twelfth.printScore(sum);
            } catch (InputMismatchException e) {
                System.out.println("Enter only numbers");
            }

        }

        case "3rd Group", "c", "3" -> {
            try {
                for (int i = 0; i <= 5; i++) {
                    System.out.println("Enter the mark of  " + group3[i]);

                    twelfth.marks[i] = sc.nextInt();

                    sum = sum + twelfth.marks[i];
                }
                twelfth.printScore(sum);
            } catch (InputMismatchException e) {
                System.out.println("Enter only numbers");
            }
        }
        default -> System.out.println("Enter valid group ");
        }

        sc.close();
    }
}