Occurrences de sous-chaîne dans une chaîne

Pourquoi l'algorithme suivant ne s'arrête pas pour moi? (str est la chaîne dans laquelle je recherche, findStr est la chaîne que j'essaie de trouver)

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

La dernière ligne créait un problème. lastIndexne serait jamais à -1, donc il y aurait une boucle infinie. Cela peut être résolu en déplaçant la dernière ligne de code dans le bloc 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);

Que diriez-vous d'utiliser StringUtils.countMatches d'Apache Commons Lang?

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

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

Cela produit:

3

Votre a lastIndex += findStr.length();été placé en dehors des crochets, provoquant une boucle infinie (quand aucune occurrence n'a été trouvée, lastIndex était toujours à findStr.length()).

Voici la version fixe:

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

Une version plus courte. ;)

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

Devez-vous vraiment gérer la correspondance vous-même? Surtout si tout ce dont vous avez besoin est le nombre d'occurrences, les expressions régulières sont plus ordonnées:

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

Je suis très surpris que personne n'ait mentionné cette seule doublure. C'est simple, concis et fonctionne légèrement mieux questr.split(target, -1).length-1

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

Le voici, enveloppé dans une méthode agréable et réutilisable:

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

à la fin du nombre de boucles, 3; J'espère que ça aide

Un grand nombre des réponses données échouent sur un ou plusieurs des éléments suivants:

• Modèles de longueur arbitraire
• Correspondances qui se chevauchent (par exemple, compter "232" dans "23232" ou "aa" dans "aaa")
• Méta-caractères d'expression régulière

Voici ce que j'ai écrit:

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

Exemple d'appel:

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

Si vous voulez une recherche non-expression régulière, compilez simplement votre modèle de manière appropriée avec l' LITERALindicateur:

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

Incrémentez lastIndexchaque fois que vous recherchez la prochaine occurrence.

Sinon, il trouve toujours la première sous-chaîne (à la position 0).

public int indexOf(int ch,
                   int fromIndex)

Renvoie l'index dans cette chaîne de la première occurrence du caractère spécifié, en commençant la recherche à l'index spécifié.

Donc, votre lastindexvaleur est toujours 0 et elle trouve toujours bonjour dans la chaîne.

La réponse donnée comme correcte n'est pas bonne pour compter des choses comme les retours de ligne et est beaucoup trop verbeuse. Les réponses ultérieures sont meilleures mais tout peut être réalisé simplement avec

str.split(findStr).length

Il ne supprime pas les correspondances de fin en utilisant l'exemple de la question.

Vous pouvez nombre d'occurrences en utilisant la fonction de bibliothèque intégrée:

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

essayez d'ajouter lastIndex+=findStr.length()à la fin de votre boucle, sinon vous vous retrouverez dans une boucle sans fin car une fois que vous avez trouvé la sous-chaîne, vous essayez de la retrouver encore et encore à partir de la même dernière position.

Essaye celui-là. Il remplace toutes les correspondances par un -.

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

Et si vous ne voulez pas détruire votre, strvous pouvez créer une nouvelle chaîne avec le même contenu:

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

Après avoir exécuté ce bloc, ce seront vos valeurs:

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

Comme @Mr_and_Mrs_D l'a suggéré:

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

Sur la base des réponses existantes, j'aimerais ajouter une version "plus courte" sans le si:

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

Voici la version avancée pour compter le nombre de fois où le jeton s'est produit dans une chaîne saisie par l'utilisateur:

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

}

Cette méthode ci-dessous montre combien de fois la sous-chaîne se répète sur toute votre chaîne. J'espère utiliser pleinement pour vous: -

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

    }

voici l'autre solution sans utiliser regexp / patterns / matchers ou même sans utiliser 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);

Si vous avez besoin de l'index de chaque sous-chaîne dans la chaîne d'origine, vous pouvez faire quelque chose avec indexOf comme ceci:

 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;

}

Cette solution imprime le nombre total d'occurrences d'une sous-chaîne donnée tout au long de la chaîne, inclut également les cas où des correspondances se chevauchent.

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