import java.util.ArrayList;
import java.util.Collections;
import java.util.Stack;

/**
* Small class illustrating the difference between a deep and a shallow copy
**/
public class CopyObject {
    private Stack<Integer> stack;

/**
* Create an instance containing a stack
**/
    public CopyObject(int size) {
	stack = new Stack<>();
	for (int i=0; i<size; i++) stack.push(i);
    }

    /**
    * Printing using a shallow copy of stack.
    * The result is the stack is emptied
    **/
    public String toString() {
	StringBuffer sb = new StringBuffer();
	Stack<Integer> sCopy = stack; // shallow copy
	while (!sCopy.empty()){
	    sb.append(sCopy.pop());
	    if (!sCopy.empty()) sb.append(" ");
	}
	return sb.toString();
    }

/**
Driver method
**/
    public static void main(String[] args){
	CopyObject co = new CopyObject(10);
	System.out.println("First  " + co.toString());
	System.out.println("Second " + co.toString());
    }


    
    
    
  /**
 * Deep copy technique 1
 * Make a new stack and get all of the objects into the stack
 **/
    private Stack<Integer> copyStack1(){
	Stack<Integer> newStack = new Stack<>();
	ArrayList<Integer> ali = new ArrayList<>();
	while (!stack.isEmpty())
	    ali.add(stack.pop());
	for (Integer ii : ali) {
	    stack.push(ii);
	    newStack.push(ii);
	}
	return newStack;
    }

/**
* Deep copy technique 2.
* The same effect as technique 1 but using java Colletions to make the copy.
**/
    private Stack<Integer> copyStack2() {
	Stack<Integer> newStack = new Stack<>();	
	Collections.copy(newStack, stack);
	return newStack;
    }


}