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:

• create test data
• define default options
• prepare seed values
• pass lists to methods
• decide whether data should be editable

The best choice depends on whether you need to later add or remove items.

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:

• you only need a quick list
• you do not need to add or remove elements

Important:

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

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

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

Use this when:

• the list should never change
• you want a concise modern style

Important:

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

4. Recommended variable type: program to the interface

Often this is better than declaring ArrayList directly:

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

This is more flexible because your code depends on the List interface, not one specific implementation.

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:

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

Compare that with this version:

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

Execution:

1. Arrays.asList(...) creates a fixed-size list.
2. places.add("Mendoza") tries to grow the list.
3. Java throws UnsupportedOperationException because this list cannot change size.

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.

Test setup

In tests, short one-line list creation is common because readability matters more than reuse:

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

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:

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

Why:

• it reduces coupling
• it makes refactoring easier

3. Trying to modify a List.of(...) list

Broken example:

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

Problem:

• List.of(...) creates an immutable list.

Fix:

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

4. Using older verbose generic syntax unnecessarily

Older style:

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

Cleaner modern style:

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

The diamond operator <> lets Java infer the generic type.

5. Forgetting Java version differences

• List.of(...) requires Java 9+
• Arrays.asList(...) works in older Java versions

If you support older Java, Arrays.asList(...) is often the practical choice.

Which one should you choose?

• Choose Arrays.asList(...) if you only need a quick fixed-size list.
• Choose new ArrayList<>(Arrays.asList(...)) if you want a mutable list in one line.
• Choose List.of(...) if the values should never change.
• Prefer List<String> as the variable type unless you specifically need ArrayList.

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", "La Plata"));

Best practice

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

• Prefer List as the variable type
• Use ArrayList when you need resizing
• Use List.of(...) for constants or read-only values

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.

Is List.of(...) better than Arrays.asList(...)?

For immutable lists in modern Java, yes. It is more explicit about being unmodifiable.

Which approach is best for test data?

• Use List.of(...) if the test data should not change.
• Use new ArrayList<>(...) if the test modifies the list.

Can I still use the multi-line add(...) approach?

Yes. It is perfectly valid and can be clearer when values are built gradually or conditionally.

• 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.