Ocurrencias de subcadenas en una cadena

¿Por qué el siguiente algoritmo no se detiene para mí? (str es la cadena que estoy buscando, findStr es la cadena que estoy tratando de encontrar)

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 última línea estaba creando un problema. lastIndexnunca estaría en -1, por lo que habría un bucle infinito. Esto se puede solucionar moviendo la última línea de código al bloque 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);

¿Qué tal usar StringUtils.countMatches de Apache Commons Lang?

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

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

Eso da salida:

3

Su lastIndex += findStr.length();se colocó fuera de los corchetes, causando un bucle infinito (cuando no se encontró ninguna ocurrencia, lastIndex siempre fue así findStr.length()).

Aquí está la versión fija:

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

Una versión más corta ;)

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

¿Realmente tienes que manejar el emparejamiento tú mismo? Especialmente si todo lo que necesita es el número de ocurrencias, las expresiones regulares son más ordenadas:

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

Estoy muy sorprendido de que nadie haya mencionado este revestimiento. Es simple, conciso y funciona ligeramente mejor questr.split(target, -1).length-1

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

Aquí está, envuelto en un método agradable y reutilizable:

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

al final del ciclo el conteo es 3; Espero eso ayude

Muchas de las respuestas dadas fallan en uno o más de:

• Patrones de longitud arbitraria.
• Partidas superpuestas (como contar "232" en "23232" o "aa" en "aaa")
• Metacaracteres de expresiones regulares

Esto es lo que escribí:

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

Llamada de ejemplo:

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

Si desea una búsqueda de expresión no regular, solo compile su patrón apropiadamente con la LITERALbandera:

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

Incremente lastIndexsiempre que busque la próxima ocurrencia.

De lo contrario, siempre se encuentra la primera subcadena (en la posición 0).

public int indexOf(int ch,
                   int fromIndex)

Devuelve el índice dentro de esta cadena de la primera aparición del carácter especificado, comenzando la búsqueda en el índice especificado.

Por lo tanto, su lastindexvalor siempre es 0 y siempre encuentra hola en la cadena.

La respuesta dada como correcta no es buena para contar cosas como los retornos de línea y es demasiado detallada. Las respuestas posteriores son mejores, pero todo se puede lograr simplemente con

str.split(findStr).length

No deja caer las coincidencias finales utilizando el ejemplo de la pregunta.

Puede hacer un número de ocurrencias usando la función de biblioteca incorporada:

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

intente agregar lastIndex+=findStr.length()al final de su ciclo, de lo contrario terminará en un ciclo sin fin porque una vez que encontró la subcadena, está tratando de encontrarla una y otra vez desde la misma última posición.

Prueba este. Reemplaza todos los partidos con a -.

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

Y si no quieres destruir tu strpuedes crear una nueva cadena con el mismo contenido:

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

Después de ejecutar este bloque, estos serán sus valores:

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

Como @Mr_and_Mrs_D sugirió:

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

Según las respuestas existentes, me gustaría agregar una versión "más corta" sin el if:

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

Aquí está la versión avanzada para contar cuántas veces se produjo el token en una cadena ingresada por el usuario:

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

}

El siguiente método muestra cuántas veces se repite la subcadena en su cadena completa. Espero uso completo para usted: -

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

    }

Aquí está la otra solución sin usar regexp / patterns / matchers o incluso sin usar 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 necesita el índice de cada subcadena dentro de la cadena original, puede hacer algo con indexOf de esta manera:

 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;

}

Esta solución imprime el número total de ocurrencias de una subcadena dada en toda la cadena, también incluye los casos en los que existen coincidencias superpuestas.

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