【问题标题】:How to use iterator in nested arraylist如何在嵌套数组列表中使用迭代器
【发布时间】:2013-10-25 06:37:54
【问题描述】:

我正在尝试构建一个具有特殊搜索目的的 NFA,这与正则表达式完全不同。状态有以下格式

class State implements List{
//GLOBAL DATA

static int depth;

//STATE VALUES
String stateName;
ArrayList<String> label = new ArrayList<>(); //Label for states

//LINKS TO OTHER STATES
boolean finalState;
ArrayList<State> nextState ; // Link with multiple next states

State preState;             // previous state

public State()
{

    stateName = "";
    finalState = true;
    nextState = new ArrayList<>();

}
public void addlabel(String lbl)
{
    if(!this.label.contains(lbl))
        this.label.add(lbl);
}
public State(String state, String lbl)
{
    this.stateName = state;
    if(!this.label.contains(lbl))
       this.label.add(lbl);
    depth++;

}

public State(String state, String lbl, boolean fstate)
{

    this.stateName = state;
    this.label.add(lbl);
    this.finalState = fstate;

    this.nextState = new ArrayList<>();
}
void displayState()
{

    System.out.print(this.stateName+" --> ");
    for(Iterator<String> it = label.iterator(); it.hasNext();)
    {
        System.out.print(it.next()+" , ");
    }
    System.out.println("\nNo of States : "+State.depth);
}

接下来,NFA类是

public class NFA
{

static final String[] STATES= {"A","B","C","D","E","F","G","H","I","J","K","L","M"
                            ,"N","O","P","Q","R","S","T","U","V","W","X","Y","Z"};
State startState;
State currentState;
static int level;
public NFA()
{
    startState = new State();
    startState = null;
    currentState = new State();
    currentState = null;
    startState = currentState;
}

/**
 *
 * @param st
 */
NFA(State startstate)
{
    startState = new State();
    startState = startstate;
    currentState = new State();
    currentState = null;
    currentState = startState ; // To show that their is only one element in NFA
}

boolean insertState(State newState)
{

    newState.nextState = new ArrayList<>();
    if(currentState == null && startState == null ) //if empty NFA
    {
        newState.preState = null;
        startState = newState;
        currentState = newState;
        State.depth = 0;
        return true;
    }
    else 
    {
        if(!Exist(newState.stateName))//Exist is used to check for duplicates
        {

                newState.preState = currentState ;
                currentState.nextState.add(newState);
                currentState = newState;
                State.depth++;
                return true;
        }
    }
    return false;
}

boolean insertState(State newState, String label)
{
        newState.label.add(label);
        newState.nextState = null;
        newState.preState = null;

    if(currentState == null && startState == null)
    {
        startState = newState;
        currentState = newState;
        State.depth = 0;
       return true; 
    }
    else 
    {
        if(!Exist(newState.stateName))
        {

                newState.preState = currentState;
                currentState.nextState.add(newState);
                currentState = newState;
                State.depth++;
                return true;

        }
        else
        {
            ///code goes here

        }
    }
    return false;
}

void markFinal(State s)
{
    s.finalState = true;
}
void unmarkFinal(State s)
{
    s.finalState = false;
}

boolean Exist(String s)
{
    State temp = startState;
    if(startState.stateName.equals(s))
        return true;
    Iterator<State> it = temp.nextState.iterator();
    while(it.hasNext())
    {

        Iterator<State> i  = it ;//startState.nextState.iterator();

           {
            while(i.hasNext())
            {

                if(i.next().stateName.equals(s))
                    return true;

            }


        }
        //else
          //  return false;
    }
    return false;
}
void displayNfa()
{
    State st = startState;
    if(startState == null && currentState == null)
    {
        System.out.println("The NFA is empty");
    }
    else
    {

        while(st != null)
        {
            if(!st.nextState.isEmpty())
            {
                Iterator<State> it = st.nextState.iterator();

                do
                {
                    st.displayState();
                    st = it.next();
                }while(it.hasNext());
            }
            else
            {
                st = null;
            }
        }
    }
    System.out.println();
}


/**
 * @param args the command line arguments
 */

/**
 *
 * @param args the command line arguments
 */
public static void main(String[] args) 
{
    // TODO code application logic here
    NFA l = new NFA();
    State s = new State("A11", "a",false);

    NFA ll = new NFA(s);
    s = new State("A111", "a",false);
    ll.insertState(s);
    ll.insertState(new State("A1","0"));
    ll.insertState(new State("A1111","0"));

    ll.displayNfa();
    int j = 1;
    for(int i = 0 ; i < 2 ; i++)
    {

        int rand = (int) (Math.random()* 10);
        State st = new State(STATES[rand],String.valueOf(i), false);
        if(l.insertState(st))
        {
            System.out.println(j+" : " + STATES[rand]+" and "+String.valueOf(i)+ " inserted");
            j++;
        }
    }
        l.displayNfa();
        System.out.println("No of states inserted : "+ j--);
}

我想做以下事情

