¿Contar palabras en un método de cuerda?

Me preguntaba cómo escribiría un método para contar el número de palabras en una cadena java solo mediante el uso de métodos de cadena como charAt, longitud o subcadena.

¡Loops y si las declaraciones son correctas!

¡Realmente aprecio cualquier ayuda que pueda obtener! ¡Gracias!

public static int countWords(String s){ int wordCount = 0; boolean word = false; int endOfLine = s.length() - 1; for (int i = 0; i < s.length(); i++) { // if the char is a letter, word = true. if (Character.isLetter(s.charAt(i)) && i != endOfLine) { word = true; // if char isn't a letter and there have been letters before, // counter goes up. } else if (!Character.isLetter(s.charAt(i)) && word) { wordCount++; word = false; // last word of String; if it doesn't end with a non letter, it // wouldn't count without this. } else if (Character.isLetter(s.charAt(i)) && i == endOfLine) { wordCount++; } } return wordCount; } 

Esto funcionaría incluso con espacios múltiples y espacios iniciales y / o finales y líneas en blanco:

 String trim = s.trim(); if (trim.isEmpty()) return 0; return trim.split("\\s+").length; // separate string around spaces 

Espero que ayude. Más información sobre dividir aquí.

Hola, acabo de descubrir esto con StringTokenizer:

 String words = "word word2 word3 word4"; StringTokenizer st = new Tokenizer(words); st.countTokens(); 

Simplemente usa,

 str.split("\\w+").length ; 
 public static int countWords(String str){ if(str == null || str.isEmpty()) return 0; int count = 0; for(int e = 0; e < str.length(); e++){ if(str.charAt(e) != ' '){ count++; while(str.charAt(e) != ' ' && e < str.length()-1){ e++; } } } return count; } 
  private static int countWordsInSentence(String input) { int wordCount = 0; if (input.trim().equals("")) { return wordCount; } else { wordCount = 1; } for (int i = 0; i < input.length(); i++) { char ch = input.charAt(i); String str = new String("" + ch); if (i+1 != input.length() && str.equals(" ") && !(""+ input.charAt(i+1)).equals(" ")) { wordCount++; } } return wordCount; } 

Algo en O (N)

  count : 0; if(str[0] == validChar ) : count++; else : for i = 1 ; i < sizeOf(str) ; i++ : if(str[i] == validChar AND str[i-1] != validChar) count++; end if; end for; end if; return count; 
  import com.google.common.base.Optional; import com.google.common.base.Splitter; import com.google.common.collect.HashMultiset; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Multiset; String str="Simple Java Word Count count Count Program"; Iterable words = Splitter.on(" ").trimResults().split(str); //google word counter Multiset wordsMultiset = HashMultiset.create(); for (String string : words) { wordsMultiset.add(string.toLowerCase()); } Set result = wordsMultiset.elementSet(); for (String string : result) { System.out.println(string+" X "+wordsMultiset.count(string)); } add at the pom.xml  com.google.guava guava r09  

Contando Palabras en una Cadena:
Esto también podría ayudar ->

 package data.structure.test; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class CountWords { public static void main(String[] args) throws IOException { // Couting number of words in a string BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); System.out.println("enter Your String"); String input = br.readLine(); char[] arr = input.toCharArray(); int i = 0; boolean notCounted = true; int counter = 0; while (i < arr.length) { if (arr[i] != ' ') { if (notCounted) { notCounted = false; counter++; } } else { notCounted = true; } i++; } System.out.println("words in the string are : " + counter); } } 

Utilizar

 myString.split("\\s+"); 

Esto funcionará

 public class TestStringCount { public static void main(String[] args) { int count=0; boolean word= false; String str = "how ma ny wo rds are th ere in th is sente nce"; char[] ch = str.toCharArray(); for(int i =0;i 

import java.util. ; importar java.io. ;

clase pública Principal {

 public static void main(String[] args) { File f=new File("src/MyFrame.java"); String value=null; int i=0; int j=0; int k=0; try { Scanner in =new Scanner(f); while(in.hasNextLine()) { String a=in.nextLine(); k++; char chars[]=a.toCharArray(); i +=chars.length; } in.close(); Scanner in2=new Scanner(f); while(in2.hasNext()) { String b=in2.next(); System.out.println(b); j++; } in2.close(); System.out.println("the number of chars is :"+i); System.out.println("the number of words is :"+j); System.out.println("the number of lines is :"+k); } catch (Exception e) { e.printStackTrace(); } } 

}

Hay una solución simple Puedes probar este código

  String s = "hju vg jhdgsf dh gg ggg "; String[] words = s.trim().split("\\s+"); System.out.println("count is = "+(words.length)); 
 public static int countWords(String input) { int wordCount = 0; boolean isBlankSet = false; input = input.trim(); for (int j = 0; j < input.length(); j++) { if (input.charAt(j) == ' ') isBlankSet = true; else { if (isBlankSet) { wordCount++; isBlankSet = false; } } } return wordCount + 1; } 

Mi idea de ese progtwig es que:

 package text; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class CoutingWords { public static void main(String[] args) throws IOException { String str; int cWords = 1; char ch; BufferedReader buffor = new BufferedReader(new InputStreamReader(System.in)); System.out.println("Enter text: "); str = buffor.readLine(); for(int i =0; i 

Soy nuevo en stackoverflow, pero espero que mi código ayude:

 private int numOfWordsInLineCounter(String line){ int words = 0; for(int i = 1 ; i 

Una frase de cadena normalmente tiene palabras separadas por espacio. Bueno, puedes dividir la frase usando los espacios como personajes separadores y contarlos de la siguiente manera.

 import java.util.HashMap; import java.util.Map; public class WordCountMethod { public static void main (String [] args){ Mapm = new HashMap(); String phrase = "hello my name is John I repeat John"; String [] array = phrase.split(" "); for(int i =0; i < array.length; i++){ String word_i = array[i]; Integer ci = m.get(word_i); if(ci == null){ m.put(word_i, 1); } else m.put(word_i, ci+1); } for(String s : m.keySet()){ System.out.println(s+" repeats "+m.get(s)); } } } 

Tomando la respuesta elegida como punto de partida, lo que sigue trata algunos problemas del idioma inglés, incluyendo palabras con guiones, apóstrofes para posesivos y shortenings, números y también cualquier carácter fuera de UTF-16:

 public static int countWords(final String s) { int wordCount = 0; boolean word = false; final int endOfLine = s.length() - 1; for (int i = 0; i < s.length(); i++) { // if the char is a letter, word = true. if (isWordCharacter(s, i) && i != endOfLine) { word = true; // if char isn't a letter and there have been letters before, // counter goes up. } else if (!isWordCharacter(s, i) && word) { wordCount++; word = false; // last word of String; if it doesn't end with a non letter, it // wouldn't count without this. } else if (isWordCharacter(s, i) && i == endOfLine) { wordCount++; } } return wordCount; } private static boolean isWordCharacter(final String s, final int i) { final char ch = s.charAt(i); return Character.isLetterOrDigit(ch) || ch == '\'' || Character.getType(ch) == Character.DASH_PUNCTUATION || Character.isSurrogate(ch); } 

Solo junté esto. El incremento en el método de wordCount () es un poco poco elegante para mí, pero funciona.

 import java.util.*; public class WordCounter { private String word; private int numWords; public int wordCount(String wrd) { StringTokenizer token = new StringTokenizer(wrd, " "); word = token.nextToken(); numWords = token.countTokens(); numWords++; return numWords; } public static void main(String[] args) { Scanner input = new Scanner(System.in); String userWord; WordCounter wc = new WordCounter(); System.out.println("Enter a sentence."); userWord = input.nextLine(); wc.wordCount(userWord); System.out.println("You sentence was " + wc.numWords + " words long."); } } 
 if(str.isEmpty() || str.trim().length() == 0){ return 0; } return (str.trim().split("\\s+").length);