Stack源码解析

我们从一个DEMO作为入口，了解Java的Stack的源码，代码如：

 Stack<String> stack = new Stack<>();
 stack.push("a"); // 入栈
 stack.peek(); // 查询栈顶元素
 stack.pop(); // 出栈
 stack.empty(); // 判空
 stack.search("a"); // 搜索元素

Stack类继承自Vector，基于数组实现，如图：

主要包含5个方法：入栈、出栈、查询栈顶、判空、查找元素，每个方法都有sychronized同步锁来保持同步，所以是线程安全的我们自上而下打开每个方法

入栈push()

入栈操作会先判断是否有足够的空间来存储新元素，如果没有的话那么要进行扩容

 public E push(E item) {
     addElement(item); // 添加元素
     return item; // 返回当前元素
 }

 public synchronized void addElement(E obj) {
     modCount++; // 修改次数+1
     ensureCapacityHelper(elementCount + 1); // 确定数组容量是否足够，如果不够那么扩充数组
     elementData[elementCount++] = obj; // 栈顶索引+1，将当前元素赋值到栈顶
 }

 private void ensureCapacityHelper(int minCapacity) {
     if (minCapacity - elementData.length > 0) // 当前所需的容量 - 当前数组的容量 如果大于0，那么意味着超出了数组的容量
         grow(minCapacity); // 超出则扩充数组容量
 }

 private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; // 数组元素很大的时候，可能会超出预想导致内存溢出，需要限定数组的最大值；这里-8的目的是因为有的虚拟机在实现的时候会在数组头部预留一些空间

 private void grow(int minCapacity) {
     int oldCapacity = elementData.length; // 当前数组的容量
     int newCapacity = oldCapacity + ((capacityIncrement > 0) ? capacityIncrement : oldCapacity); // 计算新的容量，如果有指定增长那么 + 指定增长，如果没有指定那么当前容量乘以2
     if (newCapacity - minCapacity < 0) // 如果新容量还是不够
         newCapacity = minCapacity; // 使用所需容量为新容量
     if (newCapacity - MAX_ARRAY_SIZE > 0) // 如果新容量超过容量上限
         newCapacity = hugeCapacity(minCapacity);
     elementData = Arrays.copyOf(elementData, newCapacity); // 将原数组的数据拷贝到新的容器里，并替换原数组
 }

 private static int hugeCapacity(int minCapacity) {
     if (minCapacity < 0) // 超出INT最大值则会变为负数，这里抛出内存溢出异常
         throw new OutOfMemoryError();
     return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE; // 所需容量大于上限，那么采用INT最大值，否则采用上限值
 } 

查询栈顶peek()

根据栈顶索引获取栈顶元素，但如果没有一个元素的情况下会抛出空栈异常

 public synchronized E peek() {
     int len = size(); // 当前栈的元素大小
     if (len == 0)  // 空栈抛出异常
         throw new EmptyStackException();
     return elementAt(len - 1); // 获取栈顶元素
 }

 public synchronized E elementAt(int index) {
     if (index >= elementCount) { // 栈顶索引大于等于元素大小表示越界
         throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
     }
     return elementData(index);
 }

 E elementData(int index) {
     return (E) elementData[index]; // 根据数组索引位置获取元素
 }

出栈pop()

出栈只是把栈顶的元素置为null，让GC去回收。出栈之前会先获取栈顶元素，所有如果对空栈出栈，那么会抛出异常

 public synchronized E pop() {
     E       obj;
     int     len = size(); // 获取当前元素大小
     obj = peek(); // 获取栈顶元素
     removeElementAt(len - 1); // 移除栈顶元素
     return obj; // 返回被移除的元素
 }

 public synchronized void removeElementAt(int index) {
     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) {
         System.arraycopy(elementData, index + 1, elementData, index, j); // 这里调用native方法，把被移除的元素之后的元素向前移动一位
     }
     elementCount--; // 元素数量 -1
     elementData[elementCount] = null; // 置为null，让GC去销毁该元素
 }

判空empty()

 public boolean empty() {
     return size() == 0; // 判断元素数量为0
 }

查找元素search()

查找元素的时候从栈顶向下查找，如果有多个那么只匹配最上面的一个，没有则返回-1

 public synchronized int search(Object o) {
     int i = lastIndexOf(o); // 从栈顶向下搜索，如果匹配到则返回自上而下的索引，否则返回-1
     if (i >= 0) {
         return size() - i; // 计算自下而上的索引
     }
     return -1; // 没有找到
 }

 public synchronized int lastIndexOf(Object o) {
     return lastIndexOf(o, elementCount-1); // 索引从栈顶开始
 }

 public synchronized int lastIndexOf(Object o, int index) {
     if (index >= elementCount) // 越界检验
         throw new IndexOutOfBoundsException(index + " >= "+ elementCount);
     if (o == null) { // 如果元素为null
         for (int i = index; i >= 0; i--) // 自栈顶向下遍历
             if (elementData[i]==null) // 如果存在 == null的，返回
                 return i;
     } else { // 元素不为null
         for (int i = index; i >= 0; i--) // 自栈顶向下遍历
             if (o.equals(elementData[i])) // 元素相等的，返回
                 return i;
     }
     return -1; // 没有找到相等的元素
 }