Question

我一直致力于一个项目，在该项目中，我使用Backus-Naur Form语法表示法获取文件并用它生成句子。这是我正在处理的BNF文件：

<s>::=<np> <vp>
<np>::=<dp> <adjp> <n>|<pn>
<pn>::=John|Jane|Sally|Spot|Fred|Elmo
<adjp>::=<adj>|<adj> <adjp>
<adj>::=big|fat|green|wonderful|faulty|subliminal|pretentious
<dp>::=the|a 
<n>::=dog|cat|man|university|father|mother|child|television
<vp>::=<tv> <np>|<iv>
<tv>::=hit|honored|kissed|helped
<iv>::=died|collapsed|laughed|wept

几乎所有东西都运行正常，除了通过规则集引入字母“a”之外。当发生这种情况时，我收到以下错误：

线程“main”中的异常显示java.lang.NullPointerException 在GrammarSolver.generate（GrammarSolver.java:95）在GrammarSolver.generate（GrammarSolver.java:109）在GrammarSolver.generate（GrammarSolver.java:116）在GrammarSolver.generate（GrammarSolver.java:116）在GrammarSolver。（GrammarSolver.java:51）在GrammarTest.main（GrammarTest.java:19）

我一直在尝试跟踪并查找此错误的原因，但一直无法执行此操作。所以我正在寻找一个可能有更多经验的人的建议，告诉我我的bug在哪里，这样我就能理解是什么导致它，并避免在将来复制类似的错误。

我的程序代码如下：

import java.util.*;
import java.util.regex.*;

class GrammarSolver {

    //Create output variable for sentences
    String output = "";

    //Create a map for storing grammar
    SortedMap<String, String[]> rules = new TreeMap<String, String[]>();

    //Create a queue for managing sentences
    Queue<String> queue = new LinkedList<String>();

    /**
     * Constructor for GrammarSolver
     *
     * Accepts a List<String> then processes it splitting
     * BNF notation into a TreeMap so that "A ::= B" is
     * loaded into the tree so the key is A and the data
     * contained is B
     *
     * @param       grammar     List of Strings with a set of
     *                          grammar rules in BNF form.
     */
    public GrammarSolver(List<String> grammar){
        //Convert list to string
        String s = grammar.toString();

        //Split and clean
        String[] parts = s.split("::=|,");
        for(int i = 0; i < parts.length; i++){
            parts[i] = parts[i].trim();
            parts[i] = parts[i].replaceAll("\\[|]", "");
            //parts[i] = parts[i].replaceAll("[ \t]+", "");

        }
        //Load into TreeMap
        for(int i = 0; i < parts.length - 1; i+=2){
            String[] temp = parts[i+1].split("\\|");
            rules.put(parts[i], temp);
        }

        //Debug
        String[] test = generate("<s>", 2);
        System.out.println(test[0]);
        System.out.println(test[1]);
    }

    /**
     * Method to check if a certain non-terminal (such as <adj>
     * is present in the map.
     *
     * Accepts a String and returns true if said non-terminal is
     * in the map, and therefore a valid grammar. Returns false
     * otherwise.
     *
     * @param       symbol      The string that will be checked
     * @return      boolean     True if present, false if otherwise
     */
    public boolean grammarContains(String symbol){
        if(rules.keySet().toString().contains(symbol)){
            return true;
        }else{
            return false;
        }
    }

    /**
     * Method to generate sentences based on BNF notation and
     * return them as strings.
     *
     * @param       symbol      The BNF symbol to be generated
     * @param       times       The number of sentences to be generated
     * @return      String      The generated sentence
     */
    public String[] generate(String symbol, int times){
        //Array for output
        String[] output = new String[times];

        for(int i = 0; i < times; i++){
            //Clear array for run
            output[i] = "";

            //Grab rules, and store in an array
            lString[] grammar = rules.get(symbol);

            //Generate random number and assign to var
            int rand = randomNumber(grammar.length);

            //Take chosen grammar and split into array
            String[] rules =  grammar[rand].toString().split("\\s");

            //Determine if the rule is terminal or not
            if(grammarContains(rules[0])){
                //System.out.println("grammar has more grammars");
                //Find if there is one or more conditions
                if(rules.length == 1){
                    String[] returnString = generate(rules[0], 1);
                    output[i] += returnString[0];
                    output[i] += " ";
                }else if(rules.length > 1){
                    for(int j = 0; j < rules.length; j++){
                        String[] returnString = generate(rules[j], 1);
                        output[i] += returnString[0];
                        output[i] += " ";
                    }
                }
            }else{
                String[] returnArr = new String[1];
                returnArr[0] = grammar[rand];;
                return returnArr;
            }
            output[i] = output[i].trim();
        }
        return output;
    }

    /**
     * Method to list all valid non-terminals for the current grammar
     *
     * @return      String      A listing of all valid non-terminals
     *                          contained in the current grammar that
     *                          can be used to generate words or
     *                          sentences.
     */
    String getSymbols(){
        return rules.keySet().toString();
    }

    public int randomNumber(int max){
        Random rand = new Random();
        int returnVal = rand.nextInt(max);
        return returnVal;
    }
}

我的测试工具如下：

import java.io.*;
import java.util.*;

public class GrammarTest {
    public static void main(String[] args) throws FileNotFoundException {
        Scanner console = new Scanner(System.in);
        System.out.println();

        // open grammar file
        Scanner input = new Scanner(new File("sentence.txt"));

        // read the grammar file and construct the grammar solver
        List<String> grammar = new ArrayList<String>();
        while (input.hasNextLine()) {
            String next = input.nextLine().trim();
            if (next.length() > 0)
                grammar.add(next);
        }
        GrammarSolver solver =
            new GrammarSolver(Collections.unmodifiableList(grammar));
    }

}

任何帮助或提示将不胜感激;

谢谢！

编辑：第95,106和116行与

神秘的NullPointer

3 个答案: