Word count from text

Question

This is my code to work out the length of a word:

public class WordCount {
public static void main (String args []) {
    String text;
    text = "Java";
    System.out.println (text);

    //Work out the length
            String [] input = text.split(" ");
            int MaxWordLength = 0;
            int WordLength = 0;
                for (int i = 0; i < input.length; i++)
                {  
                    MaxWordLength = input[i].length();
                    WordLength = MaxWordLength;                         
                } //End of working out length

                //Work out no. of words
                int[] intWordCount = new int[WordLength + 1];
                for(int i = 0; i < input.length; i++) {
                    intWordCount[input[i].length()]++; }

                for (int i = 1; i < intWordCount.length; i++) {
                    System.out.println("There are " + intWordCount[i] + " words of length " + MaxWordLength);
                }
        }
    }

The problem I am having is that when it prints out the length of the word, I get these results:

Java
There are 0 words of length 4
There are 0 words of length 4
There are 0 words of length 4
There are 1 words of length 4

But when I change the text to "J" this prints out:

J
There are 1 words of length 1

Any idea why it's doing that? P.S. I'm kind of new to Java and any help would be appreciated.

Answer 1

Let's walk through this:

public class WordCount {
public static void main (String args []) {
    String text;
    text = "Java";

text is equal to "Java".

    System.out.println (text);

Prints "Java"

    //Work out the length
            String [] input = text.split(" ");

This splits the string "Java" on spaces, of which there are none. So input (which I'd recommend be renamed to something more indicative, like inputs) is equal to an array of one element, and that one element is equal to "Java".

            int MaxWordLength = 0;
            int WordLength = 0;
                for (int i = 0; i < input.length; i++)
                {  
                    MaxWordLength = input[i].length();

For each element, of which there is only one, MaxWordLength is set to the length of the first (and only) element, which is "Java"...whose length is 4.

                    WordLength = MaxWordLength;                         

So WordLength is now equal to 4.

                } //End of working out length

                //Work out no. of words
                int[] intWordCount = new int[WordLength + 1];

This creates an int array of [WordLength + 1] elements (which is equal to [4 + 1], or 5), where each is initialized to zero.

                for(int i = 0; i < input.length; i++) {
                    intWordCount[input[i].length()]++; }

For each element in input, of which there is only one, this sets the input[i].length()-th element--the fifth, since input[i] is "Java" and it's length is four--to itself, plus one (because of the ++).

Therefore, after this for loop, the array is now equal to [0, 0, 0, 0, 1].

                for (int i = 1; i < intWordCount.length; i++) {
                    System.out.println("There are " + intWordCount[i] + " words of length " + MaxWordLength);

So this naturally prints the undesired output.

                }
        }
    }

Your output is different when the input is only "J", because the intWordCount array is shortened to input[i].length() elements, which is now 1. But the value of the last element is still set to "itself plus one", and "itself" is initialized to zero (as all int-array elements are), and then incremented by one (with ++).

Answer 2

I am not sure if you want to count letter or word because your code counts letter to me.

Just you need to change this line from

String [] input = text.split(" ");

to

String [] input = text.split("");

and your program works perfectly.

input: Java

output: There are 4 letters of length 1 <- Hope this is the expected result for you

Source: Splitting words into letters in Java

You can achieve this in better and less headache by using Lambda in Java

Code:

import java.util.*;

public class LambdaTest     
{
    public static void main (String[] args)
    {

         String[] st = "Hello".split("");
         Collection myList = Arrays.asList(st);
         System.out.println("your word has " + myList.stream().count() + "letters");

    } 
}

Output:

your word has 5 letters CLEARLY in length 1

My answer when you cleared what your issue is

Code:

public class WordCount      
{
    public static void main (String[] args)
    {
      String text ="";
      int wordLenght = 0;
      text = "Java is awesome for Me";
      System.out.println (text);


            String [] input = text.split(" ");
            List<Integer> list = new ArrayList<>();

            for (int i = 0; i < input.length; i++)
                {  
                    list.add(input[i].length());

                } 
            Set<Integer> unique = new HashSet<Integer>(list);

           for (Integer length : unique) {
               System.out.println("There are " + Collections.frequency(list, length) + " words of length " + length);
}
    } 
}

output:

  There are 2 words of length 2
  There are 1 words of length 3 
  There are 1 words of length 4 
  There are 1 words of length 7

Note: Read about HashSet and Set in Java

Source: http://javarevisited.blogspot.com/2012/06/hashset-in-java-10-examples-programs.html

Answer 3

for (int i = 1; i < intWordCount.length; i++) {
    System.out.println("There are " + intWordCount[i] + " words of length " + MaxWordLength);
}

1) You print out words with intWordCount[i] == 0, which is why you have the "There are 0 words of length X"
2) System.out.println("There are " ... + MaxWordLength); should probably be System.out.println("There are " ... + i);, so you have "There are 0 words of length 1" , "There are 0 words of length 2", etc

Answer 4

I know this question has been solved long time ago, but here is another solution using new features of Java 8. Using Java streams the whole exercise can be written in one line:

Arrays.asList(new String[]{"Java my love"}) //start with a list containing 1 string item
            .stream() //start the stream
            .flatMap(x -> Stream.of(x.split(" "))) //split the string into words
            .map((String x) -> x.length()) //compute the length of each word
            .sorted((Integer x, Integer y) -> x-y) //sort words length (not necessary)
            .collect(Collectors.groupingBy(x -> x, Collectors.counting())) //this is tricky: collect results to a map: word length -> count
            .forEach((x,y) -> {System.out.println("There are " + y + " word(s) with " + x + " letter(s)");}); //now print each result

Probably in few year time this would be a preferred method for solving such problems. Anyway it is worth knowing that such alternative exists.

Answer 5

To count words in text with we used Pattern class with while loop:

I. Case Sensitive word counts

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class CountWordsInText {

    public static void main(String[] args) {
        String paragraph = "I am at office right now."
                + "I love to work at office."
                + "My Office located at center of kathmandu valley";
        String searchWord = "office";
        Pattern pattern = Pattern.compile(searchWord);
        Matcher matcher = pattern.matcher(paragraph);
        int count = 0;
        while (matcher.find()) {
            count++;
        }
        System.out.println(count);

    }

}

II. Case Insensitive word counts

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class CountWordsInTextCaseInsensitive {


    public static void main(String[] args) {
        String paragraph = "I am at office right now."
                       + "I love to work at oFFicE."
                       +"My OFFICE located at center of kathmandu valley";
        String searchWord = "office";
        Pattern pattern = Pattern.compile(searchWord, Pattern.CASE_INSENSITIVE);
        Matcher matcher = pattern.matcher(paragraph);
        int count = 0;
        while (matcher.find())
            count++;
        System.out.println(count);

    }

}

Answer 6

Idk, but using the length method as much as you have to figure out how the length mechanism works is like defining a word using the word. It's an honorable conquest figuring out how the length method works, but you should probably avoid using the length method.