it-swarm.com.de

Zählen Sie die Anzahl der Vorkommen eines Wortes in einer Zeichenfolge

Ich bin neu bei Java-Strings. Das Problem ist, dass ich die Vorkommen eines bestimmten Words in einem String zählen möchte. Angenommen, mein String ist:

i have a male cat. the color of male cat is Black

Jetzt möchte ich es auch nicht teilen, also möchte ich nach einem Wort suchen, das "männliche Katze" ist. es kommt zweimal in meiner Saite vor!

Was ich versuche, ist:

int c = 0;
for (int j = 0; j < text.length(); j++) {
    if (text.contains("male cat")) {
        c += 1;
    }
}

System.out.println("counter=" + c);

es gibt mir 46 Gegenwert! Also, was ist die Lösung?

15
Java Nerd

Sie können den folgenden Code verwenden:

String in = "i have a male cat. the color of male cat is Black";
int i = 0;
Pattern p = Pattern.compile("male cat");
Matcher m = p.matcher( in );
while (m.find()) {
    i++;
}
System.out.println(i); // Prints 2

Demo

Was es macht?

Es entspricht "male cat".

while(m.find())

zeigt an, was in der Schleife angegeben wird, während m eine Übereinstimmung findet . Und ich erhöhe den Wert von i um i++, also gibt dies offensichtlich die Anzahl von male cat an, die eine Zeichenfolge hat.

32
Amit Joki

Wenn Sie nur die Anzahl von "male cat" wollen, dann würde ich es einfach so machen:

String str = "i have a male cat. the color of male cat is Black";
int c = str.split("male cat").length - 1;
System.out.println(c);

und wenn Sie sicherstellen möchten, dass "female cat" nicht übereinstimmt, verwenden Sie \\b-Word-Grenzen in der aufgeteilten Regex:

int c = str.split("\\bmale cat\\b").length - 1;
10
donfuxx

StringUtils In Apache commons-lang hat die CountMatches -Methode die Anzahl der Vorkommen eines Strings in einem anderen.

   String input = "i have a male cat. the color of male cat is Black";
   int occurance = StringUtils.countMatches(input, "male cat");
   System.out.println(occurance);
9
ravi

Java 8-Version:

    public static long countNumberOfOccurrencesOfWordInString(String msg, String target) {
    return Arrays.stream(msg.split("[ ,\\.]")).filter(s -> s.equals(target)).count();
}
4
Karol Król

mit indexOf ...

public static int count(String string, String substr) {
    int i;
    int last = 0;
    int count = 0;
    do {
        i = string.indexOf(substr, last);
        if (i != -1) count++;
        last = i+substr.length();
    } while(i != -1);
    return count;
}

public static void main (String[] args ){
    System.out.println(count("i have a male cat. the color of male cat is Black", "male cat"));
}

Das wird zeigen: 2

Eine weitere Implementierung für count () in nur einer Zeile:

public static int count(String string, String substr) {
    return (string.length() - string.replaceAll(substr, "").length()) / substr.length() ;
}
2
Roberto

Java 8-Version.

System.out.println(Pattern.compile("\\bmale cat")
            .splitAsStream("i have a male cat. the color of male cat is Black")
            .count()-1);
2
Zach Eldemire

Diese static-Methode gibt die Anzahl der Vorkommen einer Zeichenfolge in einer anderen Zeichenfolge zurück.

/**
 * Returns the number of appearances that a string have on another string.
 * 
 * @param source    a string to use as source of the match
 * @param sentence  a string that is a substring of source
 * @return the number of occurrences of sentence on source 
 */
public static int numberOfOccurrences(String source, String sentence) {
    int occurrences = 0;

    if (source.contains(sentence)) {
        int withSentenceLength    = source.length();
        int withoutSentenceLength = source.replace(sentence, "").length();
        occurrences = (withSentenceLength - withoutSentenceLength) / sentence.length();
    }

    return occurrences;
}

Tests:

String source = "Hello World!";
numberOfOccurrences(source, "Hello World!");   // 1
numberOfOccurrences(source, "Ello W");         // 1
numberOfOccurrences(source, "l");              // 3
numberOfOccurrences(source, "fun");            // 0
numberOfOccurrences(source, "Hello");          // 1

Übrigens, die Methode könnte in einer Zeile geschrieben werden, schrecklich, aber sie funktioniert auch :)

public static int numberOfOccurrences(String source, String sentence) {
    return (source.contains(sentence)) ? (source.length() - source.replace(sentence, "").length()) / sentence.length() : 0;
}
2
Lucio

