How to initialize ArrayList in Java?

In Java, there are several ways to initialize an ArrayList. The method you choose depends on your Java version and whether you need a mutable or immutable list. Below are the most common approaches:

1. Initialize an Empty ArrayList

Use the constructor to create an empty list and add elements later:

import java.util.ArrayList;

ArrayList<String> list = new ArrayList<>(); // Empty list
list.add("Apple");
list.add("Banana");

2. Initialize with Elements Using Arrays.asList()

Use Arrays.asList() to initialize with elements (creates a fixed-size list):

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

// Create a mutable ArrayList from a fixed-size list
ArrayList<String> list = new ArrayList<>(Arrays.asList("Apple", "Banana", "Cherry"));

Note:

• Arrays.asList() returns a fixed-size list backed by an array. Wrapping it in new ArrayList<>() makes it mutable.

3. Java 9+ List.of() (Immutable List)

For an immutable list (Java 9+):

import java.util.ArrayList;
import java.util.List;

// Create a mutable ArrayList from an immutable list
ArrayList<String> list = new ArrayList<>(List.of("Apple", "Banana", "Cherry"));

Note:

• List.of() returns an immutable list. Use new ArrayList<>(List.of(...)) to make it mutable.

4. Double Brace Initialization (Not Recommended)

This creates an anonymous inner class (memory overhead; avoid in production code):

ArrayList<String> list = new ArrayList<>() {{
    add("Apple");
    add("Banana");
}};

5. Java 8 Streams

Use streams for dynamic initialization (e.g., filtering):

import java.util.ArrayList;
import java.util.stream.Stream;

ArrayList<String> list = Stream.of("Apple", "Banana", "Cherry")
                               .collect(Collectors.toCollection(ArrayList::new));

6. Using Collections.addAll()

Add elements from an array or another collection:

ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "Apple", "Banana", "Cherry");

7. Third-Party Libraries (e.g., Guava)

With Google Guava’s Lists.newArrayList():

import com.google.common.collect.Lists;

ArrayList<String> list = Lists.newArrayList("Apple", "Banana", "Cherry");

Key Differences

Method	Java Version	Mutable?	Notes
Empty Constructor	All	Yes	Flexible for dynamic additions
Arrays.asList()	All	Yes*	Wrapped in new ArrayList<>()
List.of()	9+	No	Immutable; wrap to make mutable
Double Brace	All	Yes	Avoid (memory overhead)
Java 8 Streams	8+	Yes	Useful for complex initializations
Guava	All	Yes	Requires Guava dependency

When to Use Which

• Empty List: Use new ArrayList<>() when starting with no elements.
• Small Fixed Elements: Use Arrays.asList() or List.of() (Java 9+).
• Immutable Lists: Use List.of() (Java 9+).
• Dynamic Initialization: Use streams or Collections.addAll().

Example Summary

// Java 5+ (mutable)
ArrayList<String> list1 = new ArrayList<>(Arrays.asList("A", "B", "C"));

// Java 9+ (mutable)
ArrayList<String> list2 = new ArrayList<>(List.of("A", "B", "C"));

// Empty list (add elements later)
ArrayList<String> list3 = new ArrayList<>();
list3.add("A");

Choose the method that best fits your use case and Java version!