  1. 这个程序总是跳过显示最后一个状态,即如果插入了 10 个状态,它将只显示 9 个。
  2. 在 exists() 方法中,我使用了两个迭代器,但我不知道它为什么起作用
  3. 在处理迭代器时,我不知道如何搜索现有的类名。
  4. 我应该如何跟踪当前状态,以深度优先顺序正确地遍历 nextState 列表、标签列表。
  5. 如何插入唯一状态,即如果状态“A”被插入一次,则不应再次插入(exist 方法不起作用)

最好的问候

【问题讨论】:

    标签: java iterator nested-lists


    【解决方案1】:

    用map结构代替嵌套List解决

         State find(State state)
    {
        LinkedList<State> list = new LinkedList<>();
        list.push(null);
        State temp = null;
        State ptr = startState;
        if(ptr.stateName.equals(state.stateName))
            temp  = ptr;
        while(ptr != null && temp != ptr)
        {
            for(State nxtState :ptr.nextState.keySet())
            {
                if(state.stateName == null ? nxtState.stateName == null :     state.stateName.equals(nxtState.stateName))
                {
                    return nxtState;
                    //break;
                }
                else
                {
                    list.push(nxtState);
                }
            }
            ptr = list.pop();
        }
        return temp;
    }
    boolean insertState(State stateA,  String label, State stateB)
    {
    
        ArrayList<String> lbls = new ArrayList<>();
        lbls.add(label);
        stateA = find(stateA);
        if(stateA != null)
        {
            stateB.nextState = new HashMap<>();
            stateB.preState.put(stateA,lbls);
            stateA.nextState.put(stateB, lbls);
            currentState = stateB;
            State.depth++ ;
            return true; 
        }
        else
        {
            System.err.println("State does not exist : somthing wrong with state input or NFA creation");
            return false;
        }
    
    }
    
    void displayNfa()
    {
        LinkedList<State> stateForIteration = new LinkedList<>();
        State ptr = startState;
        if(ptr == null)
        {
            System.out.println("The NFA is empty");
        }
        else
        {
            System.out.print(ptr);
    
            while(ptr!= null)
            {
                if(!ptr.nextState.isEmpty())
                {
                    for(State key : ptr.nextState.keySet())
                    {
                      System.out.print(key+ "  ");
                       stateForIteration.push(key);
                       }
                    ptr = stateForIteration.pop();
                }
                else
                {
                    ptr = null;
                }
            }
        }
        System.out.println();
    }
    
    /**
     *
     * @param args the command line arguments
     */
    void insertRule(String[] rule)
    {
    for(int i = 0; i < rule.length - 2; i=i+2)
    {
        this.insertState(new State(rule[i]), rule[i+1], new State(rule[i+2]));
    }
    }
    public static void main(String[] args) 
    {
    
        State strtState = new State("A");
        NFA ll = new NFA(strtState);
        String[][] data = {
            {"A","0","B","1","C","1","D","1","C0"},
            {"A","0","B","1","C","1","D","1","C0"},
            {"A","0","C","1","D","1","C0"},
            {"A","0","D","1","C0"}
            //{"A","0","B","1","C","1","D","1","C0"},
          };
    
        ll.insertRule(data[0]);
        ll.insertRule(data[1]);
        ll.insertRule(data[2]);
        ll.insertRule(data[3]);
    
        ll.displayNfa();
    }
    

    “状态”类是

    class State implements List{
    
    static int depth;
    
    String stateName;
    
    //LINKS TO OTHER STATES
    Map<State, ArrayList<String>> nextState ; // to link with multiple states
    Map<State, ArrayList<String>> preState;             // previous state
    
    public State()
    {
        stateName = "";
        nextState = new HashMap<>();
        preState = new HashMap<>();
    }
    public State(String StName)
    {        
        stateName = StName;
        nextState = new HashMap<>();
        preState = new HashMap<>();
    }
    
    @Override 
    public String toString()
    {
        String temp = " "+this.stateName;
        for(State key : this.nextState.keySet())
        {
            temp = (temp + "  ");
            for(String lbl : this.nextState.get(key))
            {
                temp = (temp + lbl);
            }
                temp = temp + "  "+key.stateName+ "\n";       
        } 
        return temp;
    
    }
    @Override
    public int hashCode() {
        return 1;
    }
    
    @Override
    public boolean equals(Object obj) {
    
        if (obj instanceof State) 
        {
            //id comparison
            State st = (State)obj;
    
            if(!(this.stateName == null) && (!(st.stateName == null)))
                return (this.stateName.equals(st.stateName));
        }
        return false;
    }
    

    输出是

    A  0  D
       0  C
       0  B
    D  1  C0
       C  1  D
       B  1  C
       C  1  D
       D  1  C0
    

    【讨论】:

      猜你喜欢
      • 2013-03-21
      • 2013-05-11
      • 2015-10-17
      • 2015-05-26
      • 1970-01-01
      • 2016-05-16
      • 2011-10-14
      • 1970-01-01
      相关资源
      最近更新 更多