Compter le nombre d'occurrences d'un mot dans une chaîne
Je suis nouveau sur Java Strings, le problème est que je veux compter les occurrences d'un mot spécifique dans une chaîne. Supposons que ma chaîne soit:
i have a male cat. the color of male cat is Black
Maintenant, je ne veux pas le diviser aussi, alors je veux chercher un mot qui est "chat mâle". cela se produit deux fois dans ma chaîne!
Ce que j'essaye c'est:
int c = 0;
for (int j = 0; j < text.length(); j++) {
if (text.contains("male cat")) {
c += 1;
}
}
System.out.println("counter=" + c);
ça me donne 46 contre valeur! Alors quelle est la solution?
Vous pouvez utiliser le code suivant:
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
Ce qu'il fait?
Cela correspond à "male cat".
while(m.find())
indique tout ce qui est donné dans la boucle pendant que m trouve une correspondance . Et j'incrémente la valeur de i de i++, alors évidemment, cela donne le numéro de male cat une chaîne a obtenu .
Si vous voulez juste le nombre de "male cat", je le ferais simplement comme ceci:
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);
et si vous voulez vous assurer que "female cat" ne correspond pas, utilisez \\b Limites de mots dans l'expression régulière divisée:
int c = str.split("\\bmale cat\\b").length - 1;
StringUtils dans Apache commons-lang utilise la méthode CountMatches pour compter le nombre d'occurrences d'une chaîne dans une autre.
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);
Version Java 8:
public static long countNumberOfOccurrencesOfWordInString(String msg, String target) {
return Arrays.stream(msg.split("[ ,\\.]")).filter(s -> s.equals(target)).count();
}
en utilisant 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"));
}
Cela montrera: 2
Une autre implémentation pour count (), en seulement 1 ligne:
public static int count(String string, String substr) {
return (string.length() - string.replaceAll(substr, "").length()) / substr.length() ;
}
Version Java 8.
System.out.println(Pattern.compile("\\bmale cat")
.splitAsStream("i have a male cat. the color of male cat is Black")
.count()-1);
Cette méthode static renvoie le nombre d'occurrences d'une chaîne sur une autre chaîne.
/**
* 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
BTW, la méthode pourrait être écrite en une seule ligne, terrible, mais cela fonctionne aussi :)
public static int numberOfOccurrences(String source, String sentence) {
return (source.contains(sentence)) ? (source.length() - source.replace(sentence, "").length()) / sentence.length() : 0;
}
Remplacez la chaîne à compter par une chaîne vide, puis utilisez la longueur sans la chaîne pour calculer le nombre d'occurrences.
public int occurrencesOf(String Word)
{
int length = text.length();
int lenghtofWord = Word.length();
int lengthWithoutWord = text.replace(Word, "").length();
return (length - lengthWithoutWord) / lenghtofWord ;
}
Cela fonctionnera
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;
}
classe publique 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();
}
}
Pourquoi pas récursif?
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;
}
}
}
Cela devrait être une solution plus rapide sans regex.
(note - pas un programmeur Java)
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;
}
Il y a tellement de manières pour l'apparition de sous-chaîne et deux de thème sont: -
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);
}}
Exemple complet ici,
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");
}
}
}
J'ai une autre approche ici:
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());
public int occurrencesOf(String Word) {
int length = text.length();
int lenghtofWord = Word.length();
int lengthWithoutWord = text.replaceAll(Word, "").length();
return (length - lengthWithoutWord) / lenghtofWord ;
}
Si vous trouvez la chaîne que vous recherchez, vous pouvez en indiquer la longueur (si vous effectuez une recherche dans aaaa, vous la considérez 2 fois).
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);
Une fois que vous avez trouvé le terme que vous devez supprimer de String sous processus pour éviter qu'il ne soit résolu à nouveau, utilisez indexOf() et substring(), vous n'avez pas besoin de connaître les durées de contrôle
Nous pouvons compter de plusieurs façons pour l'apparition de sous-chaîne: -
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);
}}
La solution simple est ici-
Le code ci-dessous utilise HashMap car il conservera les clés et les valeurs. alors, ici, les clés seront Word et les valeurs seront comptées (occurrence d'un mot dans une chaîne donnée).
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());
}
}
}
La chaîne contient cette chaîne tout le temps lorsque vous la parcourez. Vous ne voulez pas ++ car ce que cela fait actuellement, c'est juste d'obtenir la longueur de la chaîne si elle contient "" un chat mâle
Vous devez indexOf ()/substring ()
Genre de obtenir ce que je dis?
classe publique 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);
}
}