Виникнення підрядок у рядку

Чому наступний алгоритм не зупиняється для мене? (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);

Як щодо використання StringUtils.countMatches від Apache Commons Lang?

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

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

Це виводить:

3

Вас lastIndex += findStr.length();розміщували поза дужками, викликаючи нескінченну петлю (коли не було виявлено випадків, останній завжди був в цьому 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; сподіваюся, що це допомагає

Багато відповідей не відповідають одній або декільком з:

• Шаблони довільної довжини
• Матчі, що перекриваються (наприклад, підрахунок "232" у "23232" або "аа" в "ааа")
• Метасимволи регулярного вираження

Ось що я написав:

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, і воно завжди знаходить привіт у рядку.

Відповідь, подана як правильна, не корисна для підрахунку таких речей, як повернення рядка, і є занадто багатослівною. Пізніші відповіді краще, але все можна досягти просто

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;

Виходячи з існуючих відповідей, я хотів би додати "коротшу" версію без 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

Ось розширена версія підрахунку, скільки разів маркер траплявся в рядок, що вводиться користувачем:

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