Bir dizede alt dize oluşumu

Aşağıdaki algoritma neden benim için durmuyor? (str, aradığım dizedir, findStr, bulmaya çalıştığım dizedir)

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

Son satır bir sorun yaratıyordu. lastIndexasla -1'de olmaz, bu yüzden sonsuz bir döngü olur. Bu, kodun son satırını if bloğuna taşıyarak düzeltilebilir.

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

Apache Commons Lang'den StringUtils.countMatches kullanmaya ne dersiniz ?

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

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

Bu çıktı:

3

Sizin lastIndex += findStr.length(); sonsuz döngüye neden parantez dışına yerleştirilmiştir (no oluşumu tespit edildi lastIndex hep oldu findStr.length()).

İşte sabit versiyon:

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

Daha kısa bir versiyon. ;)

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

Eşleştirmeyi gerçekten kendin halletmek zorunda mısın? Özellikle ihtiyacınız olan tek şey gerçekleşme sayısı ise, normal ifadeler daha derli topludur:

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

Kimsenin bundan bahsetmemesine çok şaşırdım. Basit, özlü ve performansından biraz daha iyistr.split(target, -1).length-1

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

İşte güzel ve tekrar kullanılabilir bir yöntemle özetlenmiş:

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

döngü sonunda 3'tür; Umarım yardımcı olur

Verilen cevapların çoğu şunlardan birinde veya daha fazlasında başarısız oluyor:

• Keyfi uzunluk kalıpları
• Çakışan eşleşmeler ("23232" de "232" veya "aaa" da "aa" sayma gibi)
• Normal ifade meta karakterleri

İşte yazdıklarım:

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

Örnek çağrı:

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

Normal olmayan bir arama istiyorsanız, kalıbınızı uygun bir şekilde LITERALbayrakla derleyin :

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

Artış lastIndexsonraki geçtiği için bak ne zaman.

Aksi takdirde, her zaman ilk alt dizeyi bulur (0 konumunda).

public int indexOf(int ch,
                   int fromIndex)

Aramayı belirtilen dizinde başlatarak, belirtilen karakterin ilk oluşumunun bu dizge içindeki dizini döndürür.

Yani lastindexdeğeriniz her zaman 0'dır ve dizede her zaman merhaba bulur .

Doğru olarak verilen cevap, satır dönüşleri gibi şeyleri saymak için iyi değildir ve fazlasıyla ayrıntılıdır. Daha sonra cevaplar daha iyidir, ancak hepsi basit bir şekilde elde edilebilir

str.split(findStr).length

Sorudaki örneği kullanarak takip eden eşleşmeleri düşürmez.

Dahili kütüphane işlevini kullanarak oluşumların sayısını yapabilirsiniz:

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

Döngünüzün lastIndex+=findStr.length()sonuna eklemeyi deneyin , aksi takdirde sonsuz bir döngüye girersiniz çünkü alt dizeyi bulduğunuzda, aynı son konumdan tekrar tekrar bulmaya çalışıyorsunuzdur.

Bunu dene. Tüm eşleşmeleri bir -.

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

Ve kendinizi yok etmek istemiyorsanız str, aynı içeriğe sahip yeni bir dize oluşturabilirsiniz:

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

Bu bloğu yürüttükten sonra bunlar sizin değerleriniz olacaktır:

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

@Mr_and_Mrs_D'nin önerdiği gibi:

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

Mevcut yanıtlara dayanarak, şu koşulsuz "daha kısa" bir versiyon eklemek istiyorum:

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

Kullanıcı tarafından girilen bir dizede jetonun kaç kez oluştuğunu saymak için gelişmiş sürüm:

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

}

Aşağıdaki yöntem, dizenin tamamında alt dizenin kaç kez yinelendiğini gösterir. Umarım tam size göre: -

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

    }

burada regexp / pattern / matchers kullanmadan veya StringUtils kullanmadan diğer çözüm.

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

Orijinal dizedeki her bir alt dizenin dizinine ihtiyacınız varsa, indexOf ile şu şekilde bir şeyler yapabilirsiniz:

 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;

}

Bu çözüm, dizgi boyunca belirli bir alt dizenin toplam oluşum sayısını yazdırır, ayrıca çakışan eşleşmelerin olduğu durumları da içerir.

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