Java ArrayList Initialization in One Line

By the end of this page, you will understand several common ways to initialize lists in Java, especially ArrayList in a single line. You will learn when to use Arrays.asList(...), when to wrap it in new ArrayList<>(...), how modern Java uses List.of(...), and how mutability affects which approach is best.

In Java, list initialization is really about two separate decisions:

1. How to provide the starting values
2. Whether the resulting list should be mutable or immutable

This matters because not every list-like object in Java behaves the same way.

For example:

• new ArrayList<>() creates a normal, mutable resizable list.
• Arrays.asList(...) creates a fixed-size list backed by an array.
• List.of(...) creates an immutable list in modern Java.

Your refactored version is a very common and good approach:

ArrayList<String> places = new ArrayList<>(
    Arrays.asList("Buenos Aires", "Córdoba", "La Plata")
);

Why does this work well?

• Arrays.asList(...) quickly creates a list from values.
• new ArrayList<>(...) copies those values into a real mutable ArrayList.

This is useful because Arrays.asList(...) alone does not give you a fully flexible ArrayList.

In real programming, this concept matters whenever you:

Think of Java list initialization like packing items into a container.

• Arrays.asList(...) is like putting items into a tray with fixed slots. You can replace an item in a slot, but you cannot add more slots or remove slots.
• new ArrayList<>(...) is like moving those items into a flexible bag that can grow or shrink.
• List.of(...) is like sealing the items in a display case: you can look at them, but you cannot change them.

So the real question is not just "How do I write this in one line?" It is also: What kind of list behavior do I want afterward?

Common ways to initialize a list in Java

1. Mutable ArrayList with initial values

ArrayList<String> places = new ArrayList<>(
    Arrays.asList("Buenos Aires", "Córdoba", "La Plata")
);

Use this when:

• you want a real ArrayList
• you may add or remove items later

Example:

ArrayList<String> places = new ArrayList<>(
    Arrays.asList("Buenos Aires", "Córdoba", "La Plata")
);

places.add("Mendoza");
System.out.println(places);

Output:

[Buenos Aires, Córdoba, La Plata, Mendoza]

2. Fixed-size list with Arrays.asList(...)

List<String> places = Arrays.asList("Buenos Aires", "Córdoba", "La Plata");

Use this when:

Consider this example:

List<String> places = new ArrayList<>(
    Arrays.asList("Buenos Aires", "Córdoba", "La Plata")
);

Here is what happens step by step:

1. Java evaluates Arrays.asList("Buenos Aires", "Córdoba", "La Plata").
2. That creates a list containing three strings.
3. That list is passed into the ArrayList constructor.
4. The constructor copies the elements into a new mutable ArrayList.
5. The variable places now refers to that new ArrayList.

Now trace this code:

List<String> places = new ArrayList<>(
    Arrays.asList("Buenos Aires", "Córdoba", "La Plata")
);

places.add("Mendoza");
System.out.println(places);

Execution:

• Start with [ "Buenos Aires", "Córdoba", "La Plata" ]
• places.add("Mendoza") appends a new element.
• Final list becomes:

This pattern appears often in real Java code.

Test data

List<String> testUsers = new ArrayList<>(Arrays.asList("alice", "bob", "carol"));

Useful for unit tests, mock data, and examples.

Default configuration values

List<String> supportedLocales = List.of("en", "es", "fr");

Good when values should not change.

API input preparation

List<Integer> ids = new ArrayList<>(Arrays.asList(10, 20, 30));
ids.add(40);

Useful when building request payloads dynamically.

Seed data for scripts or demos

List<String> cities = Arrays.asList("Buenos Aires", "Córdoba", "La Plata");

Good when you only need to iterate over a fixed set of values.

In real codebases, developers usually choose the initialization style based on mutability and readability.

Common patterns

Program to the List interface

List<String> places = new ArrayList<>(Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));

This makes it easier to later change the implementation.

Use immutable lists for constants

private static final List<String> SUPPORTED_CITIES = List.of(
    "Buenos Aires",
    "Córdoba",
    "La Plata"
);

This prevents accidental changes.

Copy before modifying external data

List<String> input = Arrays.asList("a", "b", "c");
List<String> editable = new ArrayList<>(input);
editable.add("d");

This is common when a method receives data but needs a mutable copy.

Validation and defensive coding

Developers often use immutable lists where possible because they reduce bugs caused by accidental mutation.

1. Assuming Arrays.asList(...) returns a normal ArrayList

Broken example:

List<String> places = Arrays.asList("Buenos Aires", "Córdoba", "La Plata");
places.add("Mendoza");

Problem:

• This compiles.
• It fails at runtime with UnsupportedOperationException.

Fix:

List<String> places = new ArrayList<>(Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));
places.add("Mendoza");

2. Declaring the variable as ArrayList when List is enough

Less flexible:

ArrayList<String> places = new ArrayList<>(Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));

Usually better:

Quick reference

Mutable ArrayList in one line

List<String> places = new ArrayList<>(Arrays.asList("Buenos Aires", "Córdoba", "La Plata"));

Fixed-size list

List<String> places = Arrays.asList("Buenos Aires", "Córdoba", "La Plata");

• Can replace values with set(...)
• Cannot add(...) or remove(...)

Immutable list

List<String> places = List.of("Buenos Aires", "Córdoba", "La Plata");

• Cannot modify at all
• Java 9+

Mutable copy of immutable or fixed-size list

List<String> places = new ArrayList<>(List.of("Buenos Aires", "Córdoba", ));

Is Arrays.asList(...) the same as new ArrayList<>(...)?

No. Arrays.asList(...) returns a fixed-size list, while new ArrayList<>(...) creates a normal resizable list.

What is the best one-line way to create a mutable list in Java?

A common choice is:

List<String> items = new ArrayList<>(Arrays.asList("a", "b", "c"));

If you use Java 9+, this is also good:

List<String> items = new ArrayList<>(List.of("a", "b", "c"));

Should I declare the variable as List or ArrayList?

Usually List is better because it keeps your code flexible and less tied to one implementation.

Why does add() fail after using Arrays.asList(...)?

Because the returned list has a fixed size. It supports reading and replacing elements, but not growing or shrinking.

• List interface — important because most Java list variables should use the interface type.
• ArrayList — the standard resizable list implementation.
• Arrays.asList — a common utility for creating a fixed-size list from values.
• List.of — the modern Java way to create immutable lists.
• Mutability vs immutability — helps you choose whether a list should be editable.
• Java generics — explains types like List<String> and ArrayList<String>.
• Diamond operator — simplifies generic construction with new ArrayList<>().
• UnsupportedOperationException — the runtime error often seen when modifying fixed-size or immutable lists.