Java Anagramanager程序不同区域出现空指针异常错误

我在代码中的几个不同位置收到一个nullpointer异常。我肯定我忘记了某个地方有个例外，但我需要一些帮助来指出它。我有3个文件要和整个程序一起使用。我正在基于给定的主文件创建一个语法分析器

这是第一类单词

import java.util.*;

public class Word implements Comparable<Word>
{
   private String word;
   private String canonical;

   public Word(String word)
   {
      String lowerCase = word.toLowerCase();
      word = lowerCase;
      canonical = CanonicalForm(word);
   }

   public String getWord()
   {
      return word;
   }

   public String getForm()
   {
      return canonical;
   }

   public String toString()
   {
      return "[" + word + "=" + canonical + "]";
   }

   public int compareTo(Word someWord)
   {
      return getForm().compareTo(someWord.getForm());
   }

   private static String CanonicalForm(String word)
   {
      if(word == null || word.length() < 1) 
      {
         throw new IllegalArgumentException();
      }

      char arr[] = word.toCharArray();
      Arrays.sort(arr);
      return new String(arr);
   }
}

import java.util.*；
公共类Word实现了可比较的
{
私有字符串字；
私有字符串规范；
公共字（字符串字）
{
String lowerCase=word.toLowerCase（）；
字=小写；
canonical=规范形式（word）；
}
公共字符串getWord（）
{
返回词；
}
公共字符串getForm（）
{
返回规范；
}
公共字符串toString（）
{
返回“[”+单词+”=“+规范+”]”；
}
公共整数比较（Word someWord）
{
返回getForm（）.compareTo（someWord.getForm（））；
}
私有静态字符串规范格式（字符串字）
{
if（word==null | | word.length（）<1）
{
抛出新的IllegalArgumentException（）；
}
char arr[]=word.toCharArray（）；
数组。排序（arr）；
返回新字符串（arr）；
}
}

这里是anagrammager，它处理主文件夹上的大部分工作

import java.util.*;

public class AnagramManager
{
   private Word[] words;
   private Random rand;
   private Map<String,Set<String>> theMap;

   public AnagramManager(List<String> list)
   {
      if (list == null || list.size() < 1)
      {
         throw new IllegalArgumentException();
      }

      rand = new Random();
      words = new Word[list.size()];
      theMap = new TreeMap<String,Set<String>>();

      makeWords(list);
      makeAnagrams();
   }

   public void sortByWord()
   {
      for (Word i : words)
      {
         i.getWord();
      }
      Arrays.sort(words);
   }

   public void sortByForm()
   {
      for(Word c : words)
      {
         c.getForm();
      }
      Arrays.sort(words);
   }

   public String getAnagram(String word)
   {
      String canonWord = CanonicalForm(word);
      if(theMap.containsKey(canonWord))
      {
         Set<String> anagramSet = theMap.get(canonWord);
         String[] match = anagramSet.toArray(new String[anagramSet.size()]);
         return match[rand.nextInt(match.length)];
      }
      else
      {
         return "";
      }
   }

   public Set<String> getAnagrams(String word)
   {
      String canonWord = CanonicalForm(word);
      boolean hasAnagram = theMap.containsKey(canonWord);

      Set<String> anagrams = (hasAnagram) ? theMap.get(canonWord) : new TreeSet<String>();


      return anagrams;
   }


   public String toString()
   {
      String printWords = "";
      int length = words.length;

      if (length < 1)
      {
         printWords += "[]";
      }
      else
      {

         for (int i=0; i < length; i++)
         {
            printWords += words[i];
         }

         printWords += "[...]";

         for(int i = length - 5; i < length; i++)
         {
            printWords += words[i];
         }
      }
      return printWords;
   }         

   private static String CanonicalForm(String word)
   {
      if(word == null || word.length() < 1)
      {
         throw new IllegalArgumentException();
      }

      char arr[] = word.toCharArray();
      Arrays.sort(arr);
      return new String(arr);
   }

   private void makeWords(List<String> list)
   {
      int ind = 0;

      for (String orgWord : list)
      {
         words[ind] = new Word(orgWord);
         ind++;
      }
   }

   private void makeAnagrams()
   {
      for(Word i : words)
      {
         String canon = i.getForm();
         String org = i.getWord();

         if(!theMap.containsKey(canon))
         {
            Set<String> set = new TreeSet<String>();
            set.add(org);
            theMap.put(canon,set);
         }
         else
         {
            theMap.get(canon).add(org);
         }
      }
   }
}

