Generic Array Lists

Introduction

ArrayList is a resizable array. Generic ArrayList uses type parameters for type safety.

ArrayList<Type> list = new ArrayList<>();

Basic Example

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        // Create ArrayList of Strings
        ArrayList<String> names = new ArrayList<>();

        // Add elements
        names.add("John");
        names.add("Alice");
        names.add("Bob");

        // Print
        System.out.println(names);  // [John, Alice, Bob]

        // Access element
        System.out.println(names.get(0));  // John

        // Size
        System.out.println("Size: " + names.size());  // 3
    }
}

Why Generic ArrayList?

Without Generics (Old Way):

ArrayList list = new ArrayList();  // Raw type
list.add("Hello");
list.add(123);  // Different type allowed

String s = (String) list.get(0);  // Need casting
String s2 = (String) list.get(1); // Runtime error!

With Generics (Type Safe):

ArrayList<String> list = new ArrayList<>();
list.add("Hello");
// list.add(123);  // Compile error - type safe!

String s = list.get(0);  // No casting needed

Common Methods

import java.util.ArrayList;

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

        // 1. add() - Add element
        list.add("Java");
        list.add("Python");
        list.add("C++");

        // 2. add(index, element) - Add at position
        list.add(1, "JavaScript");

        // 3. get(index) - Get element
        System.out.println(list.get(0));  // Java

        // 4. set(index, element) - Update element
        list.set(2, "Ruby");

        // 5. remove(index) - Remove by index
        list.remove(1);

        // 6. remove(object) - Remove by value
        list.remove("C++");

        // 7. size() - Get size
        System.out.println("Size: " + list.size());

        // 8. isEmpty() - Check if empty
        System.out.println("Empty: " + list.isEmpty());

        // 9. contains() - Check if exists
        System.out.println("Contains Java: " + list.contains("Java"));

        // 10. clear() - Remove all
        list.clear();

        System.out.println(list);  // []
    }
}

ArrayList of Integers

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();

        // Add numbers
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);
        numbers.add(40);

        // Access
        System.out.println("First: " + numbers.get(0));
        System.out.println("Last: " + numbers.get(numbers.size() - 1));

        // Calculate sum
        int sum = 0;
        for (int num : numbers) {
            sum += num;
        }
        System.out.println("Sum: " + sum);
    }
}

Iterating ArrayList

Method 1: for-each Loop

ArrayList<String> fruits = new ArrayList<>();
fruits.add("Apple");
fruits.add("Banana");
fruits.add("Orange");

for (String fruit : fruits) {
    System.out.println(fruit);
}

Method 2: Traditional for Loop

for (int i = 0; i < fruits.size(); i++) {
    System.out.println(fruits.get(i));
}

Method 3: Iterator

import java.util.Iterator;

Iterator<String> it = fruits.iterator();
while (it.hasNext()) {
    System.out.println(it.next());
}

ArrayList of Custom Objects

import java.util.ArrayList;

class Student {
    String name;
    int rollNo;

    Student(String name, int rollNo) {
        this.name = name;
        this.rollNo = rollNo;
    }

    @Override
    public String toString() {
        return name + "(" + rollNo + ")";
    }
}

public class Main {
    public static void main(String[] args) {
        ArrayList<Student> students = new ArrayList<>();

        students.add(new Student("John", 101));
        students.add(new Student("Alice", 102));
        students.add(new Student("Bob", 103));

        // Print all students
        for (Student s : students) {
            System.out.println(s);
        }

        // Access specific student
        Student first = students.get(0);
        System.out.println("First student: " + first.name);
    }
}

Complete Example: Student Management

import java.util.ArrayList;

class Student {
    private String name;
    private int rollNo;
    private double marks;

    Student(String name, int rollNo, double marks) {
        this.name = name;
        this.rollNo = rollNo;
        this.marks = marks;
    }

    String getName() { return name; }
    int getRollNo() { return rollNo; }
    double getMarks() { return marks; }

    @Override
    public String toString() {
        return String.format("%s (%d): %.2f", name, rollNo, marks);
    }
}

class StudentManager {
    private ArrayList<Student> students;

    StudentManager() {
        students = new ArrayList<>();
    }

    void addStudent(Student s) {
        students.add(s);
        System.out.println("Added: " + s.getName());
    }

    void removeStudent(int rollNo) {
        for (int i = 0; i < students.size(); i++) {
            if (students.get(i).getRollNo() == rollNo) {
                System.out.println("Removed: " + students.get(i).getName());
                students.remove(i);
                return;
            }
        }
        System.out.println("Student not found");
    }

    void displayAll() {
        System.out.println("\n=== All Students ===");
        for (Student s : students) {
            System.out.println(s);
        }
    }

    double calculateAverage() {
        if (students.isEmpty()) return 0;

        double sum = 0;
        for (Student s : students) {
            sum += s.getMarks();
        }
        return sum / students.size();
    }
}

public class Main {
    public static void main(String[] args) {
        StudentManager manager = new StudentManager();

        manager.addStudent(new Student("John", 101, 85.5));
        manager.addStudent(new Student("Alice", 102, 92.0));
        manager.addStudent(new Student("Bob", 103, 78.5));

        manager.displayAll();

        System.out.println("\nAverage marks: " + manager.calculateAverage());

        manager.removeStudent(102);
        manager.displayAll();
    }
}

ArrayList vs Array

