Java: Is Stack.addAll the same as pushing elements individually?

Question

If I want to add a number of elements at once, regardless of their order (for DFS), does Java's generic addAll() method for Stack work the same way as the Stack-specific push(), just with a number of elements?

Answer 1

Short answer: Functionally, they achieve the same goal, but not necessarily in the same way.

Long answer: From the documentation of Stack#push:

Pushes an item onto the top of this stack. This has exactly the same effect as: addElement(item)

Further, Vector#addElement says:

Adds the specified component to the end of this vector

So therefore, push appends to the end of the Vector.

Now, from the documentation of Vector#addAll:

Appends all of the elements in the specified Collection to the end of this Vector, in the order that they are returned by the specified Collection's Iterator.

This has the same effect of calling addElement on each element, and thus (by extension) the same effect of calling push on each element.

That said, addAll will likely do things far more efficiently.

Answer 2

Nope, Stack's implementation defined by Vector.addAll, which looks like this:

/**
 * Appends all of the elements in the specified Collection to the end of
 * this Vector, in the order that they are returned by the specified
 * Collection's Iterator.  The behavior of this operation is undefined if
 * the specified Collection is modified while the operation is in progress.
 * (This implies that the behavior of this call is undefined if the
 * specified Collection is this Vector, and this Vector is nonempty.)
 */
public synchronized boolean addAll(Collection<? extends E> c) {
    modCount++;
    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityHelper(elementCount + numNew);
    System.arraycopy(a, 0, elementData, elementCount, numNew);
    elementCount += numNew;
    return numNew != 0;
}

So it doesn't just call push in a loop.

We can compare this with the Vector.addElement function which Stack.push calls:

public synchronized void addElement(E obj) {
    modCount++;
    ensureCapacityHelper(elementCount + 1);
    elementData[elementCount++] = obj;
}

If you called push in a loop, there would be at least unneeded multiple calls to ensureCapacityHelper. Therefore, as you might expect, I suspect addAll has better performance.