栈的实现

越努力，越幸运！！！
如果本文有哪些不对的地方，欢迎各位大佬指正，谢谢！

一、何为栈

栈这个数据结构也是线性数据结构的一种。但是栈这种数据结构存和取都是同一个方向，存数据我们称之为入栈(push)，取数据我们称之为出栈(pop)。在栈中，我们只能取出最新放入的数据。栈就像一骡子书，最先放的书最终会在最底下，而我们取书，只能从最上面开始取，直到取到我们想要的那本书。

后进先出(LIFO)

像栈这种最后进入的数据，最先出来，我们称之为后进先出(Last In,First Out.LIFO)。
与链表和数组一样，栈的数据也是线性排列，但在栈中，添加和删除数据的操作只能在一端进行，访问数据也只能访问到顶端的数据。想要访问中间的数据时，就必须通过出栈操作将目标数据移到栈顶才行。

二、栈的具体实现

public class Stack<E> {

    /**
     * 栈中有效的元素个数，即栈的长度
     */
    private int elementCount;
    
    /**
     * 栈空间数组
     */
    private Object[] elementData;
    
    /**
     *  容量扩增时增加需增加的向量值。如果该值不大于0,则增加现在容量的一半。
     */
    private int capacityIncrement;
    
    /**
     * 用于创建一个空栈的构造器。此构造器可以设置栈空间大小和容量溢出时的增长容量。
     *
     * @param initialCapacity   栈空间初始化容量
     * @param capacityIncrement 栈容量溢出时的增长容量
     */
    public Stack(int initialCapacity, int capacityIncrement) {
        if (initialCapacity < 0) {
            throw new ArrayIndexOutOfBoundsException("initialCapacity Error," +
                    " initialCapacity must grater than zero : " + initialCapacity);
        }
        this.capacityIncrement = capacityIncrement;
        elementData = new Object[initialCapacity];
    }
    
    /**
     * 用于创建一个空栈的构造器。此构造器可以设置栈空间初始容量。
     *
     * @param initialCapacity 栈空间初始化容量
     */
    public Stack(int initialCapacity) {
        this(initialCapacity, 0);
    }
    
    /**
     * 用于创建一个空栈的构造器。此构造器的默认初始容量为10。
     */
    public Stack() {
        this(10);
    }
    
    public int size() {
        return elementCount;
    }
    
    /**
     * 入栈
     * @param item 元素
     * @return 返回入栈元素
     */
    public E push(E item) {
        ensureCapacity(elementCount + 1);
        elementData[elementCount++] = item;
        return item;
    }
    
    /**
     * 出栈
     * @return 返回栈顶元素
     */
    @SuppressWarnings("unchecked")
    public synchronized E pop() {
        if (size() == 0) {
            throw new EmptyStackException();
        }
        E obj = (E) elementData[size() - 1];
        elementData[--elementCount] = null;
        return obj;
    }
    
    /**
     * 判断栈的容量是否足够大
     * @param minCapacity 栈的最小容量
     */
    private void ensureCapacity(int minCapacity) {
        // 如果入栈后大于数组长度，则需要扩容
        if (minCapacity - elementData.length > 0) {
            grow(minCapacity);
        }
    }
    
    private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (capacityIncrement > 0 ? capacityIncrement : oldCapacity >> 1);
        if (newCapacity - minCapacity < 0) {
            newCapacity = minCapacity;
        }
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    
    @Override
    public String toString() {
        return "Stack{" +
                "elementData=" + Arrays.toString(elementData) +
                '}';
    }
}

三、栈的应用

栈只能在一端操作这一点看起来似乎十分不便，但在只需要访问最新数据时，使用它就比较方便了。比如，规定（AB（C（DE）F）（G（（H）I J）K））这一串字符中括号的处理方式如下：首先从左边开始读取字符，读到左括号就将其入栈，读到右括号就将栈顶的左括号出栈。此时，出栈的左括号便与当前读取的右括号相匹配。通过这种处理方式，我们就能得知配对括号的具体位置。

String str = "(AB(C(DE)F)(G((H)IJ)K))";
String[] strs = str.split("");
List<StringBuilder> siteList = new ArrayList<>();
Stack<Integer> stack = new Stack<>();
for (int i = 0; i < strs.length; i++) {
    if ("(".equals(strs[i])) {
        stack.push(i);
    }
    if (")".equals(strs[i])) {
        StringBuilder builder = new StringBuilder("[");
        int site = stack.pop();
        builder.append(site).append(", ");
        builder.append(i).append("]");
        siteList.add(builder);
    }
}
System.out.println(siteList.toString());

四、Java集合中的栈

Java 也实现了栈这个数据结构，让我们来看看 Java 中是如何实现栈的。

1、栈的结构

Java 的栈，只有上图所示的一些方法，也就是栈最基本的功能，入栈和出栈。除此之外，还新增了一点功能。
如果想看懂 Stack 的源码，只看 Stack 是不够的，还需要看 Vector 的实现源码。因为，Stack 继承于 Vector，Stack 中很多的功能都是直接继承自 Vector 的。
因为 Vector 是和ArraysList 和 LinkedList 同宗同源，都实现了 List 接口，所以里面有很多的功能，这里我们只是为了看懂 Stack 具体实现，我们只会涉及我们所需了解的部分 Vector 代码。