import java.util.*；
公共类语法分析器
{
私有词[]词；
私有随机兰德；
私人地图专题地图；
公共语法管理器（列表）
{
if（list==null | | list.size（）<1）
{
抛出新的IllegalArgumentException（）；
}
rand=新随机数（）；
单词=新词[list.size（）]；
theMap=新树映射（）；
makeWords（列表）；
造字谜（）；
}
公共无效sortByWord（）
{
for（单词i：单词）
{
i、 getWord（）；
}
数组。排序（单词）；
}
公共无效排序形式（）
{
for（单词c：单词）
{
c、 getForm（）；
}
数组。排序（单词）；
}
公共字符串getAnagram（字符串字）
{
字符串canonWord=规范格式（word）；
if（主题地图containsKey（canonWord））
{
设置anagramSet=map.get（canonWord）；
字符串[]匹配=anagramSet.toArray（新字符串[anagramSet.size（）]）；
返回匹配[rand.nextInt（match.length）]；
}
其他的
{
返回“”；
}
}
公共集getAnagrams（字符串字）
{
字符串canonWord=规范格式（word）；
布尔hasAnagram=theMap.containsKey（canonWord）；
Set anagrams=（hasAnagram）？map.get（canonWord）：new TreeSet（）；
返回字谜；
}
公共字符串toString（）
{
字符串printWords=“”；
int-length=words.length；
如果（长度<1）
{
打印字+=“[]”；
}
其他的
{
for（int i=0；i

这是主要节目。这根本不应该被修改

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

public class AnagramMain {
    public static final String DICTIONARY_FILE = "dictionary.txt";

    public static void main(String[] args) throws FileNotFoundException {
        System.out.println("Welcome to the CS145 Anagram Practice");
        System.out.println();

        // open the dictionary file and read dictionary into an ArrayList
        Scanner input = new Scanner(new File(DICTIONARY_FILE));
      Scanner keyboard = new Scanner(System.in);
        List<String> dictionary = new ArrayList<String>();
        while (input.hasNext()) {
            dictionary.add(input.next().toLowerCase());
        }

        // set up the AnagramManager
        List<String> dictionary2 = Collections.unmodifiableList(dictionary);
        AnagramManager catalog = new AnagramManager(dictionary2);

      // Start the program asking for run style
      System.out.println("Press enter to start, or any other input for debug mode");
      String DEBUG = keyboard.nextLine();

      // If in DEBUG mode
      if (!DEBUG.equals("") )
      {
        System.out.println("** The first and last five sorted by word elements are **");
        catalog.sortByWord();
        System.out.println(catalog);
        System.out.println("** The first and last five sorted by form elements are **");
        catalog.sortByForm();
        System.out.println(catalog);
        System.out.println("\n\n\n");
      }

      // Start the Loop
      getAnagram(keyboard, catalog);

    }

    // Executes the primary anagram loop
    public static void getAnagram(Scanner console, AnagramManager theCatalog) 
   {
      String input;
      System.out.println("Please type in a word to anagram or QUIT to quit :");
      input = console.nextLine();

      while (!input.toUpperCase().equals("QUIT") && !input.equals("") ) 
      {
        String result = theCatalog.getAnagram(input);
        if (!result.equals("") )
        {
         System.out.print("One possible anagram of your word " + input );
         System.out.println(" is " +result);
        }
        else
        {
          System.out.println("Your word was not found in the list");
        }

        System.out.print("In fact the list of anagrams for your word are : ");
        System.out.println(theCatalog.getAnagrams(input));

        System.out.println("Please type in a word to anagram or QUIT to quit :");
        input = console.nextLine();
      }
    }
}

import java.util.*；
导入java.io.*；
公共级语法分析{
公共静态最终字符串字典\u FILE=“DICTIONARY.txt”；
公共静态void main（字符串[]args）引发FileNotFoundException{
System.out.println（“欢迎使用CS145字谜练习”）；
System.out.println（）；
//打开字典文件并将字典读入ArrayList
扫描仪输入=新扫描仪（新文件（字典文件））；
扫描仪键盘=新扫描仪（System.in）；
列表字典=新的ArrayList（）；
while（input.hasNext（））{
add（input.next（）.toLowerCase（））；
}
//设置语法分析器
列表字典2=集合。不可修改列表（字典）；
语法管理器目录=新的语法管理器（字典2）；
//启动程序，询问运行方式
System.out.println（“按enter键启动，或按调试模式的任何其他输入”）；
字符串调试=keyboard.nextLine（）；
//如果处于调试模式
如果（！DEBUG.equals（“”）
{
System.out.println（“**按单词元素排序的前五个和后五个是**”）；
catalog.sortByWord（）；
系统输出打印LN（目录）；
System.out.println（“**按表单元素排序的前五个和后五个是**”）；
catalog.sortByForm（）；
系统输出打印LN（目录）；
System.out.println（“\n\n\n”）；
}
//开始循环
getAnagram（键盘、目录）；
}
//执行主字谜循环
公共静态无效获取语法图（扫描仪控制台、语法管理器目录）
{
字符串输入；
System.out.println（“请键入一个单词以进行拼音或退出以退出：”）；
input=console.nextLine（）；
而（！input.toUpperCase（）.equals（“退出”）&&！input.equals（“”）
{
字符串结果=catalog.getAnagram（输入）；
如果（！result.equals（“”）
{
System.out.print（“一个可能的单词拼音”+输入）
Exception in thread "main" java.lang.NullPointerException
    at java.util.TreeMap.compare(TreeMap.java:1294)
    at java.util.TreeMap.put(TreeMap.java:538)
    at java.util.TreeSet.add(TreeSet.java:255)
    at AnagramManager.makeAnagrams(AnagramManager.java:129)
    at AnagramManager.<init>(AnagramManager.java:21)
    at AnagramMain.main(AnagramMain.java:28)

this.word = lowerCase;