使用Array实现栈

废话不多说先看代码：

class ArrayStack {
    private static final int MAX_SIZE = 1000;
    private int top;
    private int[] stackArray;

    public ArrayStack() {
        this.top = -1;
        this.stackArray = new int[MAX_SIZE];
    }

    // 入栈操作
    public void push(int data) {
        if (top >= MAX_SIZE - 1) {
            System.out.println("Stack overflow");
            return;
        }

        stackArray[++top] = data;
    }

    // 出栈操作
    public int pop() {
        if (isEmpty()) {
            System.out.println("Stack is empty");
            return -1; // 返回一个特定的值表示栈为空
        }

        return stackArray[top--];
    }

    // 查看栈顶元素
    public int peek() {
        if (isEmpty()) {
            System.out.println("Stack is empty");
            return -1; // 返回一个特定的值表示栈为空
        }

        return stackArray[top];
    }

    // 检查栈是否为空
    public boolean isEmpty() {
        return top == -1;
    }

    // 获取栈的大小
    public int getSize() {
        return top + 1;
    }
}

// 示例使用
public class Main {
    public static void main(String[] args) {
        ArrayStack stack = new ArrayStack();
        stack.push(1);
        stack.push(2);
        stack.push(3);

        System.out.println("Top of the stack: " + stack.peek()); // 输出: 3
        System.out.println("Stack size: " + stack.getSize());    // 输出: 3

        System.out.println("Pop from stack: " + stack.pop());     // 输出: 3
        System.out.println("Top of the stack after pop: " + stack.peek()); // 输出: 2
        System.out.println("Stack size after pop: " + stack.getSize());    // 输出: 2
    }
}

栈是什么呢？栈是一种桶状的容器，先进后出

还有一个自动扩容的版本：

package pro;

public class ArrayStack {
    private int top ;
    private  int MAX_SIZE= 10;
    private int[]arrstack;

    public ArrayStack(){
        //初始化
        this.top=-1;
        this.arrstack = new int[MAX_SIZE];
    }
    public void push(int i){
        if (top+1>=MAX_SIZE){
         //扩容
          getDilatation();
        }
        arrstack[++top]=i;
    }

    public int pop(){
         if (isEmpty()){
             System.out.println("没有数据");
             return -1;
         }
         return arrstack[top--];
    }
    public boolean isEmpty(){
        boolean flag = top == -1;
        return flag;
    }
    //扩容
    private void getDilatation(){
        this.MAX_SIZE = MAX_SIZE*2;
        int[] newarr =new int[MAX_SIZE];
        System.arraycopy(arrstack,0,newarr,0,arrstack.length);
        this.arrstack = newarr;
    }
}

扩容的容器大小是以前的2倍，扩容原理实际上是创建一个新的数组将老数组的数据复制到新数组中，System.arraycopy(arrstack,0,newarr,0,arrstack.length);

System.arraycopy 是 Java 中用于数组复制的底层方法，其实现通常由 Java 虚拟机提供，因此它的具体实现可能会因 JVM 不同而有所差异。在大多数 JVM 中，System.arraycopy 的实现是通过本地方法（native method）来完成的，即通过调用底层的操作系统或者硬件指令来执行数组复制的操作，从而提高效率。

这是他的源码有好奇的小伙伴可以研究一下，众所周知Java的底层是用c实现的所以我就不多说了

JVM_ENTRY(void, JVM_SystemArraycopy(JNIEnv* env, jclass ignored, jobject src, jint src_pos, jobject dest, jint dest_pos, jint length))

  // 省略了部分代码...

  if (src->is_primitive_array() && dest->is_primitive_array()) {
    // 如果是基本类型数组，使用相应的复制操作
    arraycopy_unchecked(src, src_pos, dest, dest_pos, length, CHECK);
  } else {
    // 如果是对象数组，使用 Object.clone 方法
    arraycopy_unchecked_objArray(src, src_pos, dest, dest_pos, length, CHECK);
  }

JVM_END