ArrayList Working

Lecture 68:-  ArrayList Working

ArrayList is a dynamic array-like data structure in Java that provides flexibility in managing collections of elements. It automatically resizes itself as elements are added or removed, making it more convenient to use compared to traditional arrays. Let's explore how ArrayList works and some of its key features:

1. Dynamic Resizing: Unlike fixed-size arrays, ArrayList can grow or shrink as elements are added or removed. When you create an ArrayList, it has an initial capacity (usually 10 elements). If you add more elements than the current capacity allows, the ArrayList automatically increases its capacity by creating a new array with a larger size and copying the elements to the new array.

2. Adding Elements: You can add elements to an ArrayList using the add() method. The add() method appends the element to the end of the list. You can also insert an element at a specific index using the add(index, element) method.

3. Accessing Elements: You can access elements in an ArrayList using the get() method, providing the index of the element you want to retrieve. Indexing starts from 0, so the first element is at index 0, the second at index 1, and so on.

4. Removing Elements: You can remove elements from an ArrayList using the remove() method, either by specifying the index of the element to remove or by providing the element itself. When an element is removed, the ArrayList automatically adjusts its size and shifts the subsequent elements to fill the gap.

5. Iterating Over ArrayList: You can use the enhanced for loop (for-each loop) or the traditional for loop to iterate over the elements in an ArrayList. The enhanced for loop is more concise and convenient.

6. Size and Checking Empty: The size() method returns the number of elements currently stored in the ArrayList. You can use this method to get the size of the list. To check if the ArrayList is empty, you can use the isEmpty() method.

7. Other Useful Methods: ArrayList provides many other methods for common list operations, such as contains(), indexOf(), clear(), set(), and more.

Here's a brief example to illustrate how ArrayList works:

javaCopy code
import java.util.ArrayList;

public class ArrayListExample {
    public static void main(String[] args) {
        ArrayList<String> colors = new ArrayList<>();

        // Adding elements
        colors.add("Red");
        colors.add("Green");
        colors.add("Blue");

        // Accessing elements
        String firstColor = colors.get(0); // "Red"

        // Removing elements
        colors.remove(1); // Remove "Green"

        // Iterating over ArrayList
        for (String color : colors) {
            System.out.println(color);
        }

        // Size and checking empty
        int size = colors.size(); // 2
        boolean isEmpty = colors.isEmpty(); // false

        // Other methods
        boolean containsBlue = colors.contains("Blue"); // true
        int index = colors.indexOf("Blue"); // 1
        colors.set(0, "Yellow"); // Replaces "Red" with "Yellow"
        colors.clear(); // Remove all elements from the ArrayList
    }
}

In this example, we create an ArrayList called colors, add some elements, access and remove elements, iterate over the list, get its size, and use some of the other methods provided by ArrayList.

Overall, ArrayList is a powerful and widely used data structure in Java that simplifies working with collections of elements, providing automatic resizing and a rich set of methods for list manipulation.

Disclaimer:-

Under Section 107 of the copyright act 1976, allowance is made for fair use for purposes such as criticism, comment, news reporting, scholarship, and research. Fair use is a use permitted by copyright statute that might otherwise be infringing. Non-profit, educational, or personal use tips the balance in favor of fair use.