Java 为什么我的数组得到ArrayIndexOutOfBoundsException？

我在学校的编程课上有一个项目，我们要做一个邪恶的刽子手游戏，在这个游戏中，电脑在必要时才会选择一个单词。为了欺骗用户认为它是在公平地玩，计算机只考虑具有相同字母模式的单词

我得到了一些我认为应该有效的东西，但是在猜了字母“a”和“e”之后，我的数组有一个ArrayIndexOutOfBoundsException，在过去的几个小时里，我一直在尝试使用调试器来解决它，但我仍然没有看到问题，我的意思是整个类都可以处理第一个字母，但第二个字母就中断了。当我在HangmanManager类的末尾返回patternArr[indexOfMax]时，就会发生这种情况。为什么它不能像我期望的那样工作

这是我一直在使用的字典文件的链接（为了让游戏正常运行，你必须使用一个包含一堆单词的文本文件）：

下面是我的节目：

机库经理班

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;

public class HangmanManager {
    private SortedSet<String> wordset;
    private SortedSet<Character> guessSet;
    private String wordPattern;
    private int guessesLeft;



    public HangmanManager(List<String> dictionary, int length, int max){
        if(length < 1 || max < 0) {
            throw new IllegalArgumentException();
        }
        wordset = new TreeSet<String>();
        for(String words: dictionary) {
            if(words.length() == length) {
                wordset.add(words);
            }
        }
        wordPattern = "";
        for (int i = 0; i < length; i++) {
            wordPattern += "- ";
        }
        guessesLeft = max;
        guessSet = new TreeSet<Character>();

    }
    //Returns the managers words
    public Set<String> words() {
        return wordset;
    }

    //Returns the number of guesses left
    public int guessesLeft() {
        return guessesLeft - guessSet.size();
    }

    //Returns the guessed letters
    public SortedSet<Character> guesses() {
        return guessSet;
    }

    //Returns String pattern 
    public String pattern() {
        return wordPattern;
    }
    public int record(char guess) {
        guessSet.add(guess);
        return comparePatterns(wordset, guess);
    }

    private String makePattern(char guess, String word) {
        String position = "";
        char[] letters = word.toCharArray();
        for (int i = 0; i < word.length(); i ++) {
            if (letters[i] == guess) {
                position = position + guess + " ";
            } else {
                position = position + "- ";
            }
        }
        return position;
    }
    //This method is supposed to take out all the patterns that don't match
    // the String commonPattern
    private int comparePatterns(SortedSet<String> mySet, char guess) {
        String[] wordArray = new String[mySet.size()];
        wordArray = (String[]) mySet.toArray(wordArray);
        String[] patternArray = new String[wordArray.length];
        List<String> tempList = new ArrayList<String>();
        for(int i = 0; i < wordArray.length; i++) {
            patternArray[i] = makePattern(guess, wordArray[i]);
        }
        String commonPattern = getMostCommonPattern(guess, patternArray);

        int rightGuess = 0;
        for(int i = 0; i > commonPattern.length(); i ++) {
            if(commonPattern.charAt(i) == guess) {
                rightGuess++;
            }
        }
        for(int j = 0; j < patternArray.length; j++) {
            if(commonPattern.equals(patternArray[j])) {
                tempList.add(wordArray[j]);
            }
        }
        wordset.removeAll(wordset);
        wordset.addAll(tempList);
        return rightGuess;
    }
    //This method gets the most common pattern

    //THIS METHOD BREAKS
    private String getMostCommonPattern(char guess, String[] patternArr) {
        List<String> patternList = Arrays.asList(patternArr);
        int[] countArray = new int[patternArr.length];
        for(int i = 0; i < patternArr.length; i++) {
            countArray[i] = Collections.frequency(patternList, patternArr[i]);
        }


        int max = 0;
        int indexOfMax = 0;
        for (int j = 0; j < countArray.length; j++) {
            if(max < countArray[j]) {
                max = countArray[j];
                indexOfMax = j;
            } else if (max > countArray[j]) {

            }else if (max == countArray[j]) {

            }
        }

        return patternArr[indexOfMax];
    }
}

