문자열에서 하위 문자열의 발생

다음 알고리즘이 중단되지 않는 이유는 무엇입니까? (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);

Apache Commons Lang에서 StringUtils.countMatches 를 사용하는 것은 어떻 습니까?

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

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

그 결과 :

3

귀하가 lastIndex += findStr.length();어떤 선두로부터이 발견되지 때 무한 루프 (원인, 괄호 외부에 배치 된, lastIndex 속성은 항상 있었다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이고; 도움이되기를 바랍니다

주어진 답변 중 상당수가 다음 중 하나 이상에서 실패합니다.

• 임의 길이의 패턴
• 겹치는 일치 (예 : "23232"의 "232"또는 "aaa"의 "aa")
• 정규식 메타 문자

내가 쓴 내용은 다음과 같습니다.

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이고 항상 문자열에서 hello 를 찾습니다 .

정답으로 주어진 대답은 줄 바꿈과 같은 것을 계산하는 데 좋지 않으며 너무 장황합니다. 나중에 대답하는 것이 더 좋지만 모든 것은 간단하게 얻을 수 있습니다.

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