NFA转换成DFA——汉字形式数字转换成整数数字

偶然间遇到了一个需求：汉字形式数字转换成整数数字。如果不处理意外情况，可以写的很简单（比如不会出现三三等），详情可以看这里。但是，想着可以写成一个FA的形式，于是乎，发现并不是想象中的那么简单。。因为写成FA就发现，要处理非法形式的问题，还是有点麻烦的。
好不容易写成了FA，发现是个NFA，于是乎写了个NFA转换成DFA的代码，也支持了一套简单的FA的定义规则。代码如下：

package ie;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import util.FileEntry;

public class DFA {
    public static DFA getNumberDFA() { 
        DFA dfa = RulesLoader.loadRules("src/rules", "UTF-8");
        return dfa;
    }

    public static void display(Set<String> set, String enter) {
        for (String s: set) {
            System.out.print(s + " ");
        }
        System.out.print(enter);
    }
    public final HashMap<String, Integer> addMap = new HashMap<String, Integer>(){
        /**
         * 
         */
        private static final long serialVersionUID = 4651868428072469904L;

        {
            put("零", 0);
            put("一", 1);
            put("二", 2);
            put("两", 2);
            put("三", 3);
            put("四", 4);
            put("五", 5);
            put("六", 6);
            put("七", 7);
            put("八", 8);
            put("九", 9);
        }
    };
    public final HashMap<String, Integer> mulMap = new HashMap<String, Integer>(){
        /**
         * 
         */
        private static final long serialVersionUID = 4001356133579818232L;

        {
            put("十", 10);
            put("百", 100);
            put("千", 1000);
        }
    };

    /**
     * 
     * @author wty
     *
     */
    class MapNode {
        /*自动机的初始状态*/
        public Set<String> status;
        /*状态接受的符号*/
        public String symbol;
        /*<临时>，处理汉字转换成数字用来记录和*/
        public int sum = 0, subSum = 0;
        public MapNode() {}
        public MapNode(Set<String> status, String symbol) {
            this.status = status;
            this.symbol = symbol;
        }

        @Override
        public boolean equals(Object obj) {
            if (obj == null || getClass() != obj.getClass())
                return false;
            final MapNode other = (MapNode) obj;
            if (this.status != other.status && (this.status == null || !this.status.equals(other.status)))
                return false;
            if (this.symbol != other.symbol && (this.symbol == null || !this.symbol.equals(other.symbol)))
                return false;
            return true;
        }

        @Override
        public int hashCode() {
            return status.hashCode() ^ symbol.hashCode();
        }
    }


    private HashMap<MapNode, Set<String>> map = new HashMap<DFA.MapNode, Set<String>>();


    /**
     * 当前状态进行转换时需要进行的操作
     */
    public void transform(MapNode mapNode) {
        if (addMap.containsKey(mapNode.symbol))
            mapNode.subSum = addMap.get(mapNode.symbol);
        else if (mulMap.containsKey(mapNode.symbol)) {
            mapNode.sum += Math.max(1, mapNode.subSum) * mulMap.get(mapNode.symbol);
            mapNode.subSum = 0;
        }
        else {
            if (mapNode.status.size() == 0)
                mapNode.sum = -1;
            else if (mapNode.status.contains("3"))
                mapNode.sum = mapNode.sum + mapNode.subSum * 100;
            else if (mapNode.status.contains("7"))
                mapNode.sum = mapNode.sum + mapNode.subSum * 10;
            else if (mapNode.status.contains("11"))
                mapNode.sum = mapNode.sum + mapNode.subSum;
            else if (mapNode.status.contains("13"))
                mapNode.sum = mapNode.sum + mapNode.subSum;
            else if (mapNode.status.contains("14"))
                mapNode.sum = mapNode.sum + mapNode.subSum;
            else if (mapNode.status.contains("15"))
                mapNode.sum = mapNode.sum + mapNode.subSum;
            else if (mapNode.status.contains("19"))
                mapNode.sum = mapNode.sum + mapNode.subSum;
            else
                mapNode.sum = mapNode.sum;
        }

        mapNode.status = getDest(mapNode.status, mapNode.symbol);
        mapNode.symbol = "";
    }


    public void addEdge(Set<String> source, String symbol, Set<String> dest) {
        map.put(new MapNode(source, symbol), dest);
    }

    public Set<String> getDest(Set<String> source, String symbol) {
        return map.getOrDefault(new MapNode(source, symbol), new HashSet<String>());
    }

    public int transform(String inputStream) {
        Set<String> status = new HashSet<String>();
        status.add("0");
        MapNode mapNode = new MapNode(status, "");
        for (int i = 0; i < inputStream.length(); i++) {
            String symbol = inputStream.substring(i, i + 1);
            mapNode.symbol = symbol;
//          display(status, " --(" + symbol + ")--> ");
            transform(mapNode);
//          display(status, "\n");
        }
        transform(mapNode);
        return mapNode.sum;
    }
}

