最粗暴的方法实现一个栈

对于栈和队列是一个很简单的知识，用的感觉也不是很多，但是，我们仍然的学习！！加油！！在实现最简单的栈之前，我们需要简单了解一下栈是什么？？

栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、 入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 原文链接为： https://baike.baidu.com/item/%E6%A0%88/12808149?fr=aladdin

栈stack是以“先进后出”模式入栈，出栈的！比如：子弹的弹夹

注意：如果我们想在上述的数据中，拿到12，则需要将12上面的全部数据都拿走，否则是拿不走12的！！先进后出模式！

另一种用法：如果你要存储的数据支持先进后出模式，则就需要用到栈stack这种数据结构！

下面我们就栈的几个基础的：入栈，压栈，得到栈顶元素（偷看），来进行讲解一下基础的语法！！

import java.util.Stack;
 
public class Tset {
    public static void main(String[] args) {
        Stack<Integer> stack =new Stack<>();
        //入栈
        stack.push(12);
        stack.push(23);
        stack.push(34);
        stack.push(45);
        System.out.println("获取此时栈中的元素个数："+stack.size());
 
        //出栈
        System.out.println("出栈");
        Integer a=stack.pop();
        System.out.println(a);
 
        Integer b=stack.pop();
        System.out.println(b);
        System.out.println("获取此时栈中的元素个数："+stack.size());
 
 
        //获取栈顶元素（偷看）
        System.out.println("获取栈顶元素（偷看）");
        Integer c=stack.peek();
        System.out.println(c);
 
        Integer d=stack.peek();
        System.out.println(d);
        System.out.println("获取此时栈中的元素个数："+stack.size());
 
    }
}

上述代码的运行结果为：

对于该入栈时候的顺序为：12，23，34，45

经过上述的铺垫，那么，我们就深入研究一下;模拟实现一个栈吧！！以数组的形式实现一个栈！！

实现一个栈的准备阶段：必须定义一个栈：

public class MyStack {
    public int[] elem;
    public int usedSize;
    
    public MyStack(){
        //构造方法，定义数组的长度为10
        this.elem=new int[10];
    }  
}

有了上述的代码，那么我们就可以进行：压栈！！

压栈，（放入数据）

   //压栈（放入数据）
    public void push(int val){
        if (isFull()){
            //判断是否满了！
            //扩容
            elem= Arrays.copyOf(elem,2*elem.length);
        }
        elem[usedSize]=val;
        usedSize++;
    }
    
    public boolean isFull(){
        return usedSize== elem.length;
    }

首先先对需要放入到数据判断是否需要扩容处理！在上述的代码中，进行了2倍扩容！其实要想放入数据，这个代码很简单！！

出栈（获取栈顶元素）

 
    //出栈（将栈顶的元素出栈并返回）
    public int pop(){
        if(isEmpty()){
            throw new EmptyException("栈是空的！");
         //自定义异常
        }
        int val=elem[usedSize-1];
        usedSize--;
        return val;
    }
    
    public boolean isEmpty(){
        return usedSize==0;
    }

对于该段代码，实际上并没有删除元素，但是通过usedSize-1，或者通过usedSize--，不再记录该栈顶元素，所以可以理解为删除了

获取栈顶元素（偷看）

   //获取栈顶元素（偷看）
    public int peek(){
        if (isEmpty()){
            throw new EmptyException("栈是空的！");
        }
        return elem[usedSize-1];
    }

切记，在最后返回的时候，千万不能使用usedSize--，原因在于：peek是模仿的偷看！！如果使用usedSize--就会使得usedSize的数据发生改变！！

抛异常的代码：

public class EmptyException extends RuntimeException {
    public EmptyException() {
    }
 
    public EmptyException(String message) {
        super(message);
    }
}

抛异常的代码：也就简简单单的两个构造方法！！

测试用列：

public class Test {
    public static void main(String[] args){
        MyStack stack =new MyStack();
        //压栈（放入数据）
        stack.push(12);
        stack.push(23);
        stack.push(34);
        stack.push(45);
 
        //出栈
        Integer a=stack.pop();
        System.out.println(a);//45
        //此时栈中还有，12，23，34
        Integer b=stack.pop();
        System.out.println(b);
        //此时栈中还有,12,23
        System.out.println(stack.isEmpty());
    }
}

上述便是全部的代码！！到目前位置，我们遍实现了一个栈！！简单而又粗暴！！

注意区分：进栈过程可以出栈（边进边出）考试常见！！