Stack 源码解读

public
class Stack<E> extends Vector<E> {
    
    // 构造器用于创建一个空栈
    public Stack() {
    }
    // 入栈，向栈空间添加元素
    public E push(E item) {
        // 调用了父类中添加元素的方法，详细见Vector解读
        addElement(item);
        return item;
    }
    // 出栈，删除栈空间最上面的元素
    public synchronized E pop() {
        E       obj; // 存储栈顶元素
        int     len = size(); // 栈的长度
        // 查询栈顶元素
        obj = peek();
        // 调用了父类中的删除指定索引位置元素的方法，详细见Vector源码解读
        removeElementAt(len - 1);
        return obj;
    }
    // 查询栈顶元素
    public synchronized E peek() {
        int     len = size(); // 栈长度
        // 校验是否为空栈，提前暴露异常
        if (len == 0) 
            throw new EmptyStackException();
        // 调用了父类中的查询指定索引位置元素的方法，详细见Vector源码解读
        return elementAt(len - 1);
    }
    // 该方法返回当前栈是否为空栈
    public boolean empty() {
        return size() == 0;
    }
    // 查询栈中元素与栈顶最近的距离，如果该元素本身处于栈顶，则距离计为1。
    public synchronized int search(Object o) {
        // 调用了父类中查询指定元素最后一次出现的索引位置，详细见Vector源码解读
        int i = lastIndexOf(o);
        // 如果找到了对应的元素索引位置，那么将返回该元素与栈顶最近的距离
        if (i >= 0) {
            return size() - i;
        }
        // 未找到指定元素，则返回-1
        return -1;
    }
    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = 1224463164541339165L;
}

Vector 部分源码解读

