# ArrayList in Java

`ArrayList` is one of the most commonly used classes in the Java Collections Framework.

It provides a **resizable array** that can grow or shrink dynamically.

* * *

**1\. What is ArrayList?**

**Definition:**  
`ArrayList` is a resizable-array implementation of the `List` interface.

It:

*   Maintains insertion order
    
*   Allows duplicate elements
    
*   Allows `null` values
    
*   Provides index-based access
    
*   Grows dynamically
    

**Syntax:**

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

**Example:**

```java
ArrayList<String> names = new ArrayList<>();

names.add("Mani");
names.add("Arun");
names.add("Kumar");

System.out.println(names);
```

**Output:**

```text
[Mani, Arun, Kumar]
```

* * *

**2\. Creating an ArrayList**

**Syntax:**

```java
ArrayList<Integer> numbers = new ArrayList<>();
```

**Example:**

```java
ArrayList<Integer> numbers = new ArrayList<>();

numbers.add(10);
numbers.add(20);
numbers.add(30);
```

* * *

**3\. ArrayList with Initial Capacity**

**Definition:**  
We can specify an initial capacity when creating an `ArrayList`.

**Syntax:**

```java
ArrayList<Type> list = new ArrayList<>(capacity);
```

**Example:**

```java
ArrayList<Integer> numbers = new ArrayList<>(20);
```

This creates an ArrayList with an initial capacity of 20.

> Capacity and size are different. Capacity is the allocated storage; size is the number of elements currently stored.

* * *

**4\. Adding Elements**

**Definition:**  
`add()` adds an element to the end of the list.

**Example:**

```java
ArrayList<String> names = new ArrayList<>();

names.add("Java");
names.add("Spring");

System.out.println(names);
```

**Output:**

```text
[Java, Spring]
```

* * *

**5\. Adding Element at an Index**

**Definition:**  
`add(index, element)` inserts an element at a specific position.

**Example:**

```java
ArrayList<String> names = new ArrayList<>();

names.add("Java");
names.add("Spring");

names.add(1, "Python");

System.out.println(names);
```

**Output:**

```text
[Java, Python, Spring]
```

* * *

**6\. Accessing Elements**

**Definition:**  
`get(index)` returns the element at a specific index.

**Example:**

```java
ArrayList<String> names = new ArrayList<>();

names.add("Java");
names.add("Spring");

System.out.println(names.get(0));
```

**Output:**

```text
Java
```

* * *

**7\. Updating Elements**

**Definition:**  
`set(index, element)` replaces an existing element.

**Example:**

```java
ArrayList<String> names = new ArrayList<>();

names.add("Java");
names.add("Spring");

names.set(1, "React");

System.out.println(names);
```

**Output:**

```text
[Java, React]
```

* * *

**8\. Removing Elements**

**Definition:**  
`remove()` removes an element by index or object.

**Example:**

```java
ArrayList<String> names = new ArrayList<>();

names.add("Java");
names.add("Spring");

names.remove(0);

System.out.println(names);
```

**Output:**

```text
[Spring]
```

* * *

**9\. Removing by Object**

**Example:**

```java
names.remove("Spring");
```

This removes the first matching element.

* * *

**10\. Finding the Size**

**Definition:**  
`size()` returns the number of elements currently stored.

**Example:**

```java
ArrayList<String> names = new ArrayList<>();

names.add("Java");
names.add("Spring");

System.out.println(names.size());
```

**Output:**

```text
2
```

* * *

**11\. Checking an Element**

**Definition:**  
`contains()` checks whether an element exists.

**Example:**

```java
ArrayList<String> names = new ArrayList<>();

names.add("Java");

System.out.println(names.contains("Java"));
```

**Output:**

```text
true
```

* * *

**12\. Finding Index**

**Definition:**  
`indexOf()` returns the first index of an element.

**Example:**

```java
ArrayList<String> names =
        new ArrayList<>(Arrays.asList("Java", "Spring", "Java"));

System.out.println(names.indexOf("Java"));
```

**Output:**

```text
0
```

* * *

**13\. Last Index**

**Definition:**  
`lastIndexOf()` returns the last index of an element.

**Example:**

```java
System.out.println(names.lastIndexOf("Java"));
```

**Output:**

```text
2
```

* * *

**14\. Checking Empty ArrayList**

**Definition:**  
`isEmpty()` checks whether the list contains no elements.