Ersetzen Sie den String, der gezählt werden muss, durch einen leeren String, und verwenden Sie dann die Länge ohne den String, um die Anzahl der Vorkommen zu berechnen.

public int occurrencesOf(String Word)
    {
    int length = text.length();
    int lenghtofWord = Word.length();
    int lengthWithoutWord = text.replace(Word, "").length();
    return (length - lengthWithoutWord) / lenghtofWord ;
    }
1
Ravi Kumar

Das wird funktionieren

int Word_count(String text,String key){
   int count=0;
   while(text.contains(key)){
      count++;
      text=text.substring(text.indexOf(key)+key.length());
   }
   return count;
}
1
kail95

öffentliche Klasse TestWordCount {

public static void main(String[] args) {

    int count = numberOfOccurences("Alice", "Alice in wonderland. Alice & chinki are classmates. Chinki is better than Alice.occ");
    System.out.println("count : "+count);

}

public static int numberOfOccurences(String findWord, String sentence) {

    int length = sentence.length();
    int lengthWithoutFindWord = sentence.replace(findWord, "").length();
    return (length - lengthWithoutFindWord)/findWord.length();

}

}

1
sakshi bhatia

Warum nicht rekursiv? 

public class CatchTheMaleCat  {
    private static final String MALE_CAT = "male cat";
    static int count = 0;
    public static void main(String[] arg){
        wordCount("i have a male cat. the color of male cat is Black");
        System.out.println(count);
    }

    private static boolean wordCount(String str){
        if(str.contains(MALE_CAT)){
            count++;
            return wordCount(str.substring(str.indexOf(MALE_CAT)+MALE_CAT.length()));
        }
        else{
            return false;
        }
    }
}
1
zawhtut

Dies sollte eine schnellere Lösung ohne Regex sein.
(Hinweis - Kein Java-Programmierer) 

 String str = "i have a male cat. the color of male cat is Black";
 int found  = 0;
 int oldndx = 0;
 int newndx = 0;

 while ( (newndx=str.indexOf("male cat", oldndx)) > -1 )
 {
     found++;
     oldndx = newndx+8;
 }
0
sln

Es gibt so viele Möglichkeiten für das Auftreten von Teilstrings, und zwei Themen sind: -

public class Test1 {
public static void main(String args[]) {
    String st = "abcdsfgh yfhf hghj gjgjhbn hgkhmn abc hadslfahsd abcioh abc  a ";
    count(st, 0, "a".length());

}

public static void count(String trim, int i, int length) {
    if (trim.contains("a")) {
        trim = trim.substring(trim.indexOf("a") + length);
        count(trim, i + 1, length);
    } else {
        System.out.println(i);
    }
}

public static void countMethod2() {
    int index = 0, count = 0;
    String inputString = "mynameiskhanMYlaptopnameishclMYsirnameisjasaiwalmyfrontnameisvishal".toLowerCase();
    String subString = "my".toLowerCase();

    while (index != -1) {
        index = inputString.indexOf(subString, index);
        if (index != -1) {
            count++;
            index += subString.length();
        }
    }
    System.out.print(count);
}}
0
Ravindra

Komplettes Beispiel hier,

package com.test;

import Java.util.HashMap;
import Java.util.Iterator;
import Java.util.Map;

public class WordsOccurances {

      public static void main(String[] args) {

            String sentence = "Java can run on many different operating "
                + "systems. This makes Java platform independent.";

            String[] words = sentence.split(" ");
            Map<String, Integer> wordsMap = new HashMap<String, Integer>();

            for (int i = 0; i<words.length; i++ ) {
                if (wordsMap.containsKey(words[i])) {
                    Integer value = wordsMap.get(words[i]);
                    wordsMap.put(words[i], value + 1);
                } else {
                    wordsMap.put(words[i], 1);
                }
            }

            /*Now iterate the HashMap to display the Word with number 
           of time occurance            */

           Iterator it = wordsMap.entrySet().iterator();
           while (it.hasNext()) {
                Map.Entry<String, Integer> entryKeyValue = (Map.Entry<String, Integer>) it.next();
                System.out.println("Word : "+entryKeyValue.getKey()+", Occurance : "
                                +entryKeyValue.getValue()+" times");
           }
     }
}
0
Anil Nivargi

Ich habe hier einen anderen Ansatz:

String description = "hello india hello india hello hello india hello";
String textToBeCounted = "hello";

// Split description using "hello", which will return 
//string array of words other than hello
String[] words = description.split("hello");

// Get number of characters words other than "hello"
int lengthOfNonMatchingWords = 0;
for (String Word : words) {
    lengthOfNonMatchingWords += Word.length();
}

