Java 在字符串中查找子字符串的匹配项

我试图找到给定字符串中的子字符串数。目前，我的代码没有考虑重叠字符串

比如说

substr=“cde” str=“cdcde”

我的代码：

public static int ssCount(String str, String substr) {
    int count = 0;
    int strlen = str.length();
    int substrlen = substr.length();
    int numsubstr = 0;
    int substrpointer = 0;

    for (int i = 0; i < strlen; i++) {
        if (str.charAt(i) == substr.charAt(substrpointer)) {
            substrpointer++;
            count++;
        }
        else {
            count = 0;
            substrpointer = 0;
        }
        if (count == substrlen) {
            numsubstr++;
            count = 0;
        }
    }
    return numsubstr;
    }

publicstaticintsscount（stringstr，stringsubstr）{
整数计数=0；
int strlen=str.length（）；
int substrlen=substr.length（）；
int numsubstr=0；
int substrpointer=0；
对于（int i=0；i

我的尝试：

public static int ssCount(String str, String substr) {
        int count = 0;
        int strlen = str.length();
        int substrlen = substr.length();
        int numsubstr = 0;
        int substrpointer = 0;
        int firstchar = 0;

        for (int i = 0; i < strlen; i++) {
            if (str.charAt(i) == substr.charAt(substrpointer)) {
                substrpointer++;
                count++;
                if (str.charAt(i) == substr.charAt(0)) {
                    firstchar = i;
                }
            }
            else {
                count = 0;
                substrpointer = 0;
                i = firstchar;
            }
            if (count == substrlen) {
                numsubstr++;
                count = 0;
            }
        }
        return numsubstr;
    }

publicstaticintsscount（stringstr，stringsubstr）{
整数计数=0；
int strlen=str.length（）；
int substrlen=substr.length（）；
int numsubstr=0；
int substrpointer=0；
int firstchar=0；
对于（int i=0；i

---

我尝试添加第二个指针，指向子字符串第一个字符的下一个匹配项，以便从该点继续比较。但是我遇到了麻烦，因为我可能会遇到一些无限循环。

不确定您的问题是什么，可能是如何修复代码，但我的建议是研究解决此问题的标准方法，例如KMP算法。它还有效地考虑了重叠。

不确定您的问题是什么，可能是如何修复代码，但我的建议是研究解决此问题的标准方法，例如KMP算法。它还有效地考虑了重叠。

不确定您的问题是什么，可能是如何修复代码，但我的建议是研究解决此问题的标准方法，例如KMP算法。它还有效地考虑了重叠。

不确定您的问题是什么，可能是如何修复代码，但我的建议是研究解决此问题的标准方法，例如KMP算法。它还有效地考虑了重叠。

这将在较大的字符串中查找所有重叠的子字符串。非正则表达式之后是正则表达式。一个有趣的问题

import  java.util.regex.Pattern;
import  java.util.regex.Matcher;

 /**
    <P>{@code java OverlappingSubstringsXmpl}</P>
  **/
 public class OverlappingSubstringsXmpl  {
    public static final void main(String[] igno_red)  {
      String sToFind = "cdc";
      String sToSearch = "cdcdcdedcdc";

      System.out.println("Non regex way:");

         int iMinIdx = 0;
         while(iMinIdx <= (sToSearch.length() - sToFind.length()))  {
            int iIdxFound = sToSearch.indexOf(sToFind, iMinIdx);

            if(iIdxFound == -1)  {
               break;
            }

             System.out.println(sToFind + " found at index " + iIdxFound);

            iMinIdx = iIdxFound + 1;
         }

      System.out.println("Regex way:");

         Matcher m = Pattern.compile(sToFind, Pattern.LITERAL).matcher(sToSearch);
         boolean bFound = m.find();
         while (bFound) {
            System.out.println(sToFind + " found at index " + m.start());
            bFound = m.find(m.start() + 1);
         }
   }
}

---

这将在较大的字符串中查找所有重叠的子字符串。非正则表达式之后是正则表达式。一个有趣的问题

import  java.util.regex.Pattern;
import  java.util.regex.Matcher;

 /**
    <P>{@code java OverlappingSubstringsXmpl}</P>
  **/
 public class OverlappingSubstringsXmpl  {
    public static final void main(String[] igno_red)  {
      String sToFind = "cdc";
      String sToSearch = "cdcdcdedcdc";

      System.out.println("Non regex way:");

         int iMinIdx = 0;
         while(iMinIdx <= (sToSearch.length() - sToFind.length()))  {
            int iIdxFound = sToSearch.indexOf(sToFind, iMinIdx);

            if(iIdxFound == -1)  {
               break;
            }

             System.out.println(sToFind + " found at index " + iIdxFound);

            iMinIdx = iIdxFound + 1;
         }

      System.out.println("Regex way:");

         Matcher m = Pattern.compile(sToFind, Pattern.LITERAL).matcher(sToSearch);
         boolean bFound = m.find();
         while (bFound) {
            System.out.println(sToFind + " found at index " + m.start());
            bFound = m.find(m.start() + 1);
         }
   }
}

---

这将在较大的字符串中查找所有重叠的子字符串。非正则表达式之后是正则表达式。一个有趣的问题

import  java.util.regex.Pattern;
import  java.util.regex.Matcher;

 /**
    <P>{@code java OverlappingSubstringsXmpl}</P>
  **/
 public class OverlappingSubstringsXmpl  {
    public static final void main(String[] igno_red)  {
      String sToFind = "cdc";
      String sToSearch = "cdcdcdedcdc";

      System.out.println("Non regex way:");

         int iMinIdx = 0;
         while(iMinIdx <= (sToSearch.length() - sToFind.length()))  {
            int iIdxFound = sToSearch.indexOf(sToFind, iMinIdx);

            if(iIdxFound == -1)  {
               break;
            }

             System.out.println(sToFind + " found at index " + iIdxFound);

            iMinIdx = iIdxFound + 1;
         }

      System.out.println("Regex way:");

         Matcher m = Pattern.compile(sToFind, Pattern.LITERAL).matcher(sToSearch);
         boolean bFound = m.find();
         while (bFound) {
            System.out.println(sToFind + " found at index " + m.start());
            bFound = m.find(m.start() + 1);
         }
   }
}

---

这将在较大的字符串中查找所有重叠的子字符串。非正则表达式之后是正则表达式。一个有趣的问题

import  java.util.regex.Pattern;
import  java.util.regex.Matcher;

 /**
    <P>{@code java OverlappingSubstringsXmpl}</P>
  **/
 public class OverlappingSubstringsXmpl  {
    public static final void main(String[] igno_red)  {
      String sToFind = "cdc";
      String sToSearch = "cdcdcdedcdc";

      System.out.println("Non regex way:");

         int iMinIdx = 0;
         while(iMinIdx <= (sToSearch.length() - sToFind.length()))  {
            int iIdxFound = sToSearch.indexOf(sToFind, iMinIdx);

            if(iIdxFound == -1)  {
               break;
            }

             System.out.println(sToFind + " found at index " + iIdxFound);

            iMinIdx = iIdxFound + 1;
         }

      System.out.println("Regex way:");

         Matcher m = Pattern.compile(sToFind, Pattern.LITERAL).matcher(sToSearch);
         boolean bFound = m.find();
         while (bFound) {
            System.out.println(sToFind + " found at index " + m.start());
            bFound = m.find(m.start() + 1);
         }
   }
}

---

---

为什么不使用regex和

Matcher

？您的可能副本似乎还没有任何问题。这不是一个真正的问题，所以投票决定结束。为什么不使用regex和

Matcher

？您的可能副本似乎还没有任何问题。这不是一个真正的问题，所以投票决定结束。为什么不使用regex和

Matcher

？您的可能副本似乎还没有任何问题。这不是一个真正的问题，所以投票决定结束。为什么不使用regex和

Matcher

？您的可能副本似乎还没有任何问题。这不是一个真正的问题，所以投票决定结束。或者Z算法，对实现者来说比较简单Z算法，对实现者来说比较简单Z算法，对实现者来说比较简单Z算法，对实现者来说比较简单通过重叠他指的是类似于

pattern=“aba”

和

string=“ababa”

（两个重叠匹配）啊。OP说的是“重叠”，但他的例子“cdcde”是不重叠的。我明白了。我认为他根本无法使用任何匹配算法。更新以处理重叠。重叠的意思是类似于

pattern=“aba”

和

string=“aba”

（两个重叠匹配）啊。OP说的是“重叠”，但他的例子“cdcde”是不重叠的。我明白了。我认为他根本无法让任何匹配算法工作。更新以处理重叠。通过重叠，他指的是像

pattern=“aba”

和

string=“ababa”

（两个重叠匹配）啊。OP说的是“重叠”，但他的例子是“CDCDCDE”“没有重叠，我明白了。我认为他根本无法使用任何匹配算法。更新以处理重叠。重叠的意思是像

pattern=“aba”

和

string=“ababa”

（两个重叠匹配）啊。OP说“重叠”，但他的例子“cdcde”并不重叠。我明白了。我想他根本无法找到匹配算法。更新后可以处理重叠。