import java.util.ArrayList；
导入java.util.array；
导入java.util.Collections；
导入java.util.List；
导入java.util.Set；
导入java.util.SortedSet；
导入java.util.TreeSet；
公营机库经理{
专用分类词集；
私有分类集猜测集；
私有字符串字模式；
私有int猜测左；
公共Hangman Manager（列表字典，整数长度，整数最大值）{
如果（长度<1 | |最大值<0）{
抛出新的IllegalArgumentException（）；
}
wordset=newtreeset（）；
for（字符串：字典）{
if（words.length（）=长度）{
添加（单词）；
}
}
wordPattern=“”；
for（int i=0；icommonPattern.length（）；i++）{
if（commonPattern.charAt（i）=猜测）{
rightGuess++；
}
}
对于（int j=0；jcountArray[j]）{
}else如果（max==countArray[j]）{
}
}
返回模式arr[indexOfMax]；
}
}

刽子手级

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

public class HangmanMain {
    public static final String DICTIONARY_FILE = "C:\\Users\\Zoratu\\Desktop\\EvilHangman\\dictionary.txt";
    public static final boolean DEBUG = false; // show words left

    public static void main(String[] args) throws FileNotFoundException {
        System.out.println("Welcome to the cse143 hangman game.");
        System.out.println();

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

        // set basic parameters
        Scanner console = new Scanner(System.in);
        System.out.print("What length word do you want to use? ");
        int length = console.nextInt();
        System.out.print("How many wrong answers allowed? ");
        int max = console.nextInt();
        System.out.println();

        // set up the HangmanManager and start the game
        List<String> dictionary2 = Collections.unmodifiableList(dictionary);
        HangmanManager hangman = new HangmanManager(dictionary2, length, max);
        if (hangman.words().isEmpty()) {
            System.out.println("No words of that length in the dictionary.");
        } else {
            playGame(console, hangman);
            showResults(hangman);
        }
    }

    // Plays one game with the user
    public static void playGame(Scanner console, HangmanManager hangman) {
        while (hangman.guessesLeft() > 0 && hangman.pattern().contains("-")) {
            System.out.println("guesses : " + hangman.guessesLeft());
            if (DEBUG) {
                System.out.println(hangman.words().size() + " words left: "
                        + hangman.words());
            }
            System.out.println("guessed : " + hangman.guesses());
            System.out.println("current : " + hangman.pattern());
            System.out.print("Your guess? ");
            char ch = console.next().toLowerCase().charAt(0);
            if (hangman.guesses().contains(ch)) {
                System.out.println("You already guessed that");
            } else {
                int count = hangman.record(ch);
                if (count == 0) {
                    System.out.println("Sorry, there are no " + ch + "'s");
                } else if (count == 1) {
                    System.out.println("Yes, there is one " + ch);
                } else {
                    System.out.println("Yes, there are " + count + " " + ch
                            + "'s");
                }
            }
            System.out.println();
        }
    }

    // reports the results of the game, including showing the answer
    public static void showResults(HangmanManager hangman) {
        // if the game is over, the answer is the first word in the list
        // of words, so we use an iterator to get it
        String answer = hangman.words().iterator().next();
        System.out.println("answer = " + answer);
        if (hangman.guessesLeft() > 0) {
            System.out.println("You beat me");
        } else {
            System.out.println("Sorry, you lose");
        }
    }

import java.util.*；
导入java.io.*；
公共级机关枪{
公共静态最终字符串字典\u FILE=“C:\\Users\\Zoratu\\Desktop\\EvilHangman\\DICTIONARY.txt”；
public static final boolean DEBUG=false；//显示剩余单词
公共静态void main（字符串[]args）引发FileNotFoundException{
System.out.println（“欢迎来到cse143刽子手游戏”）；
System.out.println（）；
//打开字典文件并将字典读入ArrayList
扫描仪输入=新扫描仪（新文件（字典文件））；
列表字典=新的ArrayList（）；
while（input.hasNext（））{
add（input.next（）.toLowerCase（））；
}
//设置基本参数
扫描仪控制台=新扫描仪（System.in）；
System.out.print（“您希望使用的单词长度是多少？”）；
int length=console.nextInt（）；
System.out.print（“允许多少个错误答案？”）；
int max=console.nextInt（）；
System.out.println（）；
//设置刽子手经理并开始游戏
列表字典2=集合。不可修改列表（字典）；
hangman Manager hangman=新的hangman Manager（字典2，长度，最大值）；
if（hangman.words（）.isEmpty（））{
System.out.println（“在