[Java] Vorkommen von Teilstrings in einem String


Answers

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 ergibt:

3
Question

Warum stoppt der folgende Algorithmus nicht für mich? (str ist die Zeichenfolge, in der ich suche, findStr ist die Zeichenfolge, die ich suche)

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

EDIT- aktualisiert, funktioniert immer noch nicht




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 lastindex Wert ist also immer 0 und findet immer hallo in der Zeichenfolge.




Müssen Sie das Matching wirklich selbst regeln? Vor allem, wenn Sie nur die Anzahl der Vorkommen brauchen, 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);     



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



Ich kann nicht glauben, dass niemand diesen Einliner erwähnt hat. Es ist einfach, prägnant und führt etwas besser als str.split(target, -1).length-1

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



Versuchen Sie, lastIndex+=findStr.length() am Ende Ihrer Schleife hinzuzufügen, sonst landen Sie in einer Endlosschleife, weil Sie, sobald Sie den Teilstring gefunden haben, versuchen, ihn von der gleichen letzten Position aus wiederzufinden.




Die folgende Methode zeigt, wie viele Zeit-Teilstrings sich in der ganzen Zeichenfolge wiederholen. Hoffe Gebrauch voll zu dir: -

    String search_pattern="aaa";
    String whole_pattern=""aaaaaababaaaaaa;
    int j = search_pattern.length();
    for (int i = 0; i < whole_pattern.length() - j + 1; i++) {

        String str1 = whole_pattern.substring(i, j + i);

        System.out.println("sub string loop " + i + " => " + str1);

        if (str1.equals(search_pattern)) {
            Constants.k++;
        }

    }



Wenn Sie den Index jedes Teilstrings innerhalb des ursprünglichen Strings benötigen, können Sie etwas mit indexOf wie folgt 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;
}



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 ist die Anzahl 3; ich hoffe es hilft




Auf der Grundlage der vorhandenen Antwort (en) 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



Die Antwort, die als richtig angegeben wird, ist nicht gut zum Zählen von Dingen wie Zeilenrückgaben und ist viel zu ausführlich. Spätere Antworten sind besser, aber alle können einfach mit erreicht werden

str.split(findStr).length

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