Stack栈

public interface Stack<Item> {
    int getSize();
    boolean isEmpty();
    void push(Item e);
    Item pop();
}

 @Override
    public int size() {
        return top;
    }

    @Override
    public boolean isEmpty() {
        return top==0;
    }

    @Override
    /**
     * 压栈
     */
    public void push(Item e) {
        if (size()== stack.length){
            expandCapacity();
        }
        stack[top]=e;
        top++;
    }

    /**
     * 栈扩容
     */
    private void expandCapacity(){
        stack = Arrays.copyOf(stack,stack.length*2);
    }

    @Override
    /**
     * 出栈 返回当前栈顶元素
     */
    public Item pop() {
        if (isEmpty())
            throw  new EmptyStackException();
        top--;
        Item item = stack[top];
        return item;
    }

    @Override
    public Item peek() {
        if (isEmpty())
            throw  new EmptyStackException();
        return stack[top-1];
    }

public class LinkedStack <Item> implements Iterator<Item> {

    private class Node{
        Item item;
        Node next;

        public Node(Item item, Node next) {
            this.item = item;
            this.next = next;
        }
    }
    private Node first;//栈顶元素
    private int size;//栈元素总数
    private Node currNode;

    public void push(Item item){
        first = new Node(item,first);
        currNode = first;
        size++;
    }

    public Item pop(){
        Node currFirst = first;
        first = currFirst.next;
        currNode = first;
        size--;
        return currFirst.item;
    }

    public boolean isEmpty(){
        return size==0;
    }

    public int getSize() {
        return size;
    }

    @Override
    public boolean hasNext() {
        return currNode!=null;
    }

    @Override
    public Item next() {
        Item item = currNode.item;
        currNode = currNode.next;
        return item;
    }
    
    @Override
    public void remove() {
        throw new UnsupportedOperationException();
    }
}