集合的理解

1、栈，队列在集合中的运用

栈，先进后出，，但是注意便利的时候，还是按照先进先出的概念便利输出

     在java中我们运用运用到栈的对象  ~~~~~~ statck  通过 push() 和 pop() 方法。

                                stack介绍 继承的父类是 Vector  vector继承的接口是List，而 vector是线程安全的，所以自然 statck也是线程安全的，所谓线程安全，便是在这个类的方法上  synchronized 上锁操作，及对这个方法的操作。部分代码展示

          public synchronized int capacity() {
        return elementData.length;
    }

    /**
     * Returns the number of components in this vector.
     *
     * @return  the number of components in this vector
     */
    public synchronized int size() {
        return elementCount;
    }

    /**
     * Tests if this vector has no components.
     *
     * @return  {@code true} if and only if this vector has
     *          no components, that is, its size is zero;
     *          {@code false} otherwise.
     */
    public synchronized boolean isEmpty() {
        return elementCount == 0;
    }

队列 ，先进先出，虽然说我们一般的遍历也可以实现这个功能，但是队列仍然有它的作用，如我们要删除第一个元素，并返回这个删除的元素，那我们最简单的操作，莫过于选择队列的   pop（）方法

  在Java中运用 队列的操作对象有   LinkedList  集合   他不是线程安全的，继承的接口是 List

下面表示的是 运用 栈和队列实现  slr（1）文法判断

package jsu.java.compile;

import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Scanner;
import java.util.Stack;

public class lr {
    private static   Map<String ,String>map=new HashMap<String ,String>();
    private static   Map<Integer ,String[]>make=new HashMap<Integer ,String[]>();
    private static String array[][]={{"S'","S"},{"S","AB"},{"A","aBa"},{"A",""},{"B","bAb"},{"B",""}};
        static{
    
        map.put("0a","S3" );
        map.put("0b","r3" );
        map.put("0#","r3" );
        map.put("0S","1" );
        map.put("0A","2" );
    
        map.put("1#","acc" );
        
        map.put("2a","r5" );
        map.put("2b","S5" );
        map.put("2#","r5" );
        map.put("2B","4" );
        
        map.put("3a","r5" );
        map.put("3b","S5" );
        map.put("3#","r5" );
        map.put("3B","6" );
        
    
        map.put("4#","r1" );
        
        
        map.put("5a","S3" );
        map.put("5b","r3" );
        map.put("5#","r3" );
        map.put("5A","7" );
        
        map.put("6a","S8" );
        
    
        map.put("7b","S9" );
        
        map.put("8#","r2" );
        map.put("8b","r2" );
        
        map.put("9","r4" );
        map.put("9#","r4" );
        
        for(int t=0;t<array.length;t++){
            make.put(t, array[t]);
        }
    }
    
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        String str=scanner.next();
        if(str.endsWith("#")){
            for(int i=0;i<str.length()-1;i++){
                if(str.charAt(i)=='a' || str.charAt(i)=='b'  ){

                }
                else{
                    System.out.println("输入不合法");
                    System.exit(0);
                
                }
            }
            System.out.println("步骤 \t状态栈\t 符号栈\t 输入串\t动作 ");
            contro(str);
        }
        else{
            System.out.println("结尾以#号");
        }
    }

    private static void contro(String str) {
        Stack<Character>state=new Stack<Character>();
        state.add('0');
        
        Stack<Character>symble=new Stack<Character>();
        symble.add('#');
        LinkedList<Character>input=new LinkedList<Character>();//队列，先进先出

        for(int j=0;j<str.length();j++){
            input.add(str.charAt(j));
        }
        int i=0;
        while(true){
            
            
            System.out.print(i+1);
            i++;
            System.out.print("\t");
            //System.out.print(state.toString());
            for(Character c:state){  //便利是 按照先进先出的原则输出
                System.out.print(c);
            }
            System.out.print("\t");
            
            for(Character c:symble){  
                System.out.print(c); //便利是 按照先进先出的原则输出
            }
            System.out.print("\t");
            
            for(Character c:input){  //便利是 按照先进先出的原则输出
                System.out.print(c);
            }
            System.out.print("\t");
            
            Character pop = state.get(state.size()-1);
            Character charAt = input.get(0);
            String stateInput=pop.toString()+charAt;
            String result=null;
            try {
                 result = map.get(stateInput);
                
            
            
        
            if(result.equals("acc")){
                System.out.println("成功");
                break;
            }
            
             if(result !=null &&result.length()>0){
                if(result.charAt(0)=='S'){
                    System.out.println("移进");
                    state.push(result.charAt(1));
                    Character pop2 = input.pop();
                    symble.push(pop2);
                    
                }
                else{
                    Character two=result.charAt(1);
                    int two1=Integer.parseInt(two.toString());
                    String arr[]=make.get(two1);
                    int len=arr[1].length();
                    for(int ji=0;ji<len;ji++){
                        state.pop();   //利用栈的先进后出
                        symble.pop();   //利用栈的先进后出
                        
                    }
                    symble.push(arr[0].charAt(0));
                
                    Character in = state.get(state.size()-1);
                    String str1=in.toString()+arr[0].charAt(0);
                    state.push((map.get(str1).charAt(0)));
                    System.out.println("规约");
                }
            }
            else{
                System.out.println("报错");
            }
            }
                catch (Exception e) {
                     System.out.println("报错");
                     System.exit(0);
                }
        }
        
    }
}