// Following code gets length of `description` - length of all non-matching
// words and divide it by length of Word to be counted
System.out.println("Number of matching words are " + 
(description.length() - lengthOfNonMatchingWords) / textToBeCounted.length());
0
TDHM
public int occurrencesOf(String Word) {
    int length = text.length();
    int lenghtofWord = Word.length();
    int lengthWithoutWord = text.replaceAll(Word, "").length();
    return (length - lengthWithoutWord) / lenghtofWord ;
}
0
Koustuv Ganguly

Wenn Sie den gesuchten String gefunden haben, können Sie die Länge des Strings fortsetzen (wenn Sie in aaaa nach aa suchen, betrachten Sie ihn zwei Mal).

int c=0;
String found="male cat";
 for(int j=0; j<text.length();j++){
     if(text.contains(found)){
         c+=1;
         j+=found.length()-1;
     }
 }
 System.out.println("counter="+c);
0
AndreaTaroni86

Wenn Sie den Begriff gefunden haben, den Sie aus String unter Prozess entfernen müssen, damit er nicht erneut aufgelöst werden kann, verwenden Sie indexOf() und substring()

0
Jigar Joshi

Wir können für das Auftreten von Teilzeichenfolgen aus vielen Gründen rechnen: -

public class Test1 {
public static void main(String args[]) {
    String st = "abcdsfgh yfhf hghj gjgjhbn hgkhmn abc hadslfahsd abcioh abc  a ";
    count(st, 0, "a".length());

}

public static void count(String trim, int i, int length) {
    if (trim.contains("a")) {
        trim = trim.substring(trim.indexOf("a") + length);
        count(trim, i + 1, length);
    } else {
        System.out.println(i);
    }
}

public static void countMethod2() {
    int index = 0, count = 0;
    String inputString = "mynameiskhanMYlaptopnameishclMYsirnameisjasaiwalmyfrontnameisvishal".toLowerCase();
    String subString = "my".toLowerCase();

    while (index != -1) {
        index = inputString.indexOf(subString, index);
        if (index != -1) {
            count++;
            index += subString.length();
        }
    }
    System.out.print(count);
}}
0
Ravindra

Einfache Lösung ist hier-

Der folgende Code verwendet HashMap, da er Schlüssel und Werte verwaltet. Schlüssel sind also Word und Werte werden gezählt (Auftreten eines Words in einer gegebenen Zeichenfolge).

public class WordOccurance 
{

 public static void main(String[] args) 
 {
    HashMap<String, Integer> hm = new HashMap<>();
    String str = "avinash pande avinash pande avinash";

    //split the Word with white space       
    String words[] = str.split(" ");
    for (String Word : words) 
    {   
        //If already added/present in hashmap then increment the count by 1
        if(hm.containsKey(Word))    
        {           
            hm.put(Word, hm.get(Word)+1);
        }
        else //if not added earlier then add with count 1
        {
            hm.put(Word, 1);
        }

    }
    //Iterate over the hashmap
    Set<Entry<String, Integer>> entry =  hm.entrySet();
    for (Entry<String, Integer> entry2 : entry) 
    {
        System.out.println(entry2.getKey() + "      "+entry2.getValue());
    }
}

}

0
Avinash Pande

Die Zeichenfolge enthält diese Zeichenfolge, wenn sie durchlaufen wird. Sie wollen nicht ++, weil das, was dies jetzt tut, nur die Länge der Zeichenfolge erhält, wenn sie "" männliche Katze "enthält

Sie müssen indexOf ()/substring ()

Irgendwie was ich sage?

0
3kings

öffentliche Klasse WordCount {

public static void main(String[] args) {
    // TODO Auto-generated method stub
    String scentence = "This is a treeis isis is is is";
    String Word = "is";
    int wordCount = 0;
    for(int i =0;i<scentence.length();i++){
        if(Word.charAt(0) == scentence.charAt(i)){
            if(i>0){
                if(scentence.charAt(i-1) == ' '){
                    if(i+Word.length()<scentence.length()){
                        if(scentence.charAt(i+Word.length()) != ' '){
                            continue;}
                        }
                    }
                else{
                    continue;
                }
            }
            int count = 1;
            for(int j=1 ; j<Word.length();j++){
                i++;
                if(Word.charAt(j) != scentence.charAt(i)){
                    break;
                }
                else{
                    count++;
                }
            }
            if(count == Word.length()){
                wordCount++;
            }

        }
    }
    System.out.println("The Word "+ Word + " was repeated :" + wordCount);
}

}

0
Chaitanya