Searching in ArrayList

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> cities = new ArrayList<>();
        cities.add("Delhi");
        cities.add("Mumbai");
        cities.add("Bangalore");
        cities.add("Chennai");

        // 1. contains() - Check existence
        System.out.println(cities.contains("Delhi"));  // true

        // 2. indexOf() - Find position
        int index = cities.indexOf("Mumbai");
        System.out.println("Mumbai at index: " + index);  // 1

        // 3. indexOf() returns -1 if not found
        int notFound = cities.indexOf("Kolkata");
        System.out.println("Kolkata at index: " + notFound);  // -1

        // 4. lastIndexOf() - Last occurrence
        cities.add("Delhi");
        System.out.println("Last Delhi at: " + cities.lastIndexOf("Delhi"));
    }
}

Sorting ArrayList

import java.util.ArrayList;
import java.util.Collections;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(30);
        numbers.add(10);
        numbers.add(50);
        numbers.add(20);

        System.out.println("Before: " + numbers);

        // Sort ascending
        Collections.sort(numbers);
        System.out.println("After: " + numbers);

        // Sort descending
        Collections.sort(numbers, Collections.reverseOrder());
        System.out.println("Reverse: " + numbers);
    }
}

ArrayList Methods Summary

import java.util.ArrayList;

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

        // Adding
        list.add("A");
        list.add("B");
        list.add(0, "Z");  // Add at index

        // Accessing
        String first = list.get(0);
        String last = list.get(list.size() - 1);

        // Updating
        list.set(1, "X");

        // Removing
        list.remove(0);           // By index
        list.remove("B");         // By value

        // Searching
        boolean exists = list.contains("A");
        int index = list.indexOf("X");

        // Info
        int size = list.size();
        boolean empty = list.isEmpty();

        // Clear all
        list.clear();
    }
}

Converting Array to ArrayList

import java.util.ArrayList;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        // Method 1: Using loop
        String[] arr = {"Java", "Python", "C++"};
        ArrayList<String> list1 = new ArrayList<>();
        for (String s : arr) {
            list1.add(s);
        }

        // Method 2: Using Arrays.asList()
        ArrayList<String> list2 = new ArrayList<>(Arrays.asList(arr));

        System.out.println(list1);
        System.out.println(list2);
    }
}

Converting ArrayList to Array

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Java");
        list.add("Python");
        list.add("C++");

        // Convert to array
        String[] arr = new String[list.size()];
        list.toArray(arr);

        // Or simpler
        String[] arr2 = list.toArray(new String[0]);

        // Print array
        for (String s : arr) {
            System.out.println(s);
        }
    }
}

ArrayList Capacity

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        // Initial capacity 10 (default)
        ArrayList<Integer> list1 = new ArrayList<>();

        // Initial capacity 100
        ArrayList<Integer> list2 = new ArrayList<>(100);

        // Ensure capacity
        list1.ensureCapacity(50);

        // Trim to size (remove unused capacity)
        list1.add(10);
        list1.add(20);
        list1.trimToSize();
    }
}

Common Operations

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();

        // Add multiple
        for (int i = 1; i <= 5; i++) {
            numbers.add(i * 10);
        }

        // Find max
        int max = numbers.get(0);
        for (int num : numbers) {
            if (num > max) max = num;
        }
        System.out.println("Max: " + max);

        // Find min
        int min = numbers.get(0);
        for (int num : numbers) {
            if (num < min) min = num;
        }
        System.out.println("Min: " + min);

        // Sum
        int sum = 0;
        for (int num : numbers) {
            sum += num;
        }
        System.out.println("Sum: " + sum);

        // Average
        double avg = (double) sum / numbers.size();
        System.out.println("Average: " + avg);
    }
}

Clone and Copy

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> original = new ArrayList<>();
        original.add("A");
        original.add("B");
        original.add("C");

        // Method 1: Clone
        @SuppressWarnings("unchecked")
        ArrayList<String> copy1 = (ArrayList<String>) original.clone();

        // Method 2: Constructor
        ArrayList<String> copy2 = new ArrayList<>(original);

        // Method 3: addAll
        ArrayList<String> copy3 = new ArrayList<>();
        copy3.addAll(original);

        // Modify copy doesn't affect original
        copy1.add("D");
        System.out.println("Original: " + original);
        System.out.println("Copy: " + copy1);
    }
}

Quick Reference

import java.util.ArrayList;

// Create
ArrayList<Type> list = new ArrayList<>();

// Add
list.add(element);
list.add(index, element);

// Get
Type item = list.get(index);

// Update
list.set(index, element);

// Remove
list.remove(index);
list.remove(element);

// Size
int size = list.size();

// Check
boolean exists = list.contains(element);
boolean empty = list.isEmpty();

// Clear
list.clear();

// Iterate
for (Type item : list) {
    // Use item
}

Exam Tips

Remember:

1. ArrayList is resizable array
2. Generic: ArrayList<Type>
3. Import: import java.util.ArrayList
4. add() to add elements
5. get(index) to access
6. size() for length
7. remove() to delete
8. Type safe with generics
9. No primitive types (use wrappers)
10. Dynamic size (grows automatically)

Common Questions:

• What is ArrayList?
• ArrayList vs Array?
• How to create generic ArrayList?
• Common ArrayList methods?
• How to iterate ArrayList?
• Can ArrayList store primitives?
• How to add/remove elements?
• What is type safety in generics?