Stack

几句话证明你看过Stack的源码
Stack不推荐使用，推荐使用ArrayDeque

1.结构

Stack extends Vector(矢量队列)
Vector extends AbstractList
Vector底层结构同ArrayList也是动态数组

2.push方法&pop方法

查看栈顶元素使用同步锁
压栈不使用同步锁

//压栈到栈顶
public E push(E item) {
        addElement(item);

        return item;
    }

//查看栈顶元素 并 弹栈
public synchronized E pop() {
        E       obj;
        int     len = size();

        obj = peek();
        //同ArrarList remove操作
        removeElementAt(len - 1);

        return obj;
    }

//查看栈顶元素 不弹栈
public synchronized E peek() {
        int     len = size();

        if (len == 0)
            throw new EmptyStackException();
        //数组角标取元素
        return elementAt(len - 1);
    }

3.栈的链表实现参考LinkedList

4.自定义Stack练习-基于数组结构

public class ArrayStack<E> implements MyStack<E> {

    private static final int DEAULT_CAPACITY = 10;

    private E[] data;

    private int size;

    /**
     * 栈：先进后出，所以记录栈顶元素
     */
    private int top;

    public ArrayStack(int capacity) {
        data = (E[]) new Object[capacity];
        top = -1;
    }

    public ArrayStack() {
        this(DEAULT_CAPACITY);
    }

    @Override
    public void push(E e) {
        final int minCapacity = size + 1;
        if (minCapacity == data.length) {
            //扩容
            grow(minCapacity);
        }

        data[++top] = e;
        size++;
    }

    private void grow(int minCapacity) {
        //扩容1.5倍
        int newCapacity = data.length + (data.length >> 1);
        if (newCapacity < minCapacity) {
            newCapacity = minCapacity;
        }
        data = Arrays.copyOf(data, newCapacity);
    }

    @Override
    public E pop() {
        E e = data[top];
        data[top--] = null;
        size--;
        return e;
    }

    @Override
    public E peek() {
        return data[top];
    }

    @Override
    public boolean empty() {
        return size == 0;
    }

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

    public static void main(String[] args) {
        MyStack<Integer> stack = new ArrayStack();
        for (int i = 0; i < 20; i++) {
            stack.push(i+1);
        }
        System.out.println(stack.peek());
        System.out.println(stack.pop());
        int size = stack.size();
        for (int i = 0; i < size; i++) {
            Integer pop = stack.pop();
            System.out.println(pop);
        }
    }
}

5.自定义Stack练习-基于链表结构

public class LinkedStack<E> implements MyStack<E> {

    private int size;

    /**
     * 栈：先进后出，所以记录栈顶元素
     */
    private Node<E> top;

    @Override
    public void push(E e) {
        Node<E> oldTop = this.top;
        this.top = new Node(e, oldTop);
        size++;
    }

    @Override
    public E pop() {
        E item = top.item;
        top = top.next;
        size--;
        return item;
    }

    @Override
    public E peek() {
        return top.item;
    }

    @Override
    public boolean empty() {
        return size == 0;
    }

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

    private static class Node<E> {
        E item;
        Node<E> next;

        public Node(E item, Node<E> next) {
            this.item = item;
            this.next = next;
        }
    }

    public static void main(String[] args) {
        MyStack<Integer> stack = new LinkedStack<>();
        for (int i = 0; i < 20; i++) {
            stack.push(i + 1);
        }
        System.out.println(stack.peek());
        System.out.println(stack.pop());
        int size = stack.size();
        for (int i = 0; i < size; i++) {
            Integer pop = stack.pop();
            System.out.println(pop);
        }
    }
}