Java 有没有办法找到文本中模式的所有匹配项，而不是在Boyer-Moore算法中找到第一个匹配项

我正在用java开发Boyer-Moore字符串匹配算法，这样它就可以在阿拉伯语文本上充分发挥作用，我有代码可以找到模式的第一个匹配项，而不是所有匹配项

我试图对其进行修改，但无效，我得到了arrayIndexoutofbounds异常。
我得到的例外是：

线程“main”java.lang.ArrayIndexOutOfBoundsException中的异常： -1在BM.findPattern（BM.java:27）在BM.main（BM.java:110）上

其目的是修改算法，使其能够处理语音阿拉伯文本。 以下是输入和输出示例： 输入文本

阿纳纳

输入模式

安娜 在位置0处找到 然后我得到了上面的例外

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;


   /** Class BoyerMoore **/
 public class BM
 {
    /** function findPattern **/
    public void findPattern(String t, String p)
    {
        char[] text = t.toCharArray();
        char[] pattern = p.toCharArray();

        int pos = indexOf(text, pattern);
        if (pos == -1)
            System.out.println("\nNo Match\n");
        else
            System.out.println("Pattern found at position : "+ pos);



    }
    /** Function to calculate index of pattern substring **/
    public int indexOf(char[] text, char[] pattern) 
    {
        if (pattern.length == 0) 
            return 0;
        int charTable[] = makeCharTable(pattern);
        int offsetTable[] = makeOffsetTable(pattern);
        for (int i = pattern.length - 1, j; i < text.length;) 
        {
            for (j = pattern.length - 1; pattern[j] == text[i]; --i, --j) 
                     if (j == 0) 
                    return i;

              // i += pattern.length - j; // For naive method
              i += Math.max(offsetTable[pattern.length - 1 - j], 
        charTable[text[i]]);
        }
        return -1;
      }
      /** Makes the jump table based on the mismatched character 
       information **/
      private int[] makeCharTable(char[] pattern) 
      {
        final int ALPHABET_SIZE = 256;
        int[] table = new int[ALPHABET_SIZE];
        for (int i = 0; i < table.length; ++i) 
               table[i] = pattern.length;
        for (int i = 0; i < pattern.length - 1; ++i) 
               table[pattern[i]] = pattern.length - 1 - i;
        return table;
      }
      /** Makes the jump table based on the scan offset which mismatch 
      occurs. **/
      private static int[] makeOffsetTable(char[] pattern) 
      {
        int[] table = new int[pattern.length];
        int lastPrefixPosition = pattern.length;
        for (int i = pattern.length - 1; i >= 0; --i) 
        {
            if (isPrefix(pattern, i + 1)) 
                   lastPrefixPosition = i + 1;
              table[pattern.length - 1 - i] = lastPrefixPosition - i + 
         pattern.length - 1;
        }
        for (int i = 0; i < pattern.length - 1; ++i) 
        {
              int slen = suffixLength(pattern, i);
              table[slen] = pattern.length - 1 - i + slen;
        }
        return table;
    }
    /** function to check if needle[p:end] a prefix of pattern **/
    private static boolean isPrefix(char[] pattern, int p) 
    {
        for (int i = p, j = 0; i < pattern.length; ++i, ++j) 
            if (pattern[i] != pattern[j]) 
                  return false;
        return true;
    }
    /** function to returns the maximum length of the substring ends at p and is a suffix **/
    private static int suffixLength(char[] pattern, int p) 
    {
        int len = 0;
        for (int i = p, j = pattern.length - 1; i >= 0 && pattern[i] == pattern[j]; --i, --j) 
               len += 1;
        return len;
    }
    /** Main Function **/
    public static void main(String[] args) throws IOException
    {    
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("Boyer Moore Algorithm Test\n");
        System.out.println("\nEnter Text\n");
        String text = br.readLine();
        System.out.println("\nEnter Pattern\n");
        String pattern = br.readLine();
        BM bm = new BM(); 
        bm.findPattern(text, pattern);     
    }
}

导入java.io.BufferedReader；
导入java.io.InputStreamReader；
导入java.io.IOException；
/**男孩门**/
公共级BM
{
/**函数findPattern**/
公共void findPattern（字符串t、字符串p）
{
char[]text=t.toCharArray（）；
char[]pattern=p.toCharArray（）；
int pos=indexOf（文本、模式）；
如果（位置==-1）
System.out.println（“\n不匹配\n”）；
其他的
System.out.println（“在位置：+pos处找到的图案”）；
}
/**用于计算模式子字符串索引的函数**/
public int indexOf（字符[]文本，字符[]模式）
{
if（pattern.length==0）
返回0；
int charTable[]=makeCharTable（模式）；
int offsetable[]=makeoffsetable（模式）；
for（int i=pattern.length-1，j；i=0；--i）
{
if（isPrefix（模式，i+1））
lastPrefixPosition=i+1；
表[pattern.length-1-i]=lastprofixposition-i+
模式长度-1；
}
对于（int i=0；i=0&&pattern[i]==pattern[j]；-i，--j）
len+=1；
回程透镜；
}
/**主要功能**/
公共静态void main（字符串[]args）引发IOException
{    
BufferedReader br=新的BufferedReader（新的InputStreamReader（System.in））；
System.out.println（“Boyer-Moore算法测试”）；
System.out.println（“\n输入文本\n”）；
String text=br.readLine（）；
System.out.println（“\n输入模式\n”）；
字符串模式=br.readLine（）；
BM BM=新的BM（）；
bm.findPattern（文本、模式）；
}
}

代码中哪一行是第27行？您的代码中似乎缺少某些内容，

findPattern

中没有任何内容可能引发

ArrayIndexOutOfBoundsException

。或者缺少stachtrace的一部分。能否提供一些示例输入和预期输出？到目前为止，它似乎运行良好。卡杜肯，它只适用于第一次出现的图案。