public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    // 存储元素的数组
    protected Object[] elementData;
    
    // Vector集合的有效元素个数
    protected int elementCount;
    
    // 当Vector容量不够时，当该值大于0时，为Vector扩容默认的增长向量
    protected int capacityIncrement;
    
    /**
    * 构造器，创建一个空的Vector集合
    * initialCapacity 为Vector数组默认初始容量
    * capacityIncrement 为Vector扩容时的默认增长向量
    */
    public Vector(int initialCapacity, int capacityIncrement) {
        super();
        // 初始容量必须大于等于0
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        // 初始化Vector集合数组                                       
        this.elementData = new Object[initialCapacity];
        // 初始化扩容增长向量
        this.capacityIncrement = capacityIncrement;
    }
    
    /**
    * 构造器，创建一个空的Vector集合
    * 该构造器调用了上面的构造器 this(具体形参),调用当前类中对应的构造器
    */
    public Vector(int initialCapacity) {
        this(initialCapacity, 0);
    }
    /**
    * 构造器，创建一个空的Vector集合
    * 该构造器调用了上面的构造器 this(具体形参),调用当前类中对应的构造器
    * 空构造器，默认初始化数组长度为10
    */
    public Vector() {
        this(10);
    }
    
    // 在Vector集合末尾添加元素
    public synchronized void addElement(E obj) {
        // 该变量是AbstractList接口中的成员变量，用于fail—fast机制。
        // 该变量用于记录此列表在结构上被修改的次数。
        // 结构修改是指那些改变列表大小的修改，或者以某种方式扰乱列表，使得正在进行的迭代可能产生不正确的结果。
        // 该字段用于迭代器，在遍历集合时，如果该变量发生改变，则会抛出ConcurrentModificationException。
        // 当该集合处于并发情况下，一个线程在遍历该元素，另一个线程对该集合做了删除/增加元素操作，
        // 导致modCount值不一致，则会直接抛出异常。
        // 子类使用此字段是可选的。如果子类希望提供fail fast迭代器（和list迭代器），
        // 则它只需在新增和删除方法中增加此字段（以及它覆盖的导致列表结构修改的任何其他方法）。
        modCount++; 
        // 确认是否需要扩容
        ensureCapacityHelper(elementCount + 1);
        // 新增元素，并增加集合长度
        elementData[elementCount++] = obj;
    }
    
    /**
    * 确认当前集合是否需要扩容
    * minCapacity 该参数为集合需要的最小容量，该值为当前集合长度 + 1,即默认新增一个元素成功后的长度
    */
    private void ensureCapacityHelper(int minCapacity) {
        // 如果当前集合容量小于所需的最小容量，则需要扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity); // 扩容方法
    }
    
    /**
    * 对集合容量进行扩容
    * minCapacity 该参数为集合需要的最小容量，该值为当前集合长度 + 1,即默认新增一个元素成功后的长度
    * 其实Vector扩容的本质就是创建一个更大的数组，然后将当前所有数据都按照原先的索引位置拷贝，再将地址传给原先的引用
    */
    private void grow(int minCapacity) {
        // 存储现集合容量
        int oldCapacity = elementData.length;
        // 初步计算新的集合容量
        // 1. 如果默认的扩容增长向量大于0,则直接增长该向量值
        // 2. 如果默认的扩容增长向量小于等于0,则直接增长当前集合容量的一倍
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        // 判断新集合容量是否满足最小容量的需求，如果不满足，则直接扩容至所需的最小容量                                 
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        // 判断新集合容量是否大于数组最大长度，MAX_ARRAY_SIZE默认值为Integer最大值-8
        // 如果大于数组最大长度，则说明已经接近Integer最大值，则调用获取集合最大容量的方法
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // 确认好集合的新容量后，使用Arrays API 直接创建一个新容量的数组，
        // 并将当前集合中的元素全数拷贝到新数组，最后赋值给elementData    
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    
    /**
    * 获取集合最大容量的方法
    */
    private static int hugeCapacity(int minCapacity) {
        // 校验新增元素所需最小容量值的合法性
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        // 如果，新增元素所需的最小容量都超过了数组的最大值，则表明即使扩容到数组的最大值也不够用，
        // 需要直接扩容到Integer的最大值    
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }
    
    /**
    *   删除指定索引位置的元素
    */
    public synchronized void removeElementAt(int index) {
        // 用于fail-fast机制。
        modCount++;
        // 校验给定的索引位置是否合法
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index + " >= " +
                                                     elementCount);
        }
        else if (index < 0) {
            throw new ArrayIndexOutOfBoundsException(index);
        }
        // 计算元素拷贝的长度，即从删除元素索引位置后面的元素个数
        int j = elementCount - index - 1;
        // 校验删除的是否为集合的最后一个元素，如果是，则不需要拷贝数组元素操作
        if (j > 0) {
            // 基于数组的特性，删除元素需要移动数组元素，除非是最后一个元素。
            // 这里的删除元素，就是将删除元素的索引位置往后的所有元素向前移动一位
            // arraycopy说明，将elementData中的元素从index + 1开始拷贝，
            // 拷贝到elementData数组中，从index位置往后拷贝长度j
            System.arraycopy(elementData, index + 1, elementData, index, j);
        }
        // 集合长度减一
        elementCount--;
        // 我们将数组的从删除索引位置都向前拷贝了一位，
        // 那么集合原来集合中最后一个元素还是存在，并没有清空，不满足我们的需求
        // 所以，将集合的最后一个元素置为null
        elementData[elementCount] = null; /* to let gc do its work */
    }
    
    // 获取指定索引位置处的元素值
    public synchronized E elementAt(int index) {
        // 校验索引的合法性
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
        }
        return elementData(index);
    }
    
    // 获取指定索引位置处的元素值
    @SuppressWarnings("unchecked")
    E elementData(int index) {
        return (E) elementData[index];
    }
    
    // 查询指定元素在集合中最后一次出现的索引值
    public synchronized int lastIndexOf(Object o) {
        return lastIndexOf(o, elementCount-1);
    }
    
    // 查询指定元素在集合中最后一次出现的索引值，index为集合中有效元素的最大索引值
    public synchronized int lastIndexOf(Object o, int index) {
        // 校验索引的合法性
        if (index >= elementCount)
            throw new IndexOutOfBoundsException(index + " >= "+ elementCount);
        // 如果所查找的值为null，则直接找值为null的元素，防止NPE
        if (o == null) {
            for (int i = index; i >= 0; i--)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = index; i >= 0; i--)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }
}

五、总结

1、栈的实现

这里的栈是用数组实现的，而且 Java 集合中的 Stack 也是用数组实现的，但是也可以用链表来进行实现。基于栈后入先出的特性，操作都在一端，不管用数组还是用链表来实现的，也就是一直操作数组的最后一个元素，增加和删除的时间复杂度均为0(1)。但是，Java 集合中的 Stack 中也有元素查询方法，使用数组会更快。

2、fail-fast机制

快速失败机制是用于迭代器，用于集合的遍历。快速失败机制基于变量modCount，该变量用于记录此列表在结构上被修改的次数。结构修改是指那些改变列表大小的修改(增加/删除)，或者以某种方式扰乱列表，使得正在进行的迭代可能产生不正确的结果。
当该集合处于并发情况下，一个线程在遍历该元素时，另一个线程对该集合做了删除/增加元素操作，导致modCount值不一致，则会直接抛出ConcurrentModificationException异常。

3、基于数组的集合扩容的本质

我们都知道数组一旦定义下来，其长度就是固定的，而集合的长度却不是固定的，是可以变动的。

那么基于数组来实现的集合是如何满足长度可变的呢？

原先集合的容器为数组A，当数组长度不够时，就去创建一个更大的数组B，然后将A中的元素按照原先的索引位置复制到数组B中，并将B的地址赋值给A的引用。只不过，这里新数组的长度需要经过计算，不是随意而来的。


您都看到这了？如何觉得写的还行，不妨给个赞？

参考文献：我的第一本算法书(1-4栈) – 宫崎修