Java 集合：（八） Vector 子类 Stack

一、Stack 概述

　　1、Stack 是栈结构，它继承与 Vector。它的特性是：先进后出（FILO，First In Last Out）或 后进先出（LIFO，Last In First Out）；

　　2、Stack是Vector的子类，比Vector多了几个方法，它的后进先出的特征，就是通过调用这几个方法实现的。

　　3、

　　4、

　　5、

二、Stack 结构

　　1、Stack 类声明

public class Stack<E> extends Vector<E>

　　　　可以发现 Stack 是 Vector 的子类。

　　2、Stack 类继承结构

　　　　

 

　　3、

　　4、

三、Stack 创建

　　1、构造器

　　　　源码：

public Stack() {}

 

　　　　Stack 只提供了一个无参的构造器，但是这里会调用父类的构造器：

public Vector() {
    this(10);
}

　　　　可以发现，在这里创建了一个长度为10的数组。

 

　　2、添加元素

　　　　通过 Stack 的 push() 方法，可以向栈中添加元素，本质还是调用父类 Vector 的 addElement() 方法：

public synchronized void addElement(E obj) {
     modCount++;
     ensureCapacityHelper(elementCount + 1);
     elementData[elementCount++] = obj;
}

 

　　　　可以发现，如果需要进行扩容的话也是调用 vector 中的扩容方式来扩容的，即容量扩容为原来的2倍。

 

　　3、

四、Stack 方法

　　1、方法列表

　　　　

　　2、push(E) 方法

　　  把元素压入栈顶，等价于add(item),这里为了更形象化，单独设计了一个push。

　　　　源码：

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

        return item;
    }
    // 调用 Vector 的 addElement() 方法
    public synchronized void addElement(E obj) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = obj;
    }

 　　　　在JDK9 中：

　　　　

　　　　　然后调用 Vector 中的 add 方法：

　　　　

 

　　3、pop() 方法：弹出栈顶元素

　　　　源码：

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

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

    return obj;
}

// 调用 Vector 的removeElementAt()方法
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);
    }
    elementCount--;
    elementData[elementCount] = null; /* to let gc do its work */
}

 

　　4、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];
}

 

　　5、empty() 方法

　　　　源码：

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

 

　　6、search(Object) 方法：返回的是从栈顶开始计算索引位置的

　　　　源码：

public synchronized int search(Object o) {
    int i = lastIndexOf(o);

    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) {
        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、数组模拟栈一

class ArrayStack {
    private int[] data;   //存储数据
    private int size;    //元素的个数

    //默认容量
    private static final int DEFAULT_CAPACITY = 10;

    ArrayStack() {
        data = new int[DEFAULT_CAPACITY];
    }

    ArrayStack(int capacity) {
        data = new int[capacity];
    }

    //把item压入堆栈顶部
    public void push(int ele) {
        //判断是否需要扩容
        if (size > data.length) {
            data = Arrays.copyOf(data, data.length * 2);
        }
        data[size++] = ele;
    }

    //查看堆栈顶部的对象，但不从堆栈中移除它
    public int peek() {
        if (size == 0) {
            throw new EmptyStackException();
        }
        return data[size-1];  //获取栈顶元素
    }

    //移除堆栈顶部的对象，并作为此函数的值返回该对象
    public int pop() {
        int o = this.peek();       //获取栈顶元素
        size--;                    //减少元素个数
        return o;
    }

    //返回对象在栈中的位置，以 1 为基数，从栈顶开始计算
    public int search(int ele) {
        //顺着放倒着拿（FILO/LIFO）
        for (int i = size - 1; i >=0; i--)
        {
            if (ele == data[i]) {
                return size - i;
            }
        }
        return -1;    //返回栈中不存在该元素
    }

    public int size() {
        return size;
    }

    //测试堆栈是否为空
    public boolean empty() {
        return size == 0;
    }
}

 

　　2、数组模拟栈二

/**
 *  定义一个ArrayStack 表示栈
 */
public class MyArrayStack {
    private int maxSize;    // 栈的大小
    private int[] stack;    // 数组，数组模拟栈，数据就在该数组中
    private int top = -1;   // top 表示栈顶，初始化为 -1

    // 构造器
    public MyArrayStack(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[this.maxSize];
    }

    // 判断栈满
    public boolean isFull() {
        return top == maxSize - 1;
    }

    // 判断栈空
    public boolean isEmpty() {
        return top == -1;
    }

    // 入栈 - push
    public void push(int value) {
        // 先判断栈是否满
        if (isFull()) {
            System.out.println("栈满");
            return;
        }
        top++;
        stack[top] = value;
    }

    // 出栈 - pop,将栈顶的数据返回
    public int pop() {
        // 先判断栈是否空
        if (isEmpty()) {
            // 抛出异常来处理
            throw new RuntimeException("栈空，没有数据··");
        }
        int value = stack[top];
        top--;
        return value;
    }

    // 显示栈的情况[遍历栈]，从栈顶往下显示数据
    public void list() {
        if (isEmpty()) {
            System.out.println("栈空，没有数据~~");
            return;
        }

        for (int i = top; i >= 0; i--) {
            System.out.printf("stack[%d]=%d\n", i, stack[i]);
        }
    }
}