**Example:**

```java
ArrayList<String> names = new ArrayList<>();

System.out.println(names.isEmpty());
```

**Output:**

```text
true
```

* * *

**15\. Clearing ArrayList**

**Definition:**  
`clear()` removes all elements.

**Example:**

```java
names.clear();

System.out.println(names);
```

**Output:**

```text
[]
```

* * *

**16\. Iterating Using for Loop**

**Example:**

```java
ArrayList<String> names =
        new ArrayList<>(Arrays.asList("Java", "Spring", "React"));

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

* * *

**17\. Iterating Using Enhanced for Loop**

**Example:**

```java
for (String name : names) {
    System.out.println(name);
}
```

* * *

**18\. Iterating Using forEach**

**Example:**

```java
names.forEach(name -> System.out.println(name));
```

* * *

**19\. Sorting ArrayList**

**Definition:**  
An ArrayList can be sorted using `Collections.sort()` or `sort()`.

**Example:**

```java
ArrayList<Integer> numbers =
        new ArrayList<>(Arrays.asList(30, 10, 20));

Collections.sort(numbers);

System.out.println(numbers);
```

**Output:**

```text
[10, 20, 30]
```

* * *

**20\. Reverse Sorting**

**Example:**

```java
numbers.sort(Comparator.reverseOrder());

System.out.println(numbers);
```

**Output:**

```text
[30, 20, 10]
```

* * *

**21\. ArrayList with Duplicates**

**Definition:**  
ArrayList allows duplicate elements.

**Example:**

```java
ArrayList<String> names = new ArrayList<>();

names.add("Java");
names.add("Java");

System.out.println(names);
```

**Output:**

```text
[Java, Java]
```

* * *

**22\. ArrayList with null**

**Definition:**  
ArrayList allows `null` elements.

**Example:**

```java
ArrayList<String> names = new ArrayList<>();

names.add("Java");
names.add(null);

System.out.println(names);
```

**Output:**

```text
[Java, null]
```

* * *

**23\. Converting ArrayList to Array**

**Definition:**  
`toArray()` converts the list into an array.

**Example:**

```java
ArrayList<String> names =
        new ArrayList<>(Arrays.asList("Java", "Spring"));

String[] array = names.toArray(new String[0]);
```

* * *

**24\. Copying an ArrayList**

**Example:**

```java
ArrayList<String> original =
        new ArrayList<>(Arrays.asList("Java", "Spring"));

ArrayList<String> copy =
        new ArrayList<>(original);
```

* * *

**25\. ArrayList vs Array**

| Feature | ArrayList | Array |
| --- | --- | --- |
| Size | Dynamic | Fixed |
| Stores objects | Yes | Yes, including primitives |
| Add/remove | Supported | Not directly |
| Index access | Yes | Yes |
| Collection methods | Yes | No |

* * *

**26\. ArrayList Time Complexity**

| Operation | Average Time |
| --- | --- |
| `get()` | O(1) |
| `set()` | O(1) |
| `add()` at end | O(1) amortized |
| `add(index, element)` | O(n) |
| `remove(index)` | O(n) |
| `contains()` | O(n) |
| `indexOf()` | O(n) |

* * *

**27\. Important ArrayList Methods**

```text
add()
add(index, element)
get()
set()
remove()
size()
contains()
indexOf()
lastIndexOf()
isEmpty()
clear()
sort()
forEach()
toArray()
```

* * *

**Complete Example**

```java
import java.util.*;

public class Main {
    public static void main(String[] args) {

        ArrayList<String> languages = new ArrayList<>();

        languages.add("Java");
        languages.add("Python");
        languages.add("Java");

        System.out.println(languages);

        System.out.println(languages.get(0));

        languages.set(1, "Spring");

        languages.remove("Java");

        System.out.println(languages);
        System.out.println(languages.size());
    }
}
```

**Output:**

```text
[Java, Python, Java]
Java
[Python, Java]
2
```

**Conclusion**

`ArrayList` is a commonly used Java collection when we need a **dynamic, ordered list with index-based access**.

The important points to remember are:

```text
ArrayList
→ Dynamic size
→ Maintains insertion order
→ Allows duplicates
→ Allows null
→ Fast index-based access
→ Slower insertion/removal in the middle
```

It is one of the most important Java Collections to understand for **Java development, Spring Boot, DSA, and interviews**.