正则表达式转DFA

JAVA实现的正则表达式转换成DFA，并将DFA用Graph画出，画图须安装Graph。

import java.io.File;
import java.util.*;
import java.util.concurrent.linkedBlockingQueue;

public class DFA {

    char[][] g;
    int size;
    int sta;
    ArrayList ends;//终态节点
    char Njump;
    Set M;
    Map setMap;
    Set setSet;
    ArrayList edges;

    public DFA（NFA nfa） {
        g = nfa.getG（）;
        size = nfa.getSize（）;
        sta = nfa.getSta（）;
        Njump = nfa.getNjump（）;
        M = new HashSet（）;
        ArrayList nedges = nfa.getEdges（）;
        for （Edge edge : nedges） {
            char x = edge.getStr（）;
            if （x != Njump）
                M.add（x）;
        }
        setSet = new HashSet（）;
        setMap = new HashMap（）;
        setEdges（）;
        setEnds（nfa.getEnd（））;


    }

    public void outSet（） {
        for （object x : setSet） {

            for （object i : （Set） x） {
                System.out.print（（int） i + “ “）;
            }
            System.out.println（“/“ + setMap.get（x））;
        }
    }

    //x-m-set //move（x，m）
    private Set move（Set x char m） {
        Set set = new HashSet（）;
        for （object i : x） {
            for （int j = 0; j < size; j++） {
                if （g[（int） i][j] == m） {
                    set.add（j）;
                }
            }
        }
        return set;
    }

    //ε-closure{x}->set
    private Set getClosure（Set x） {
        Set set = new HashSet（x）;
        boolean k = true;
        while （k） {
            x = new HashSet（set）;
            k = false;
            for （int i : x） {
                set.add（i）;
                for （int j = 0; j < size; j++） {
                    if （g[i][j] == Njump） {
                        if （set.add（j））
                            k = true;
                    }
                }
            }
        }
        return set;
    }

    private Set getClosure（int x） {
        Set set = new HashSet（）;
        set.add（x）;

        return getClosure（set）;
    }

    private void setEdges（） {
        edges = new ArrayList<>（）;
        linkedBlockingQueue setQueue = new linkedBlockingQueue<>（）;
        Set set = getClosure（sta）;
        Integer setN = 0;
        if （setSet.add（set）） {
            setQueue.add（set）;
            setN++;
            setMap.put（set setN）;//setMap 状态集的集合
        }
        while （!setQueue.isEmpty（）） {
            Set x = （Set） setQueue.poll（）;
            for （object m : M） {
                Set nx = getClosure（move（x （char） m））;
                if （（!nx.isEmpty（）） && setSet.add（nx）） {//新增状态集
                    setQueue.add（nx）;
                    setN++;//状态集个数
                    setMap.put（nx setN）;
                }
                if （!nx.isEmpty（）） {
                    //edges 状态集间跳转的边集
                    edges.add（new Edge（setMap.get（x） setMap.get（nx） （char） m））;
                }
            }
        }
    }

 属性            大小     日期    时间   名称
----------- ---------  ---------- -----  ----
     文件           0  2018-04-23 13:07  婧愪唬鐮?
     文件        4044  2018-01-07 21:03  婧愪唬鐮?DFA.java
     文件        2477  2018-01-07 19:45  婧愪唬鐮?Regex.java
     文件        4288  2018-01-07 20:35  婧愪唬鐮?NFA.java
     目录           0  2018-04-23 13:07  婧愪唬鐮?Graphoutput\
     文件        9642  2017-11-13 12:44  婧愪唬鐮?Graphoutput\GraphViz.java
     文件         417  2017-11-13 15:58  婧愪唬鐮?G.java
     文件         363  2018-01-07 21:31  婧愪唬鐮?Main.java
     文件        2176  2017-11-13 12:45  婧愪唬鐮?Proba.java
     文件         931  2017-11-13 19:03  婧愪唬鐮?Edge.java