An ArrayList in Java is a List that is backed by an array.

The get(index) method is a constant time, O(1), operation.

The code straight out of the Java library for ArrayList.get(index):

public E get(int index) {
    RangeCheck(index);
    return (E) elementData[index];
}

Basically, it just returns a value straight out of the backing array. (RangeCheck(index)) is also constant time)

The best resource is straight from the official API:

The size, isEmpty, get, set, iterator, and listIterator operations run in constant time. The add operation runs in amortized constant time, that is, adding n elements requires O(n) time. All of the other operations run in linear time (roughly speaking). The constant factor is low compared to that for the LinkedList implementation.

For array lists, you would have to move all elements to adjacent positions when you insert at an index. So it takes linear time ( more the number of elements already in the list, more time it takes to move them all ).

Also Java has nothing to do with time complexities of a data structure. It is universal.

This depends on where you're adding. E.g. if in an ArrayList you add to the front of the list, the implementation will have to shift all items every time, so adding n elements will run in quadratic time.

Similar for the linked list, the implementation in the JDK keeps a pointer to the head and the tail. If you keep appending to the tail, or prepending in front of the head, the operation will run in linear time for n elements. If you append at a different place, the implementation will have to search the linked list for the right place, which might give you worse runtime. Again, this depends on the insertion position; you'll get the worst time complexity if you're inserting in the middle of the list, as the maximum number of elements have to be traversed to find the insertion point.

The actual complexity depends on whether your insertion position is constant (e.g. always at the 10th position), or a function of the number of items in the list (or some arbitrary search on it). The first one will give you O(n) with a slightly worse constant factor, the latter O(n^2).

Arrays.asList - just this one would be O(1). Under the hood a new ArrayList is created with the given array - no matter of the size of the array.

Or simpler, the same action happens all the time no matter the size of the array = it's constant.

When you do new ArrayList(Arrays.asList...), internally it copies the data:

....
elementData = Arrays.copyOf(elementData, size, Object[].class);

that will ultimately call System::arrayCopy; and this is where it gets tricky. In general, that could be thought as O(n), but since that is a native method is could be implemented as a single CPU instruction; thus becoming O(1).

I would still go with O(n) as the answer.

Imagine packing for a trip with two choices for luggage: a regular suitcase (Array) and an expandable suitcase (ArrayList). Array: It's like a regular suitcase. You choose its size when you pack, like a small, medium, or large suitcase. Once you pick, it's fixed. If it's small and you try to add more, it won't fit. If it's not full, you still carry the empty space. In Java, an Array of size 10 can only store 10 elements, no more, no less. ArrayList: This is an expandable suitcase. It grows or shrinks as needed. Start with a few items? It adjusts. Found souvenirs? It expands. Decided to leave stuff behind? It shrinks. In Java, ArrayList is part of the Java Collection Framework and adjusts its size as you add or remove elements. Key Differences: Size: Arrays have fixed sizes. ArrayLists can change size dynamically. Type: Arrays can hold primitive types (like int, char) and objects. ArrayLists only hold objects, not primitives. Performance: Adding or removing items in an ArrayList might be slower due to potential resizing and copying to a new location. Utility: ArrayLists offer methods like .add(), .remove(), .indexOf(), making them more user-friendly than Arrays. Time and Space Complexities of Arrays and ArrayLists in Java Understanding the time and space complexities of Arrays and ArrayLists is like knowing how long it takes to do tasks with your regular suitcase (Array) or expandable suitcase (ArrayList), and how much space they take up. Arrays Space Complexity: O(n). The size is fixed, and it occupies space for all its elements, regardless of whether they are used or not. Accessing an Element (Read/Write): O(1). Like picking an item from a specific pocket in your suitcase; it's quick because you know where it is. Inserting/Deleting an Element: Not applicable in the traditional sense, as the size is fixed. But if you consider overwriting an existing element or setting it to null, it's O(1). ArrayLists Space Complexity: O(n). However, it can be more due to the dynamic resizing. When an ArrayList grows, it usually doubles its size, which temporarily increases the space requirement before it's filled up. Accessing an Element (Read/Write): O(1). Similar to arrays, direct index access. Inserting an Element: Average Case: O(1). If there's room in the ArrayList. Worst Case (resizing required): O(n). Resizing involves creating a new array and copying elements, which takes more time. Deleting an Element: Average/Worst Case: O(n). Removal requires shifting elements to fill the gap left by the deleted element, which takes more time as the size of the ArrayList increases. In summary, both arrays and ArrayLists offer quick access to elements. Arrays have a fixed space, while ArrayLists can resize, affecting their space complexity. Inserting and deleting elements are generally more time-consuming in ArrayLists, especially when resizing or shifting elements is involved. Choose Arrays when you know the exact number of elements. Choose ArrayLists for flexibility and convenience.