class RulesLoader {
    /*rule文件中，用来缩写状态集合的符号*/
    public static String SPLITER_STATUS = ",";
    /*rule文件中，预定义语句的分隔符*/
    public static String SPLITER_DEFINE = "=";
    /*rule文件中，定义状态转移的分隔符*/
    public static String SPLITER_TRANSFORM = "\t";
    /*程序中，用来记录原始状态和转移的分隔符*/
    public static String SPLITER_MAP_KEY = "--";
    /*rule文件中，定义状态空的符号*/
    public static String EMPTY = "$EMPTY";

    /**
     * 是否是预定义
     * @param line rule文件的一行
     * @return
     */
    public static boolean isDefine(String line) {
        return line.indexOf(SPLITER_DEFINE) != -1;
    }

    /**
     * 是否是需要忽略的行
     * @param line rule文件的一行
     * @return
     */
    public static boolean isIgnore(String line) {
        return line.length() == 0;
    }

    /**
     * 是否是状态转换定义
     * @param line rule文件的一行
     * @return
     */
    public static boolean isTransform(String line) {
        return line.split(SPLITER_TRANSFORM).length == 3;
    }

    /**
     * 获取文件中的预定义
     * @param mapDefine 用来存储所有的预定义
     * @param line rule文件的一行
     */
    public static void getDefine(Map<String, String> mapDefine, String line) {
        String[] parts = line.split(SPLITER_DEFINE);
        try {
            mapDefine.put(parts[0], parts[1]);
        }
        catch (ArrayIndexOutOfBoundsException e) {
            System.err.println("ERROR:未在当前行中发现定义");
            throw e;
        }
    }

    /**
     * 
     * @param mapDefine 记录文件中所有的预定义
     * @param status 原状态
     * @return 先将状态用预定义替换，然后分隔
     */
    public static String[] getStatuses(Map<String, String> mapDefine, String status) {
        if (mapDefine.containsKey(status))
            status = mapDefine.get(status);
        return status.split(SPLITER_STATUS);
    }

    /**
     * 是否是空符号
     * @param symbol
     * @return
     */
    public static boolean isEmpty(String symbol) {
        return symbol.equals(EMPTY);
    }

    public static void display(Set<String> set, String enter) {
        for (String s: set) {
            System.out.print(s + " ");
        }
        System.out.print(enter);
    }

    /**
     * 获取statuses中，所有状态在空符号下的等价状态
     * @param mapEmpty 记录rule文件中的所有空转移信息
     * @param statuses
     * @return
     */
    public static Set<String> getByEmpty(Map<String, Set<String>> mapEmpty, Set<String> statuses) {
        Set<String> ret = new HashSet<String>();
        Set<String> tmpStatuses = new HashSet<String>(statuses);
        while (!tmpStatuses.isEmpty()) {
            String status = tmpStatuses.iterator().next();
            tmpStatuses.remove(status);
            ret.add(status);
            for (String dest: mapEmpty.getOrDefault(status, new HashSet<String>()))
                ret.add(dest);
        }
        return ret;
    }

    /**
     * 获取status在空符号下的等价状态
     * @param mapEmpty 记录rule文件中的所有空转移信息
     * @param status
     * @return
     */
    public static Set<String> getByEmpty(Map<String, Set<String>> mapEmpty, String status) {
        Set<String> ret = new HashSet<String>();
        ret.add(status);
        for (String dest: mapEmpty.getOrDefault(status, new HashSet<String>())) {
            ret.add(dest);
        }
        return ret;
    }

    /**
     * 起始状态经过symbol转换后的状态
     * @param mapTransform
     * @param mapEmpty
     * @param startStatuses 起始的状态，是转换后的状态
     * @param symbol 需要转换的符号
     * @return
     */
    public static Set<String> getDestBySymbol(Map<String, Set<String>> mapTransform, 
            Map<String, Set<String>> mapEmpty, Set<String> startStatuses, String symbol) {
        //将状态经过空符号转移后的状态作为初始状态
        Set<String> sourceStatuses = getByEmpty(mapEmpty, startStatuses);
        Set<String> destStatuses = new HashSet<String>();
        //对一个新的状态的所有原始状态，都进行转移，每个原始状态为String
        while (!sourceStatuses.isEmpty()) {
            String status = sourceStatuses.iterator().next();
            String key = status + SPLITER_MAP_KEY + symbol;
            for (String destStatus: mapTransform.getOrDefault(key, new HashSet<String>())) {
                if (!destStatuses.contains(destStatus)) {
                    Set<String> all = getByEmpty(mapEmpty, destStatus);
                    sourceStatuses.addAll(all);
                    destStatuses.addAll(all);
                }
            }
            sourceStatuses.remove(status);
        }
        return destStatuses;
    }

