Terjadinya substring dalam sebuah string

Mengapa algoritme berikut tidak berhenti untuk saya? (str adalah string yang saya cari, findStr adalah string yang saya coba temukan)

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

Baris terakhir membuat masalah. lastIndextidak akan pernah berada di -1, jadi akan ada loop tak terbatas. Ini dapat diperbaiki dengan memindahkan baris kode terakhir ke blok 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);

Bagaimana kalau menggunakan StringUtils.countMatches dari Apache Commons Lang?

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

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

Output itu:

3

Anda lastIndex += findStr.length();ditempatkan di luar tanda kurung, menyebabkan pengulangan tak terbatas (ketika tidak ada kemunculan yang ditemukan, lastIndex selalu ke findStr.length()).

Ini adalah versi tetapnya:

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

Versi yang lebih pendek. ;)

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

Apakah Anda benar-benar harus menangani pencocokan sendiri? Terutama jika yang Anda butuhkan hanyalah jumlah kemunculan, ekspresi reguler lebih rapi:

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

Saya sangat terkejut tidak ada yang menyebutkan liner yang satu ini. Sederhana, ringkas, dan berkinerja sedikit lebih baik daripadastr.split(target, -1).length-1

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

Ini dia, dibungkus dengan metode yang bagus dan dapat digunakan kembali:

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

di akhir hitungan loop adalah 3; semoga membantu

Banyak jawaban yang diberikan gagal pada satu atau lebih dari:

• Pola dengan panjang sembarang
• Kecocokan yang tumpang tindih (seperti menghitung "232" dalam "23232" atau "aa" dalam "aaa")
• Karakter meta ekspresi reguler

Inilah yang saya tulis:

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

Contoh panggilan:

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

Jika Anda menginginkan pencarian non-regular-expression, cukup kompilasi pola Anda secara tepat dengan LITERALflag:

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

Kenaikan lastIndexsetiap kali Anda mencari kejadian berikutnya.

Jika tidak, selalu menemukan substring pertama (pada posisi 0).

public int indexOf(int ch,
                   int fromIndex)

Mengembalikan indeks dalam string ini dari kemunculan pertama dari karakter yang ditentukan, memulai pencarian pada indeks yang ditentukan.

Jadi lastindexnilai Anda selalu 0 dan selalu menemukan hello dalam string.

Jawaban yang diberikan sebagai benar tidak baik untuk menghitung hal-hal seperti pengembalian baris dan terlalu bertele-tele. Jawaban selanjutnya lebih baik tetapi semua bisa dicapai hanya dengan

str.split(findStr).length

Itu tidak menjatuhkan kecocokan trailing menggunakan contoh dalam pertanyaan.

Anda dapat jumlah kejadian menggunakan fungsi perpustakaan bawaan:

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

coba tambahkan lastIndex+=findStr.length()ke akhir loop Anda, jika tidak, Anda akan berakhir dalam loop tanpa akhir karena setelah Anda menemukan substring, Anda mencoba menemukannya berulang kali dari posisi terakhir yang sama.

Coba yang ini. Ini menggantikan semua pertandingan dengan a -.

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

Dan jika Anda tidak ingin menghancurkan Anda, strAnda dapat membuat string baru dengan konten yang sama:

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

Setelah menjalankan blok ini, ini akan menjadi nilai Anda:

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

Seperti yang disarankan @Mr_and_Mrs_D:

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

Berdasarkan jawaban yang ada, saya ingin menambahkan versi "lebih pendek" tanpa 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

Berikut adalah versi lanjutan untuk menghitung berapa kali token terjadi dalam string yang dimasukkan pengguna:

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

}

Metode di bawah ini menunjukkan berapa banyak waktu pengulangan substring pada seluruh string Anda. Semoga bermanfaat bagi Anda: -

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

    }

berikut adalah solusi lain tanpa menggunakan regexp / patterns / matchers atau bahkan tidak menggunakan 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);

Jika Anda membutuhkan indeks setiap substring dalam string asli, Anda dapat melakukan sesuatu dengan indexOf seperti ini:

 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;

}

Solusi ini mencetak jumlah total kemunculan substring tertentu di seluruh string, juga mencakup kasus di mana terdapat kecocokan yang tumpang tindih.

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