Vorkommen von Teilzeichenfolgen in einer Zeichenfolge

Warum hält der folgende Algorithmus für mich nicht an? (str ist die Zeichenfolge, in der ich suche, findStr ist die Zeichenfolge, die ich zu finden versuche)

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);

Die letzte Zeile verursachte ein Problem. lastIndexwürde niemals bei -1 sein, also würde es eine Endlosschleife geben. Dies kann behoben werden, indem die letzte Codezeile in den if-Block verschoben wird.

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);

Wie wäre es mit StringUtils.countMatches von Apache Commons Lang?

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

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

Das gibt aus:

3

Ihr lastIndex += findStr.length();wurde außerhalb der Klammern platziert, was eine Endlosschleife verursachte (wenn kein Vorkommen gefunden wurde, war lastIndex immer zu findStr.length()).

Hier ist die feste Version:

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);

Eine kürzere Version. ;)

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

Müssen Sie das Matching wirklich selbst erledigen? Besonders wenn Sie nur die Anzahl der Vorkommen benötigen, sind reguläre Ausdrücke aufgeräumter:

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);     

Ich bin sehr überrascht, dass niemand diesen einen Liner erwähnt hat. Es ist einfach, prägnant und bietet eine etwas bessere Leistung alsstr.split(target, -1).length-1

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

Hier ist es, eingepackt in eine schöne und wiederverwendbare Methode:

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);

am Ende der Schleife beträgt die Anzahl 3; ich hoffe es hilft

Viele der gegebenen Antworten schlagen bei einer oder mehreren der folgenden fehl:

• Muster beliebiger Länge
• Überlappende Übereinstimmungen (z. B. "232" in "23232" oder "aa" in "aaa" zählen)
• Metazeichen für reguläre Ausdrücke

Folgendes habe ich geschrieben:

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;
}

Beispielaufruf:

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

Wenn Sie eine Suche mit nicht regulären Ausdrücken wünschen, kompilieren Sie Ihr Muster einfach entsprechend mit dem LITERALFlag:

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();
}

Zuwachs lastIndex Sie, wann immer Sie nach dem nächsten Auftreten suchen.

Andernfalls wird immer der erste Teilstring gefunden (an Position 0).

public int indexOf(int ch,
                   int fromIndex)

Gibt den Index innerhalb dieser Zeichenfolge des ersten Vorkommens des angegebenen Zeichens zurück und startet die Suche am angegebenen Index.

Ihr lastindexWert ist also immer 0 und er findet immer Hallo in der Zeichenfolge.

Die als richtig gegebene Antwort eignet sich nicht zum Zählen von Zeilenrückläufen und ist viel zu ausführlich. Spätere Antworten sind besser, aber alles kann einfach mit erreicht werden

str.split(findStr).length

Nach dem Beispiel in der Frage werden keine nachfolgenden Übereinstimmungen gelöscht.

Sie können die Anzahl der Vorkommen mithilfe der integrierten Bibliotheksfunktion festlegen:

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

Versuchen Sie lastIndex+=findStr.length(), am Ende Ihrer Schleife etwas hinzuzufügen , da Sie sonst in einer Endlosschleife landen, da Sie, sobald Sie den Teilstring gefunden haben, versuchen, ihn immer wieder von derselben letzten Position aus zu finden.

Probier diese. Es ersetzt alle Übereinstimmungen durch a -.

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

Und wenn Sie Ihre nicht zerstören möchten, können strSie eine neue Zeichenfolge mit demselben Inhalt erstellen:

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

Nach dem Ausführen dieses Blocks sind dies Ihre Werte:

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

Wie @Mr_and_Mrs_D vorgeschlagen hat:

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

Basierend auf den vorhandenen Antworten möchte ich eine "kürzere" Version ohne das if hinzufügen:

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

Hier ist die erweiterte Version zum Zählen, wie oft das Token in einer vom Benutzer eingegebenen Zeichenfolge aufgetreten ist:

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);
    }

}

Die folgende Methode zeigt, wie oft sich Teilzeichenfolgen auf Ihrer gesamten Zeichenfolge wiederholen. Hoffe, Sie voll zu nutzen: -

    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++;
        }

    }

Hier ist die andere Lösung, ohne Regexp / Patterns / Matcher zu verwenden oder StringUtils nicht zu verwenden.

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);

Wenn Sie den Index jeder Teilzeichenfolge in der ursprünglichen Zeichenfolge benötigen, können Sie mit indexOf Folgendes tun:

 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;

}}

Diese Lösung gibt die Gesamtzahl des Auftretens eines bestimmten Teilstrings in der gesamten Zeichenfolge aus und schließt auch die Fälle ein, in denen überlappende Übereinstimmungen vorhanden sind.

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);
    }
}