java - 有没有办法找到文本中所有模式的出现，而不是在 Boyer Moore 算法中找到第一次出现

Question

我正在研究 Java 中的 Boyer Moore 字符串匹配算法，因此它可以充分处理阿拉伯文本，我有代码可以找到模式的第一次出现而不是所有出现。

我试图对其进行修改，但它不起作用，我得到了 arrayIndexoutofbounds 异常。
我得到的例外是：

线程“main”中的异常 java.lang.ArrayIndexOutOfBoundsException: BM.findPattern(BM.java:27) 处 BM.main(BM.java:110) 处 -1

目的是修改算法，使其可以处理发声的阿拉伯语文本。这是输入和输出的示例：输入文本

安娜那那那那

输入模式

ana 在位置 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);     
    }
}