How do I copy a stack in Java?

The Stack class is a sub-class of AbstractList.

Simply treat it like an AbstractList, iterate through the elements in the stack using the get(int index) method, from 0 to the length of your list/stack, and add the elements to the new stack.

This won't copy the elements - it will add the elements to the new stack. If you need to copy the elements as well, you'll need to go another level deep and create copies of the elements, and add those to the new stack.

You can do full (or "deep") copies, by using the clone method, but note that the object must implement the Clonable interface in order to get deep copies of objects.

Stack extends Vector, so you can just new up a new Stack and use .addAll(...) to copy the items:

Stack<Type> newStack = new Stack<Type>();
newStack.addAll(oldStack);

Just use the clone() -method of the Stack-class (it implements Cloneable).

Here's a simple test-case with JUnit:

@Test   
public void test()
{
    Stack<Integer> intStack = new Stack<Integer>();
    for(int i = 0; i < 100; i++)        
    {
        intStack.push(i);
    }

    Stack<Integer> copiedStack = (Stack<Integer>)intStack.clone();

    for(int i = 0; i < 100; i++)            
    {
        Assert.assertEquals(intStack.pop(), copiedStack.pop());
    }
}

Edit:

tmsimont: This creates a "unchecked or unsafe operations" warning for me. Any way to do this without generating this problem?

I at first responded that the warning would be unavoidable, but actually it is avoidable using <?> (wildcard) -typing:

@Test
public void test()
{
    Stack<Integer> intStack = new Stack<Integer>();
    for(int i = 0; i < 100; i++)
    {
        intStack.push(i);
    }

    //No warning
    Stack<?> copiedStack = (Stack<?>)intStack.clone();

    for(int i = 0; i < 100; i++)
    {
        Integer value = (Integer)copiedStack.pop(); //Won't cause a warning, no matter to which type you cast (String, Float...), but will throw ClassCastException at runtime if the type is wrong
        Assert.assertEquals(intStack.pop(), value);
    }
}

Basically I'd say you're still doing an unchecked cast from ? (unknown type) to Integer, but there's no warning. Personally, I'd still prefer to cast directly into Stack<Integer> and suppress the warning with @SuppressWarnings("unchecked").