java基于数组初步实现栈

话不多说，先上代码

栈

栈，先进后出

Socket接口

首先我们先定义一个Socket接口，给出栈必须的几个方法，分别是：

• 判断栈是否为空 isEmpty()
• 获取栈中元素数目 getSize()
• 入栈 push(Object object)
• 出栈 pop()
• 获取栈顶元素 top()

public interface Stack {

    /**
     * 判断栈是否为空
     * @return boolean
     * @return
     * 时间：2018年4月26日
     */
    public boolean isEmpty();

    /**
     * 返回栈中元素数量
     * @return int
     * @return
     * 时间：2018年4月26日
     */
    public int getSize();

    /**
     * 压栈
     * @return void
     * @param object
     * 时间：2018年4月26日
     * @throws Exception 
     */
    public void push(Object object) throws Exception;

    /**
     * 出栈
     * @return Object
     * @return
     * 时间：2018年4月26日
     * @throws Exception 
     */
    public Object pop() throws Exception;

    /**
     * 获取栈顶元素
     * @return Object
     * @return
     * 时间：2018年4月26日
     * @throws Exception 
     */
    public Object top() throws Exception;

}

ArraySocket实现类

然后，我们创建ArraySocket类，实现Stack接口，并对Stack接口中的方法进行重写。
先看代码

public class ArrayStack implements Stack {

    /**
     * 数组栈默认容量
     */
    private static final int CAPACITY = 1024;

    /**
     * 数组栈实际容量
     */
    private int capacity;

    /**
     * 数组栈
     */
    private Object[] s;

    /**
     * 栈顶指针，-1代表栈空
     */
    private int top = -1;

    /**
     * 无参构造，创建默认容量大小的数组栈
     */
    public ArrayStack() {
        this(CAPACITY);
    }

    /**
     * 创建指定容量的数组栈
     * 
     * @param capacity
     */
    public ArrayStack(int capacity) {
        this.capacity = capacity;
        s = new Object[capacity];
    }

    @Override
    public boolean isEmpty() {
        return -1 == top ? true : false;
    }

    @Override
    public int getSize() {
        return top + 1;
    }

    @Override
    public void push(Object object) throws Exception {
        //判断容量是否达上限
        if (CAPACITY == top) {
            throw new Exception("沾溢出");
        }
        s[++top] = object;
    }

    @Override
    public Object pop() throws Exception {
        // 判断栈是否为空
        if (isEmpty()) {
            throw new Exception("栈空");
        }
        // 返回栈顶元素
        Object object = s[top];
        //移除栈顶元素，方便垃圾回收
        s[top--] = null;
        return object;
    }

    @Override
    public Object top() throws Exception {
        if (isEmpty()) {
            throw new Exception("栈空");
        }
        return s[top];
    }

}

在这里，我们依次来讲解实现原理。

1. 我们是基于数组实现的栈，所以必不可少的要先定义一个数组s。考虑到封装性，我们将数组私有化。并保证当创建栈对象时，栈对象中的数组被分配空间。
2. 静态常量CAPACITY，默认1024。私有变量capacity。当调用有参构造的时候，创建capacity大小的数组。当调用无参构造时，创建CAPACITY默认大小的数组。
3. 创建栈顶指针top,考虑到数组起始下标为0，所以top为-1
4. 重写isEmpty()方法，直接对栈顶指针top进行判断，当top=-1时，栈必定为空
5. 重写getSize()方法，每当栈内压栈一个元素时，top+1，所以top+1为栈中元素数目
6. 重写push(Object object)方法，首先判断栈是否满了，根据top是否等于capacity判断；若栈未满，将元素赋值给s[top]，并将栈顶指针+1
7. 重写pop()，首先判断栈空；若栈不为空，将s[top]返回，并将其置为空
8. 重写top()，首先判断栈空；若栈不为空，将s[top]返回

测试类

public class Test {

    public static void main(String[] args) throws Exception {
        Stack stack = new ArrayStack();
        stack.push(6);
        stack.push(5);
        stack.push(5);
        stack.push(5);
        stack.push(5);
        System.out.println(stack.pop());;
        System.out.println(stack.top());;
        System.out.println(stack.getSize());;
    }
}