Wörter in einer String-Methode zählen?

Ich Frage mich, wie würde ich schreiben, eine Methode, um die Anzahl der Wörter in einem java-string nur mit Hilfe von string-Methoden wie charAt, Länge oder substring.

Schleifen und if-Anweisungen sind okay!

Ich wirklich zu schätzen jede Hilfe die ich bekommen kann! Danke!

InformationsquelleAutor der Frage Philip McQuitty | 2011-05-03

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;
}

InformationsquelleAutor der Antwort koool

63

Dies funktioniert auch mit mehreren Leerzeichen und führende und/oder nachfolgende Leerzeichen und Leerzeilen:
```
String trim = s.trim();
if (trim.isEmpty())
    return 0;
return trim.split("\\s+").length; //separate string around spaces
```
Hoffe, das hilft. Mehr Infos über split hier.

InformationsquelleAutor der Antwort Cory G.
11

Hallo ich habe gerade herausgefunden, mit StringTokenizer wie diese:
```
String words = "word word2 word3 word4";
StringTokenizer st = new Tokenizer(words);
st.countTokens();
```
InformationsquelleAutor der Antwort fredy hernan sanchez montaa Ha
5

Einfach zu verwenden ,
```
str.split("\\w+").length ;
```
InformationsquelleAutor der Antwort Ram Krishna Chaulagai

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;
    }

InformationsquelleAutor der Antwort whiteErru

 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;
 }

InformationsquelleAutor der Antwort Arvind Krishnakumar

Algorithmus in 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;

InformationsquelleAutor der Antwort Saad

    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<String> words = Splitter.on(" ").trimResults().split(str);


    //google word counter       
    Multiset<String> wordsMultiset = HashMultiset.create();
    for (String string : words) {   
        wordsMultiset.add(string.toLowerCase());
    }

    Set<String> result = wordsMultiset.elementSet();
    for (String string : result) {
        System.out.println(string+" X "+wordsMultiset.count(string));
    }


add at the pom.xml
<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>r09</version>
</dependency>

InformationsquelleAutor der Antwort Ran Adler

Zählen von Wörtern in einer Zeichenfolge:

Das könnte auch helfen -->

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

}

InformationsquelleAutor der Antwort taj.tajinder

0

Verwenden
```
myString.split("\\s+");
```
Dies funktionieren wird.

InformationsquelleAutor der Antwort Deepak

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<ch.length;i++){
        if(!(ch[i]==' ')){
            for(int j=i;j<ch.length;j++,i++){
                if(!(ch[j]==' ')){
                    word= true;
                    if(j==ch.length-1){
                        count++;
                    }
                    continue;
                }
                else{
                    if(word){
                        count++;
                    }
                    word = false;
                }
            }
        }
        else{
            continue;
        }
    }
    System.out.println("there are "+(count)+" words");      
    }
}

InformationsquelleAutor der Antwort RE350

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

public class Main {

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();

}


}

}

InformationsquelleAutor der Antwort hassan

Gibt es eine Einfache Lösung, können Sie Versuchen, diesen code

    String s = "hju   vg    jhdgsf  dh gg    g g  g  ";

    String[] words = s.trim().split("\\s+");

    System.out.println("count is = "+(words.length));

InformationsquelleAutor der Antwort Abhishek Verma

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;
    }

InformationsquelleAutor der Antwort Ashish M Jain

Meine Idee von diesem Programm ist, dass:

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<str.length(); i++){
            ch = str.charAt(i);
            if(Character.isWhitespace(ch)){ cWords++; }
        }
        System.out.println("There are " + (int)cWords +" words.");
    }
}

InformationsquelleAutor der Antwort Misq

Ich bin neu auf stackoverflow, aber ich hoffe, dass mein code hilft:

private int numOfWordsInLineCounter(String line){

     int words = 0;

         for(int i = 1 ; i<line.length();i++){
         Character ch  = line.charAt(i-1);
         Character bch = line.charAt(i);
             if(Character.isLetterOrDigit(ch) == true && Character.isLetterOrDigit(bch)== false ) words++;
             if(i == line.length()-1 && Character.isLetterOrDigit(bch))words++;
         }
     return words;
 }

InformationsquelleAutor der Antwort Soorena

Einen string-Ausdruck in der Regel hat Wörter, getrennt durch Leerzeichen. Nun können Sie teilen Sie die phrase mit dem Leerzeichen als Trennung von Zeichen und zählen Sie Sie wie folgt.

import java.util.HashMap;

import java.util.Map;

public class WordCountMethod {

    public static void main (String [] args){

        Map<String, Integer>m = new HashMap<String, Integer>();
        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));
        }
    }

}

InformationsquelleAutor der Antwort AlketCecaj

Unter die gewählte Antwort als Ausgangspunkt der folgenden befasst sich mit ein paar englischen Sprache Probleme, einschließlich Bindestrich-Wörter, die Apostrophe für possessives und Kürzungen, zahlen und auch Zeichen außerhalb von 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);
}

InformationsquelleAutor der Antwort Dave Bower

Ich habe nur diese zusammen. Der inkrementierer in die wordCount () - Methode ist ein wenig unelegant an mir, aber es funktioniert.

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.");
  }
}

InformationsquelleAutor der Antwort Geoff Zoref

-1

if(str.isEmpty() || str.trim().length() == 0){
   return 0;
}
return (str.trim().split("\\s+").length);

InformationsquelleAutor der Antwort Quick and dirty

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.