How to Initialize an ArrayList in One Line in Java: Best Practices & Examples

Initializing an ArrayList in Java is a common task, but doing it concisely can save time and reduce boilerplate code. In this guide, you’ll learn the most efficient ways to create and populate an ArrayList in a single line, along with best practices for different Java versions.

Why Initialize an ArrayList in One Line?

• Readability: Reduce clutter in your code.
• Convenience: Quickly prepopulate lists for testing or default values.
• Efficiency: Avoid multiple calls to add().

Methods to Initialize an ArrayList in One Line

1. Using Arrays.asList() (Java 7 and Earlier)

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

// Create a mutable ArrayList
ArrayList<String> cities = new ArrayList<>(Arrays.asList("Paris", "London", "Tokyo"));

• Pros: Works in older Java versions.
• Cons:
  • Arrays.asList() returns a fixed-size list backed by an array. Wrapping it in new ArrayList<>() makes it mutable.
  • Does not allow adding/removing elements directly from the Arrays.asList() result.

2. Java 8: Streams and Collectors

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

// Initialize using Stream
ArrayList<String> colors = Stream.of("Red", "Green", "Blue")
                                 .collect(Collectors.toCollection(ArrayList::new));

• Pros: Flexible for dynamic data processing.
• Cons: More verbose for simple cases.

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

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

// Create a mutable ArrayList from an immutable list
ArrayList<String> countries = new ArrayList<>(List.of("USA", "Canada", "Mexico"));

• Pros:
  • List.of() creates a compact, immutable list.
  • No null elements allowed (prevents errors).
• Cons: Requires Java 9 or later.

4. Double Brace Initialization (Not Recommended)

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

• Pros: Minimal syntax.
• Cons:
  • Creates anonymous inner classes, leading to memory leaks.
  • Poor performance in large-scale apps.

Key Considerations

Mutable vs. Immutable Lists

// Immutable: Use List.of() (Java 9+) or Collections.singletonList() for unchangeable lists.
ArrayList<String> immutable = new ArrayList<>(List.of("A", "B")); // Cannot add/remove elements

// Mutable: Wrap with new ArrayList<>() for flexibility.
ArrayList<String> mutable = new ArrayList<>(Arrays.asList("A", "B"));

Common Pitfalls

// UnsupportedOperationException
ArrayList<String> list = new ArrayList<>(Arrays.asList("X", "Y"));
list.add("Z"); // Works

// Null Values
// List.of() disallows null; Arrays.asList() allows it.
ArrayList<String> listWithNull = new ArrayList<>(Arrays.asList("A", null, "B"));

FAQs

Q: What’s the difference between Arrays.asList and List.of?

*Backed by an array; size can’t change.

Q: Can I add elements after one-line initialization?

ArrayList<String> list = new ArrayList<>(List.of("A"));  
list.add("B"); // Works

Conclusion

Initializing an ArrayList in one line is straightforward with modern Java:

• Java 7-8: Use new ArrayList<>(Arrays.asList(...)).
• Java 9+: Prefer List.of() wrapped in ArrayList<>.
• Avoid double brace initialization for production code.

By declaring lists as ArrayList instead of List, you keep your code flexible and follow best practices.

Further Reading:

• Java ArrayList Documentation
• Java Collections Framework Guide

Need more Java tips? Explore our Java Tutorials Hub for in-depth guides!