文字列内の部分文字列の出現

次のアルゴリズムが停止しないのはなぜですか？（strは検索している文字列、findStrは検索しようとしている文字列です）

String str = "helloslkhellodjladfjhello";
String findStr = "hello";
int lastIndex = 0;
int count = 0;

while (lastIndex != -1) {
    lastIndex = str.indexOf(findStr,lastIndex);

    if( lastIndex != -1)
        count++;

    lastIndex += findStr.length();
}

System.out.println(count);

最後の行は問題を引き起こしていました。lastIndex-1になることはないため、無限ループが発生します。これは、コードの最後の行をifブロックに移動することで修正できます。

String str = "helloslkhellodjladfjhello";
String findStr = "hello";
int lastIndex = 0;
int count = 0;

while(lastIndex != -1){

    lastIndex = str.indexOf(findStr,lastIndex);

    if(lastIndex != -1){
        count ++;
        lastIndex += findStr.length();
    }
}
System.out.println(count);

Apache Commons LangのStringUtils.countMatchesを使用するのはどうですか？

String str = "helloslkhellodjladfjhello";
String findStr = "hello";

System.out.println(StringUtils.countMatches(str, findStr));

それは出力します：

3

あなたがlastIndex += findStr.length();無限ループ原因、括弧の外側に配置された（非出現が見られなかった、lastIndexのは常にありましたfindStr.length()）。

ここに修正バージョンがあります：

String str = "helloslkhellodjladfjhello";
String findStr = "hello";
int lastIndex = 0;
int count = 0;

while (lastIndex != -1) {

    lastIndex = str.indexOf(findStr, lastIndex);

    if (lastIndex != -1) {
        count++;
        lastIndex += findStr.length();
    }
}
System.out.println(count);

短いバージョン。;）

String str = "helloslkhellodjladfjhello";
String findStr = "hello";
System.out.println(str.split(findStr, -1).length-1);

あなたは本当に自分でマッチングを処理する必要がありますか？特に必要なのが出現回数だけである場合、正規表現の方が整然としています：

String str = "helloslkhellodjladfjhello";
Pattern p = Pattern.compile("hello");
Matcher m = p.matcher(str);
int count = 0;
while (m.find()){
    count +=1;
}
System.out.println(count);     

誰もこのライナーについて言及しなかったので、私はとても驚いています。シンプルで簡潔で、パフォーマンスはやや優れていますstr.split(target, -1).length-1

public static int count(String str, String target) {
    return (str.length() - str.replace(target, "").length()) / target.length();
}

ここでは、再利用可能な優れたメソッドにまとめました。

public static int count(String text, String find) {
        int index = 0, count = 0, length = find.length();
        while( (index = text.indexOf(find, index)) != -1 ) {                
                index += length; count++;
        }
        return count;
}

String str = "helloslkhellodjladfjhello";
String findStr = "hello";
int lastIndex = 0;
int count = 0;

while((lastIndex = str.indexOf(findStr, lastIndex)) != -1) {
     count++;
     lastIndex += findStr.length() - 1;
}
System.out.println(count);

ループ終了時のカウントは3です。それが役に立てば幸い

与えられた答えの多くは、以下の1つ以上で失敗します。

• 任意の長さのパターン
• 重複する一致（「23232」の「232」や「aaa」の「aa」など）
• 正規表現のメタ文字

これが私が書いたものです：

static int countMatches(Pattern pattern, String string)
{
    Matcher matcher = pattern.matcher(string);

    int count = 0;
    int pos = 0;
    while (matcher.find(pos))
    {
        count++;
        pos = matcher.start() + 1;
    }

    return count;
}

呼び出し例：

Pattern pattern = Pattern.compile("232");
int count = countMatches(pattern, "23232"); // Returns 2

正規表現以外の検索が必要な場合は、LITERALフラグを使用してパターンを適切にコンパイルします。

Pattern pattern = Pattern.compile("1+1", Pattern.LITERAL);
int count = countMatches(pattern, "1+1+1"); // Returns 2

public int countOfOccurrences(String str, String subStr) {
  return (str.length() - str.replaceAll(Pattern.quote(subStr), "").length()) / subStr.length();
}

lastIndex次の出現を探すたびに増分します。

それ以外の場合は、常に最初の部分文字列（位置0）が検索されます。

public int indexOf(int ch,
                   int fromIndex)

指定されたインデックスから検索を開始し、指定された文字が最初に出現するこの文字列内のインデックスを返します。

したがって、lastindex値は常に0であり、常に文字列でhelloを見つけます。

正しい答えは、改行などのカウントには適しておらず、冗長すぎます。後の答えはより良いですが、すべてが簡単に達成できます

str.split(findStr).length

質問の例では、末尾の一致は削除されません。

組み込みライブラリ関数を使用して、発生回数を指定できます。

import org.springframework.util.StringUtils;
StringUtils.countOccurrencesOf(result, "R-")

lastIndex+=findStr.length()ループの最後に追加してみてください。そうしないと、部分文字列を見つけたら、同じ最後の位置から何度も検索しようとするため、無限ループになります。

