Java ArrayList

The most popular resizable array implementation in Java

šŸš€ What is ArrayList?

ArrayList is a resizable array implementation that automatically grows and shrinks as needed, providing fast random access to elements by index. 


// Creating and using ArrayList
import java.util.ArrayList;

ArrayList<String> names = new ArrayList<>();
names.add("John");
names.add("Jane");
System.out.println(names.get(0)); // Fast access by index
System.out.println("Size: " + names.size());

Output:

John
Size: 2

ArrayList Advantages

āš”

Fast Access

O(1) time for get/set operations 

list.get(100); // Instant access
šŸ“ˆ

Dynamic Size

Automatically resizes as needed 

// Starts small, grows automatically
list.add("item1000");
šŸ’¾

Memory Efficient

Stores elements in contiguous memory 

// Better cache performance
list.trimToSize();
šŸ”§

Easy to Use

Simple API with many utility methods 

list.isEmpty();
list.contains("item");

šŸ”¹ Creating ArrayList

Different ways to create and initialize ArrayList: 

import java.util.*;

public class ArrayListCreation {
    public static void main(String[] args) {
        // 1. Empty ArrayList
        ArrayList<String> list1 = new ArrayList<>();
        
        // 2. ArrayList with initial capacity
        ArrayList<String> list2 = new ArrayList<>(50);
        
        // 3. ArrayList from another collection
        ArrayList<String> list3 = new ArrayList<>(Arrays.asList("A", "B", "C"));
        
        // 4. Using List interface (recommended)
        List<String> list4 = new ArrayList<>();
        
        // 5. Initialize with values (Java 9+)
        List<String> list5 = new ArrayList<>(List.of("X", "Y", "Z"));
        
        System.out.println("List3: " + list3);
        System.out.println("List5: " + list5);
    }
}

Output:

List3: [A, B, C]
List5: [X, Y, Z]

šŸ”¹ ArrayList Methods

Essential ArrayList methods with examples: 

import java.util.*;

public class ArrayListMethods {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        
        // Adding elements
        numbers.add(10);                    // Add at end
        numbers.add(20);
        numbers.add(1, 15);                 // Add at index 1
        numbers.addAll(Arrays.asList(30, 40)); // Add multiple
        
        System.out.println("After adding: " + numbers);
        
        // Accessing elements
        System.out.println("First element: " + numbers.get(0));
        System.out.println("Last element: " + numbers.get(numbers.size() - 1));
        
        // Modifying elements
        numbers.set(0, 5);                  // Replace element at index 0
        System.out.println("After set: " + numbers);
        
        // Searching
        System.out.println("Contains 20: " + numbers.contains(20));
        System.out.println("Index of 30: " + numbers.indexOf(30));
        
        // Removing elements
        numbers.remove(1);                  // Remove by index
        numbers.remove(Integer.valueOf(40)); // Remove by value
        System.out.println("After removal: " + numbers);
        
        // Size and capacity
        System.out.println("Size: " + numbers.size());
        System.out.println("Is empty: " + numbers.isEmpty());
    }
}

Output:

After adding: [10, 15, 20, 30, 40]
First element: 10
Last element: 40
After set: [5, 15, 20, 30, 40]
Contains 20: true
Index of 30: 3
After removal: [5, 20, 30]
Size: 3
Is empty: false

šŸ”¹ ArrayList vs Array

Understanding the differences:

Array vs ArrayList Comparison:

Feature Array ArrayList
Size Fixed Dynamic
Type Primitives + Objects Objects only
Methods Length property Many utility methods 
// Array example
int[] array = new int[5];           // Fixed size
array[0] = 10;
System.out.println("Array length: " + array.length);

// ArrayList example  
ArrayList<Integer> list = new ArrayList<>(); // Dynamic size
list.add(10);
list.add(20);                       // Can keep adding
System.out.println("List size: " + list.size());

šŸ”¹ Performance Considerations

ArrayList Performance:

  • Access by index: O(1) - Very fast
  • Add at end: O(1) amortized - Usually fast
  • Add at beginning/middle: O(n) - Slower, shifts elements
  • Remove from end: O(1) - Fast
  • Remove from beginning/middle: O(n) - Slower, shifts elements
  • Search: O(n) - Must check each element

šŸ§  Test Your Knowledge

What is the time complexity of accessing an element by index in ArrayList?