Sự xuất hiện của chuỗi con trong một chuỗi

Tại sao thuật toán sau không tạm dừng đối với tôi? (str là chuỗi tôi đang tìm kiếm, findStr là chuỗi tôi đang cố gắng tìm)

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

Dòng cuối cùng đang tạo ra một vấn đề. lastIndexsẽ không bao giờ ở -1, vì vậy sẽ có một vòng lặp vô hạn. Điều này có thể được khắc phục bằng cách chuyển dòng mã cuối cùng vào khối 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);

Làm thế nào về việc sử dụng StringUtils.countMatches từ Apache Commons Lang?

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

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

Kết quả đầu ra:

3

Của bạn lastIndex += findStr.length();được đặt bên ngoài dấu ngoặc, gây ra một vòng lặp vô hạn (khi không tìm thấy sự xuất hiện nào, lastIndex luôn làfindStr.length() ).

Đây là phiên bản cố định:

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

Một phiên bản ngắn hơn. ;)

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

Bạn có thực sự phải tự mình xử lý kết hợp không? Đặc biệt nếu tất cả những gì bạn cần là số lần xuất hiện, thì biểu thức chính quy sẽ gọn hơn:

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

Tôi rất ngạc nhiên là không ai đề cập đến cái lót này. Nó đơn giản, ngắn gọn và hoạt động tốt hơn một chút so vớistr.split(target, -1).length-1

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

Nó đây, được gói gọn trong một phương pháp hay và có thể tái sử dụng:

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

ở cuối vòng lặp số đếm là 3; hy vọng nó giúp

Rất nhiều câu trả lời được đưa ra không thành công với một hoặc nhiều:

• Các mẫu có độ dài tùy ý
• Các kết quả trùng lặp (chẳng hạn như đếm "232" trong "23232" hoặc "aa" trong "aaa")
• Ký tự meta biểu thức chính quy

Đây là những gì tôi đã viết:

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

Cuộc gọi ví dụ:

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

Nếu bạn muốn tìm kiếm không phải cụm từ thông dụng, chỉ cần biên dịch mẫu của bạn một cách thích hợp với LITERALcờ:

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

Sự gia tăng lastIndexbất cứ khi nào bạn tìm kiếm sự xuất hiện tiếp theo.

Nếu không, nó luôn tìm thấy chuỗi con đầu tiên (ở vị trí 0).

public int indexOf(int ch,
                   int fromIndex)

Trả về chỉ mục trong chuỗi này của lần xuất hiện đầu tiên của ký tự được chỉ định, bắt đầu tìm kiếm tại chỉ mục được chỉ định.

Vì vậy, lastindexgiá trị của bạn luôn là 0 và nó luôn tìm thấy hello trong chuỗi.

Câu trả lời được đưa ra là đúng sẽ không tốt cho việc đếm những thứ như trả về dòng và quá dài dòng. Câu trả lời sau này tốt hơn nhưng tất cả đều có thể đạt được đơn giản với

str.split(findStr).length

Nó không bỏ các kết quả phù hợp theo sau bằng cách sử dụng ví dụ trong câu hỏi.

Bạn có thể đánh số lần xuất hiện bằng cách sử dụng hàm thư viện có sẵn:

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

hãy thử thêm lastIndex+=findStr.length()vào cuối vòng lặp của bạn, nếu không bạn sẽ kết thúc trong một vòng lặp vô tận vì một khi bạn tìm thấy chuỗi con, bạn đang cố gắng tìm lại nó từ cùng một vị trí cuối cùng.

Hãy thử cái này. Nó thay thế tất cả các trận đấu bằng a -.

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

Và nếu bạn không muốn phá hủy của strbạn, bạn có thể tạo một chuỗi mới có cùng nội dung:

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

Sau khi thực hiện khối này, đây sẽ là các giá trị của bạn:

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

Như @Mr_and_Mrs_D đã đề xuất:

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

Dựa trên (các) câu trả lời hiện có, tôi muốn thêm phiên bản "ngắn hơn" mà không có 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

Đây là phiên bản nâng cao để đếm số lần mã thông báo xảy ra trong một chuỗi do người dùng nhập:

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

}

Phương thức dưới đây cho biết số lần lặp lại chuỗi con trên toàn bộ chuỗi của bạn. Hy vọng sử dụng đầy đủ cho bạn: -

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

    }

đây là giải pháp khác mà không cần sử dụng regexp / pattern / matchers hoặc thậm chí không sử dụng 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);

Nếu bạn cần chỉ mục của từng chuỗi con trong chuỗi ban đầu, bạn có thể thực hiện điều gì đó với indexOf như sau:

 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;

}

Giải pháp này in ra tổng số lần xuất hiện của một chuỗi con nhất định trong suốt chuỗi, cũng bao gồm các trường hợp có các kết quả trùng lặp tồn tại.

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