栈也是一种线性表结构，相较于数组，栈对应的操作是数组的子集，我们只要实现从一端添加元素，并从这个一端取出元素，这一端我们称呼它为栈顶，正是由于这种结构，它具有“后入先出”（LIFO : Last In First Out ）的特性。利用这种特性，可以为我们解决掉计算机世界中的很多应用场景遇到的特殊问题，比如：

•         编辑器集成的Undo撤销操作，我们可以在每次编辑文本的时候，记录一个快照到栈中，当你需要unDo操作时，出栈即可。
•         另一种常用的场景就是程序调用系统栈执行子函数调用的例子。比如Go语言的函数调用的时候，goroutine 会创建一个轻量的线程，在一个栈中创建栈帧，当我们遇到在main方法体中调用子方法时，就会终止当前活动栈帧（active frame），并记录当前代码的执行位置，压入另一个栈帧作为活动栈帧 ，当活动栈帧运行完方法后，就会出栈，回到上次外面的函数调用位置。举例说明  ↓

        func A(){

             B() // 第66行，记作B66

        }

        func B(){

             C()  //第88行,记作C88

        }

        A66 压入栈 --> B88压入栈 ->C执行完了，计算机蒙圈了 -->然后查看栈顶元素B88 -->找到人生目标了，又继续执行B88 ，等B88执行完出栈 --->计算机蒙圈了，就要查看系统栈，发现栈顶元素是A66时 --> 继续执行A66  执行完了，又蒙圈了 -->就来查看栈顶元素，发现栈中没有元素了。至此就全部执行完了。

        利用前面的动态数组，实现属于自己的一个栈。同样看一下JDK的栈定义，我们的实现尽量向JDK的定义的栈的语言意义上靠近。参考后，代码如下：

package com.company.array;

public interface Stack<E> {

    E push(E item);

    E pop();

    E peek();

    boolean empty();

    int search(Object o);

}

    int search(Object o); 查找这个元素和栈顶的距离，这个貌似用不上，我们就先返回0。

        根据要求设计出属于我们自己的栈：

package com.company.array;

public class MyStack<E> implements Stack<E>{

    private DynamicArray<E> dynamicArray = new DynamicArray<>();

    @Override
    public E push(E item) {
        dynamicArray.addLast(item);
        return item;
    }

    @Override
    public E pop() {
        E remove = dynamicArray.remove(dynamicArray.getSize() - 1);
        return remove;
    }

    @Override
    public E peek() {
        return dynamicArray.get(dynamicArray.getSize() - 1);
    }

    @Override
    public boolean empty() {
        return dynamicArray.getSize() == 0 ;
    }

    @Override
    public int search(Object o) {
        return 0;
    }

    
}

        解决Leedcode 上的一个问题：

         代码参考：

package com.company.array.queue;


public class CharacterIsValid {
        // () or  [] {} () 匹配 。leedcode
    public static boolean isValid(String s){

        MyStack<Character> stack = new MyStack<>();

        for(int i = 0 ;i<s.length();i++){
            char c = s.charAt(i);

            if(c == '(' || c== '[' || c== '{' ){
                stack.push(c);
            }else {
                    Character pop = stack.pop();
                if(c==')' && pop !='('){
                    return false;
                }
                if(c=='}' && pop !='{'){
                    return false;
                }
                if(c==']' && pop !='['){
                    return false;
                }

            }
        }

        //只有栈里的，全部匹配完毕，才能算真的符合情况。有元素，没得匹配，pop不出去的情况，也算无效。
        return  stack.empty();
    }


    public static void main(String[] args) {
        String s = "({}[])";
        boolean valid = isValid(s);
        System.out.println(valid);

    }
}

        栈在计算机中是一个很重要的线性表，可以利用数组实现也可以利用链表实现，下面我们将开启新的一篇来介绍一下链表的相关知识和具体实现。

        下一篇见，加油！