栈源码分析

栈底层实现是一个数组，可以做到先进后出原则。入栈和出栈都操作栈顶元素

package stack.init;

public class MyStack {
    /**
     * 栈最大长度
     */
    private int size;

    /**
     * 栈底层实现 数组
     */
    private int[] arrays;

    /**
     * 临时变量指向 栈顶元素
     */
    private int top;

    /**
     * 默认初始化
     */
    public MyStack() {
        size = 10;
        arrays = new int[size];
        top = -1;
    }

    /**
     * 自定义初始化
     *
     * @param size
     */
    public MyStack(int size) {
        if (size <= 0) {
            throw new IllegalArgumentException("初始容量不能为" + size);
        }
        this.size = size;
        arrays = new int[size];
        top = -1;
    }

    /**
     * 判断栈是否为空
     *
     * @return
     */
    public boolean isEmpty() {
        if (top == -1) {
            return true;
        }
        return false;
    }

    /**
     * 判断栈是否已满
     *
     * @return
     */
    public boolean isFull() {
        if (top == size - 1) {
            return true;
        }
        return false;
    }

    /**
     * 向栈顶插入元素
     *
     * @param value
     */
    public void push(int value) {
        if (isFull()) { // 栈已满
            // 自动扩容
        } else {
            // 将元素插入栈顶
            top++;
            arrays[top] = value;
        }

    }

    /**
     * 访问栈顶元素
     *
     * @return
     */
    public int peek() {
        if (top == -1) { // 空栈
            throw new IndexOutOfBoundsException("栈为空");
        }
        // 获取栈顶元素
        return arrays[top];
    }

    /**
     * 弹出栈顶元素
     *
     * @return
     */
    public int pop() {
        int size = peek();
        remove(top);
        return size;
    }

    /**
     * 删除栈顶元素
     *
     * @return
     */
    public void remove(int top) {
        arrays[top] = -1;
        this.top--;
    }
    
}

测试类

import stack.init.MyStack;

import java.util.Stack;

public class Test {

    /**
     * 栈初始化
     */
    public void myStack(){
        // 1. 初始化 自动扩容
        MyStack myStack = new MyStack();
        // 2. 判断栈是否为空
        System.out.println("栈是否为空：" + myStack.isEmpty());
        // 3. 判断栈是否满
        System.out.println("栈是否满：" + myStack.isFull());
        // 4. 向栈中添加元素
        myStack.push(1);
        myStack.push(2);
        myStack.push(3);
        myStack.push(4);
        myStack.push(5);
        myStack.push(6);
        myStack.push(7);
        myStack.push(8);
        myStack.push(9);
        myStack.push(10);
        // 5. 访问栈顶元素
        System.out.println(myStack.peek());
        System.out.println(myStack.peek());
        // 6. 弹出栈顶元素
        System.out.println(myStack.pop());
        System.out.println(myStack.pop());

    }

    public static void main(String[] args) {
        Test test = new Test();
        test.myStack();
    }
}

测试结果

栈是否为空：true
栈是否满：false
10
10
10
9