栈Stack（附源码）

栈在Java应用中并不常用，但栈这个数据结构在整个计算机体系中十分重要。

栈（stack），不要和heap（堆）搞混。都是堆栈这个词惹的祸。

栈数据结构：

栈就像是，盘子洗好后，要整理，然后一个叠一个。

对这些盘子，可以做两个事：

在最上面放一个新盘子

把顶部的盘子拿走。

这两个行为做起来很容易，但是如果从中间或者底部抽出来一个盘子，就很难。

如果我们想拿到最下面的盘子，就得把上面的一个一个拿走。这样的操作称为后进先出（LIFO）“Last In First Out”。

对于栈这样的数据结构来说，有两个常见的操作；

push：这个动作就是压入。

pop：这个动作就是弹出。

明白了栈的基本操作之后，需要深入的思考一下，栈是如何工作。换句话说，为了使栈这个数据结构按照栈的方式去工作，它需要什么？

1）一个TOP指针，用来指向栈最顶的元素。

2）初始化时候，TOP=-1，用来判断栈是否为空。

3）当我们要在栈中压入一个元素的时候，我们把TOP的值加1，然后把TOP指向新元素。

4）当我们弹出一个元素时候，我们把TOP的值减1，然后把TOP指向最新的老东西。

5）当压入的时候许哟啊判断是否已经满了，也就是说需要有isFull（）方法。

6）当我们要弹出一个元素的时候，需要检查是否已经空了，也就是说要有isEmpty（）方法。

 

空栈的时候，TOP 等于 -1；把元素 1 压入栈中的时候，stack[0] 为 1，TOP 加 1 变为 0；把元素 2 压入栈中的时候，stack[1] 为 2，TOP 加 1 变为 1；把元素 3 压入栈中的时候，stack[2] 为 3，TOP 加 1 变为 2；把元素 3 从栈中弹出后，返回元素 stack[2]，TOP 减 1 变为 1.

自定义栈：

来定义一个存储int类型的栈，使用Java语言。

需要三个字段：

int arr[],一个int类型的数组，来存放数据。

int top，一个int类型的标记。

int capacity，一个int类型的容量。

class Stack { 
     private int arr[]; 
     private int top; 
     private int capacity; 
 }

初始化栈：

Stack(int size) { 
     arr = new int[size]; 
     capacity = size; 
     top = -1; 
 }

往栈中压入元素：

public void push(int x) { 
     if (isFull()) { 
         System.out.println("溢出\n程序终止\n"); 
         System.exit(1); 
     } 
  
     System.out.println("压入 " + x); 
     arr[++top] = x; 
 }

从栈中弹出元素：

public int pop() { 
     if (isEmpty()) { 
         System.out.println("栈是空的"); 
         System.exit(1); 
     } 
     return arr[top--]; 
 }

返回栈的大小：

public int size() { 
     return top + 1; 
 }

查找栈是否为空：

public Boolean isEmpty() { 
     return top == -1; 
 }

检查栈是否已经满了：

public Boolean isEmpty() { 
     return top == -1; 
 }

来个main()方法直接测试下：

public void printStack() { 
     for (int i = 0; i <= top; i++) { 
         System.out.println(arr[i]); 
     } 
 } 
  
 public static void main(String[] args) { 
     Stack stack = new Stack(5); 
  
     stack.push(1); 
     stack.push(2); 
     stack.push(3); 
     stack.push(4); 
  
     stack.pop(); 
     System.out.println("\n弹出元素后"); 
  
     stack.printStack(); 
 }

打印结果如下：

压入 1 
压入 2 
压入 3 
压入 4 

弹出元素后 
1 
2 
3

由于是通过数组来实现的栈，所以push和pop的时间复杂度都是O（1）。

尽管栈是一种很简单的数据结构，但是它却非常强而有力，在很多场景中可以用。

1）反转-字符串：正常顺序压入，然后弹出。

2）用于计算器：

3）用于浏览器：浏览器的后退按钮会将访问的URL压入一个栈中，每次访问新的，旧的旧压入了栈顶，点击回退最新的移除，之前的URL被找到。

Stack类：

Java中实现的栈，java.util.stack,继承自Vector，是线程安全的，有点StringBuffer的感觉。

Stack类并不复杂，仅有几个重要的方法，比如push、pop、peek、empty、search等等。

来看看push源码：

    public E push(E item) {
        addElement(item);

        return item;
    }

push方法虽然没有synchronized关键字，但调用了Vector类的addElement方法，该方法加上了synchronized关键字。

    public synchronized void addElement(E obj) {
        modCount++;
        add(obj, elementData, elementCount);
    }

再来看一下pop方法的源码：

    public synchronized E pop() {
        E       obj;
        int     len = size();

        obj = peek();
        removeElementAt(len - 1);

        return obj;
    }

可以看到添加了synchronized关键字，并且先调用peek方法获取到栈顶元素。

    public synchronized E peek() {
        int     len = size();

        if (len == 0)
            throw new EmptyStackException();
        return elementAt(len - 1);
    }

接着调用Vector类的removeElementAt（）方法移除栈顶元素。

    public synchronized void removeElementAt(int index) {
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index + " >= " +
                                                     elementCount);
        }
        else if (index < 0) {
            throw new ArrayIndexOutOfBoundsException(index);
        }
        int j = elementCount - index - 1;
        if (j > 0) {
            System.arraycopy(elementData, index + 1, elementData, index, j);
        }
        modCount++;
        elementCount--;
        elementData[elementCount] = null; /* to let gc do its work */
    }

注意该方法如果移除的不是栈顶元素，还会调用System.arraycopy进行数组拷贝，因为栈的底层是由数组实现的。

public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    protected Object[] elementData;
    protected int elementCount;
    protected int capacityIncrement;
}

小结

栈是一种非常有用的数据结构，特点是先进后出，可以反转字符串，实现计算器，浏览器的后退按钮等等。

虽然Stack类不常用，但是栈这个数据结构很重要。再Java中，推进使用ArrayDeque来代替Stack，因为ArrayDeque是非线程安全的，性能更好。