容器-Stack栈容器（五)

容器-Stack栈容器（五）

1. stack栈容器，是Vector的一个子类，他的标准是：出栈的顺序是后进先出（LIFO:Last In First Out）的栈。

2. 通过五个方法对Vector进行扩展。

3. 关于栈容器的五个方法：

   public class StackTest {
       public static void main(String[] args) {
           //实例化栈容器
           Stack<String> stack=new Stack<>();
           //将容器添加到栈容器中，入栈
           stack.push("a");
           stack.push("b");
           stack.push("c");
   
           //判断栈容器是否为空
           System.out.println(stack.empty());
           //查看栈顶元素，但是没有删除
           System.out.println(stack.peek());
           //返回元素在容器中的位置
           System.out.println(stack.search("a"));//因为栈元素从栈顶元素开始算的，所以c:1 b:2 a:3
           //获取栈容器中的元素 ，出栈(是删除元素的)，出栈的顺序是：后进先出
           String p1=stack.pop();
           System.out.println(p1);
           String p2=stack.pop();
           System.out.println(p2);
           String p3=stack.pop();
           System.out.println(p3);
           
       }
   }
   
   

4. 匹配符号的对称性:String str="…{…[…(…)…]…}…(…)…[…]…(.)";

• 用修正法
• 先拆字符串的字符，先把一些系列左括号的问题判断出来，如果匹配就压入栈中，假设都匹配成功，就结束了。
• 但是，我们如果用入栈的方式，没匹配成功，我们就要用修正法，判断那些会失败的问题，再通过判断，用出栈的方法，在进行匹配，如果匹配还是失败，那就是这个字符串的对称是无法匹配成功的。

import java.util.Stack;

public class StackTest {
    public static void main(String[] args) {
        //实例化栈容器
        Stack<String> stack=new Stack<>();
        //将容器添加到栈容器中，入栈
        stack.push("a");
        stack.push("b");
        stack.push("c");

        //判断栈容器是否为空
        System.out.println(stack.empty());
        //查看栈顶元素，但是没有删除
        System.out.println(stack.peek());
        //返回元素在容器中的位置
        System.out.println(stack.search("a"));//因为栈元素从栈顶元素开始算的，所以c:1 b:2 a:3
        //获取栈容器中的元素 ，出栈(是删除元素的)，出栈的顺序是：后进先出
        String p1=stack.pop();
        System.out.println(p1);
        String p2=stack.pop();
        System.out.println(p2);
        String p3=stack.pop();
        System.out.println(p3);
        System.out.println("---------------------");
        StackTest stackTest=new StackTest();
        stackTest.symmetry();

    }

    //匹配符号的对称性
    public void symmetry(){
        String str="...{....[....(....)...]....}..(....)..[...]..(.)";
        //实例化Stack
        Stack<String> stack=new Stack<>();
        //假设修正法
        boolean flag =true;
        //拆分字符串获取字符
        for (int i=0;i<str.length();i++){
            char c=str.charAt(i);
            if (c=='{'){
                stack.push("}");
            }
            if (c=='['){
                stack.push("]");
            }
            if (c=='('){
                stack.push(")");
            }

            //判断符号是否匹配
            if (c=='}'||c==']'||c==')'){
                if (stack.empty()){//假设栈里面为空了，你都拆到只剩下右括号了，还没有找到匹配的，证明是缺失了左括号
                    //修正处理
                    flag=false;
                    break;//不用再去判断了，肯定是缺失了左括号，跳出循环
                }
                String x=stack.pop();//假设栈里面不为空，说明还有元素，我把元素取出来
                if (x.charAt(0)!=c){//因为取出来的是字符串，我要把它变成字符才能和c做比较，所以用charAt(0)
                    //修正处理      //假设取出来的元素跟c是不匹配的，说明就是匹配失败了
                    flag=false;
                    break;
                }
            }
        }
        if (!stack.empty()){//当所有的元素都匹配完了，栈还是不为空，说明还只剩下一个左括号或者一个右括号
            flag=false;     //肯定是匹配失败的
        }
        System.out.println(flag);
    }
}