计算字符串中Word的出现次数
我是Java Strings的新手，问题是我想要计算String中特定单词的出现次数。 假设我的String是：
i have a male cat. the color of male cat is Black 现在我也不想将它拆分，所以我想搜索一个“雄猫”这个词。 它在我的字符串中出现两次！
我在想的是：
int c = 0; for (int j = 0; j < text.length(); j++) { if (text.contains("male cat")) { c += 1; } } System.out.println("counter=" + c);
它给了我46计数值！ 那么解决方案是什么？
您可以使用以下代码：
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
演示
它能做什么？
它匹配"male cat" 。
while(m.find())
表示，当m找到匹配时，执行循环内给出的任何内容。 而我正在用i++增加i的值，所以很明显，这给了一个字符串已经得到的male cat的数量。
如果你只想要"male cat"那么我会这样做：
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);
如果你想确保"female cat"不匹配，那么在分割正则表达式中使用\\b字边界：
int c = str.split("\\bmale cat\\b").length - 1;
apache commons-lang中的StringUtils具有CountMatches方法来计算一个String在另一个String中出现的次数。
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);
Java 8版本：
public static long countNumberOfOccurrencesOfWordInString(String msg, String target) { return Arrays.stream(msg.split("[ ,\\.]")).filter(s -> s.equals(target)).count(); }
使用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")); }
这将显示：2
count（）的另一个实现，只有一行：
public static int count(String string, String substr) { return (string.length() - string.replaceAll(substr, "").length()) / substr.length() ; }
此static方法确实返回另一个字符串上字符串的出现次数。
/** * 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; }
测试：
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
顺便说一句，这个方法可以写成一行，很糟糕，但它也有效:)
public static int numberOfOccurrences(String source, String sentence) { return (source.contains(sentence)) ? (source.length() - source.replace(sentence, "").length()) / sentence.length() : 0; }
为什么不递归？
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; } } }
这会奏效
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; }
公共类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(); }
}
Java 8版。
System.out.println(Pattern.compile("\\bmale cat") .splitAsStream("i have a male cat. the color of male cat is Black") .count()-1);
一旦找到你需要从进程中的String中删除它的术语，以便它不会再次解析它，使用indexOf()和substring() ，你不需要包含检查长度时间
该字符串在循环遍历时始终包含该字符串。 你不想要++，因为现在正在做的只是获取字符串的长度，如果它包含“”男性猫“
你需要indexOf（）/ substring（）
有点得到我在说什么？
如果您找到要搜索的字符串，则可以继续查找该字符串的长度（如果您在aaaa中搜索aa，则将其视为2次）。
int c=0; String found="male cat"; for(int j=0; j
这应该是一个更快的非正则表达式解决方案。
（注意 – 不是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; }
子串的出现有很多种方式，主题有两种： –
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); }}
我们可以通过多种方式计算子串的出现： –
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); }}
替换需要用空字符串计数的字符串，然后使用不带字符串的长度来计算出现次数。
public int occurrencesOf(String word) { int length = text.length(); int lenghtofWord = word.length(); int lengthWithoutWord = text.replace(word, "").length(); return (length - lengthWithoutWord) / lenghtofWord ; }
我在这里有另一种方法：
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());
这里完成示例，
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 wordsMap = new HashMap(); for (int i = 0; i entryKeyValue = (Map.Entry) it.next(); System.out.println("Word : "+entryKeyValue.getKey()+", Occurance : " +entryKeyValue.getValue()+" times"); } } }
公共类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;i0){ if(scentence.charAt(i-1) == ' '){ if(i+word.length()
}
简单的解决方案是 –
下面的代码使用HashMap，因为它将维护键和值。 所以这里的键将是单词，值将被计数（在给定的字符串中出现一个单词）。
public class WordOccurance { public static void main(String[] args) { HashMap 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 = hm.entrySet(); for (Entry entry2 : entry) { System.out.println(entry2.getKey() + " "+entry2.getValue()); } }
}