    /**
     * 从文件中加载信息，构造出DFA
     * @param filePath
     * @param charset
     * @return
     */
    public static DFA loadRules(String filePath, String charset) {
        ArrayList<String> lines = FileEntry.readFileLines(filePath, charset);
        Map<String, String> mapDefine = new HashMap<String, String>();
        Map<String, Set<String>> mapTransform = new HashMap<String, Set<String>>();
        Map<String, Set<String>> mapEmpty = new HashMap<String, Set<String>>();
        Map<String, Integer> statusMap = new HashMap<String, Integer>();
        Set<String> symbolSet = new HashSet<String>();
        DFA dfa = new DFA();
        /**
         * 先处理出所有的预定义信息，并记录下来
         */
        for (String line: lines)
            if (isDefine(line))
                getDefine(mapDefine, line);
        /**
         * 将所有状态都使用预定义进行替换处理
         * 对rules文件进行处理，生成所有的(a, b, c)三元组：表示a状态经过b符号到c状态
         * 如果b不是空符号，则记录在mapTransform中，记录形式为 Map[a+SPLITER_MAP_KEY+b]=c
         * 否则，记录在mapEmpty中，记录形式为Map[a]=c
         */
        for (String line: lines)
            if (isTransform(line)) {
                String[] parts = line.split("\t");
                String[] sources = getStatuses(mapDefine, parts[0]);
                String[] symbols = getStatuses(mapDefine, parts[1]);
                String[] destinations = getStatuses(mapDefine, parts[2]);
                for (String source: sources) {
                    statusMap.put(source, -1);
                    for (String symbol: symbols) {
                        symbolSet.add(symbol);
                        for (String destination: destinations) {
                            if (!isEmpty(symbol)) {
                                statusMap.put(destination, -1);
                                String key = source + SPLITER_MAP_KEY + symbol;
                                Set<String> value = mapTransform.getOrDefault(key, new HashSet<String>());
                                value.add(destination);
                                mapTransform.put(key, value);
                            }
                            else {
                                Set<String> value = mapEmpty.getOrDefault(source, new HashSet<String>());
                                value.add(destination);
//                              System.out.println(source + "\t" + value);
                                mapEmpty.put(source, value);
                            }
                        }
                    }
                }
            }

        //记录转换后的DFA的状态，每个状态为Set<String>
        Set<Set<String>> newStatusSet = new HashSet<Set<String>>();
        //起点默认为0
        Set<String> startStatus = new HashSet<String>();
        startStatus.add("0");
        newStatusSet.add(startStatus);
        //对所有未处理的状态，都进行转移
        while (!newStatusSet.isEmpty()) {
            Set<String> statuses = newStatusSet.iterator().next();
            //对每个状态，逐一选择所有的符号，得到新的转移后状态
            for (String symbol: symbolSet) {
                Set<String> destStatuses = getDestBySymbol(mapTransform, mapEmpty, statuses, symbol);
                if (destStatuses.size() > 0) {
                    dfa.addEdge(new HashSet<String>(statuses), symbol, destStatuses);
//                  display(statuses, "--(");
//                  display(getByEmpty(mapEmpty, statuses), "--(");
//                  System.out.print(symbol + ")--> ");
//                  display(destStatuses, "\n");
                    newStatusSet.add(destStatuses);
                }
            }
            newStatusSet.remove(statuses);
        }
        return dfa;
    }
}

//public class DFA {
//  public static DFA getDFA(String[] args) {
//      DFA dfa = RulesLoader.loadRules("src/rules", "UTF-8");
//      return dfa;
//      //
////        for (String s: new String[]{"零", "五", "十", "十五", "五十五", "一百", "一百零五", 
////                "一百五十", "一百五十五", "一千零五", "一千零一十", "一千零一十一", "一千一", "一千一百零三", 
////                "一千零三十", "一千零三十五"}) {
////            int v = dfa.transform(s);
////            System.out.println( v );
////        }
////        System.out.println("------------------------------------------------------------");
////        for (String s: new String[]{"零零", "五五", "十十", "十五五", "五十五五"}) {
////            int v = dfa.transform(s);
////            System.out.println( v );
////        }
//  }
//}

这是我写的，对万（不包括）以内的数的识别的自动机描述：

1-9=一,二,两,三,四,五,六,七,八,九
2-9=二,两,三,四,五,六,七,八,九

0   1-9 1,4,15
0   2-9 8
0   十   9
0   零   16

1   千   2

2   1-9 3
2   零   6,10

3   百   5

4   百   5

5   零   12
5   1-9 7,8

6   1-9 17,10

7   十   9

8   十   9

9   1-9 14

10  1-9 11

12  1-9 13

17  十   18

18  1-9 19

简单写一下说明，文件最开始的1-9=str是对【1-9】这个符号的一个简单替换规则，类似c语言中的#define。下边的文件，每行分为三部分：起始状态 \t 接受的符号 \t 转换到的状态，此处为了编写的方便，如果有多个状态or接受的符号，用英文的逗号分隔开即可。

其实这部分工作，对汉字转数字的作用好像也没多大。。。毕竟把错误的汉字串传进来也不大可能，而且如果要实现对万以上的汉字的识别，自动机也比较复杂。倒是这个NFA转换成DFA或许有用的到的时候，先记下来吧。