Java ArrayList

The ArrayList is a dynamic array implementation in Java that provides flexible size, type safety, and convenient methods for data manipulation. Unlike traditional arrays with fixed sizes, ArrayLists dynamically expand and shrink as elements are added or removed, providing more flexibility for data manipulation.

Syntax

The ArrayList class is part of the java.util package and must be imported before use:

import java.util.ArrayList;

Copy to clipboard
Copy to clipboard

Creating an ArrayList

There are three ways to initialize an ArrayList:

// Empty ArrayList with default initial capacity (10)
ArrayList<DataType> list1 = new ArrayList<>();

// Empty ArrayList with specified initial capacity
ArrayList<DataType> list2 = new ArrayList<>(initialCapacity);

// ArrayList initialized with elements from another collection
ArrayList<DataType> list3 = new ArrayList<>(collection);

Copy to clipboard
Copy to clipboard

Where:

• DataType is the type of elements the ArrayList will hold
• initialCapacity is the initial storage capacity of the ArrayList
• collection is another collection whose elements will be added to the ArrayList

Working with Primitive Types

ArrayList can only store objects, not primitive types. For primitives, use their wrapper classes:

For example, to create an ArrayList of integers:

ArrayList<Integer> numbers = new ArrayList<>();
numbers.add(10);  // Auto-boxing converts int to Integer

Copy to clipboard
Copy to clipboard

This process is called auto-boxing, where primitive values are automatically converted to their corresponding wrapper class.

Comparison with Other Collections

ArrayList has several important characteristics that distinguish it from other collection types:

Example

In this example, a new ArrayList instance arr is defined. There are print statements throughout to show elements being added to and removed from arr before it is ultimately cleared:

// Import from the java.util package
import java.util.ArrayList;

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

    System.out.println(arr);  // Currently empty

    arr.add("hello");
    arr.add("India");

    System.out.println(arr);

    arr.remove("hello");

    System.out.println(arr.size());  // Prints size of ArrayList

    arr.clear();

    System.out.println(arr); // Empty again
  }
}

Copy to clipboard
Copy to clipboard

The output would be:

[]
[hello, India]
1
[]

Copy to clipboard
Copy to clipboard

Frequently Asked Questions

1. What is the difference between ArrayList and LinkedList?

ArrayList is better for fast random access and low overhead; LinkedList is better for frequent insertions/deletions.

2. What is an ArrayList vs. array?

ArrayLists are dynamic and only hold objects. Arrays are fixed-size and can hold primitives or objects.

3. Does ArrayList allow duplicates?

Yes, it maintains insertion order and allows duplicate elements.