これを試してみてください。すべての一致をに置き換えます-。

String str = "helloslkhellodjladfjhello";
String findStr = "hello";
int numberOfMatches = 0;
while (str.contains(findStr)){
    str = str.replaceFirst(findStr, "-");
    numberOfMatches++;
}

そして、破壊したくない場合strは、同じ内容の新しい文字列を作成できます。

String str = "helloslkhellodjladfjhello";
String strDestroy = str;
String findStr = "hello";
int numberOfMatches = 0;
while (strDestroy.contains(findStr)){
    strDestroy = strDestroy.replaceFirst(findStr, "-");
    numberOfMatches++;
}

このブロックを実行した後、これらはあなたの値になります：

str = "helloslkhellodjladfjhello"
strDestroy = "-slk-djladfj-"
findStr = "hello"
numberOfMatches = 3

@Mr_and_Mrs_Dが示唆したように：

String haystack = "hellolovelyworld";
String needle = "lo";
return haystack.split(Pattern.quote(needle), -1).length - 1;

既存の回答に基づいて、以下の場合を除いた「より短い」バージョンを追加します。

String str = "helloslkhellodjladfjhello";
String findStr = "hello";

int count = 0, lastIndex = 0;
while((lastIndex = str.indexOf(findStr, lastIndex)) != -1) {
    lastIndex += findStr.length() - 1;
    count++;
}

System.out.println(count); // output: 3

これは、ユーザーが入力した文字列でトークンが発生した回数をカウントするための高度なバージョンです。

public class StringIndexOf {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);

        System.out.println("Enter a sentence please: \n");
        String string = scanner.nextLine();

        int atIndex = 0;
        int count = 0;

        while (atIndex != -1)
        {
            atIndex = string.indexOf("hello", atIndex);

            if(atIndex != -1)
            {
                count++;
                atIndex += 5;
            }
        }

        System.out.println(count);
    }

}

次のメソッドは、部分文字列が文字列全体で何回繰り返されるかを示しています。あなたにフル使用を願っています：-

    String searchPattern="aaa"; // search string
    String str="aaaaaababaaaaaa"; // whole string
    int searchLength = searchPattern.length(); 
    int totalLength = str.length(); 
    int k = 0;
    for (int i = 0; i < totalLength - searchLength + 1; i++) {
        String subStr = str.substring(i, searchLength + i);
        if (subStr.equals(searchPattern)) {
           k++;
        }

    }

regexp / patterns / matchersを使用しない、またはStringUtilsを使用しない他のソリューションを次に示します。

String str = "helloslkhellodjladfjhelloarunkumarhelloasdhelloaruhelloasrhello";
        String findStr = "hello";
        int count =0;
        int findStrLength = findStr.length();
        for(int i=0;i<str.length();i++){
            if(findStr.startsWith(Character.toString(str.charAt(i)))){
                if(str.substring(i).length() >= findStrLength){
                    if(str.substring(i, i+findStrLength).equals(findStr)){
                        count++;
                    }
                }
            }
        }
        System.out.println(count);

元の文字列内の各部分文字列のインデックスが必要な場合は、次のようにindexOfを使用して何かを行うことができます。

 private static List<Integer> getAllIndexesOfSubstringInString(String fullString, String substring) {
    int pointIndex = 0;
    List<Integer> allOccurences = new ArrayList<Integer>();
    while(fullPdfText.indexOf(substring,pointIndex) >= 0){
       allOccurences.add(fullPdfText.indexOf(substring, pointIndex));
       pointIndex = fullPdfText.indexOf(substring, pointIndex) + substring.length();
    }
    return allOccurences;
}

public static int getCountSubString(String str , String sub){
int n = 0, m = 0, counter = 0, counterSub = 0;
while(n < str.length()){
  counter = 0;
  m = 0;
  while(m < sub.length() && str.charAt(n) == sub.charAt(m)){
    counter++;
    m++; n++;
  }
  if (counter == sub.length()){
    counterSub++;
    continue;
  }
  else if(counter > 0){
    continue;
  }
  n++;
}

return  counterSub;

}

このソリューションは、文字列全体にわたる特定の部分文字列の出現回数の合計を出力します。また、一致する重複が存在する場合も含まれます。

class SubstringMatch{
    public static void main(String []args){
        //String str = "aaaaabaabdcaa";
        //String sub = "aa";
        //String str = "caaab";
        //String sub = "aa";
        String str="abababababaabb";
        String sub = "bab";

        int n = str.length();
        int m = sub.length();

        // index=-1 in case of no match, otherwise >=0(first match position)
        int index=str.indexOf(sub), i=index+1, count=(index>=0)?1:0;
        System.out.println(i+" "+index+" "+count);

        // i will traverse up to only (m-n) position
        while(index!=-1 && i<=(n-m)){   
            index=str.substring(i, n).indexOf(sub);
            count=(index>=0)?count+1:count;
            i=i+index+1;  
            System.out.println(i+" "+index);
        }
        System.out.println("count: "+count);
    }
}