Is it possible to place objects in an Arraylist as soon as instantiated?

Question

Doubt applies not only in one ArrayList, but in any kind of List. It is possible to add objects to ArrayList soon after we instantiate it, and without having to use the method add()? As can be done with arrays?

Example of what I want to do, only using one array, instead of a Collection:

int[5] array = {1, 2, 3, 4, 5};

Answer 1

If you want a simple changeable list, nothing stops you from doing that:

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

class MinhasListas {
    public static <E> List<E> of(E... elementos) {
        return new ArrayList<>(Arrays.asList(elementos));
    }
}

An example of use would be like this:

class Main {
    public static void main(String[] args) {
        List<String> x = MinhasListas.of("a", "b", "c");
        List<Integer> y = MinhasListas.of(1, 2, 3);
    }
}

And this then works with any version of Java from 5 up. So even if you’re stuck in an old version, you won’t have any problems.

Answer 2

From Java 9, you have static methods on the interface List for that reason:

List<String> abc = List.of("a", "b", "c");

But the use of this method creates a list that will be immutable, and can not be done all that can be done with a list "normal".

Answer 3

Not possible in Java.

It is possible initialize the array with a specific size to avoid needing relocations when the list gets larger than the array available.

The options cited in reply linked in comment above and other responses here do not generate a real list, generates something that looks like a list, but it is immutable and can not do everything expected from a list. And it’s not something efficient, it’s just a facilitator.

If this fits, then one array solves your problem and it can be initialized as you wish. Carrying the other solutions or do not solve the problem mentioned or the problem can be solved in a much more elegant and performative way.

It is possible to create a method that creates a real list from a sequence of arguments, but it is also not efficient. It is actually very inefficient because there will be two copies, one to initialize the array which will be passed to the method and another to copy to the list.

In C# you can do this, but it’s only syntactic sugar. In C++ you can do it, in certain circumstances efficiently.