class WordsAndCount
{
    // instance variables - replace the example below with your own
    private String Word;
    private int Frequency;
 
    /**
     * Constructor for objects of class WordsAndCount
     */
    public WordsAndCount()
    {
        // initialise instance variables
       Word = "unknown";
       Frequency = 0;
    }
 
   WordsAndCount(String w, int f)
    {
        // initialise instance variables
        Word = w;
        Frequency = f;
    }
}
 

import java.io.FileReader;
import java.io.BufferedReader;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.io.IOException;
import java.io.FileNotFoundException;
import java.util.StringTokenizer;
 
/**
 * Write a description of class WordsFrequency here.
 *
 * @author (your name)
 * @version (a version number or a date)
 */
public class WordsFrequency
{
	public static void main(String[] args)
        throws IOException
    {
 
 
 
	    // Initializations
 
        FileReader reader = null;
        FileWriter writer = null;
 
        String inFileName = "TextIn.txt";
        String outFileName = "WordsReport.txt";
 
 
        // Open input and output files
 
   try
		{
			reader = new FileReader(inFileName);
			writer = new FileWriter(outFileName);
		}
 
   catch(FileNotFoundException e)
		{
			System.err.println("Cannot find input file ");
			System.exit(1); // abnormal termination status code
		}
 
   catch(IOException e)
		{
			System.err.println("Cannot open input/output file ");
			System.exit(2);
		}
 
	// Set up to read a line and write a line
	   BufferedReader in = new BufferedReader(reader);
	   PrintWriter out = new PrintWriter(writer);
	   WordsAndCount [] words;
	   WordsAndCount w = null;
	   words = new WordsAndCount[20];
        int wordCount = 0;
 
		for (int i = 0; i <wordCount; i++)
		{
 
						String word;
						String inputLine = in.readLine();
						
						word = in.readLine();
	            		words[i] = w;
 
 
			    // initialize a tokenizer and attach it to a line
			   boolean done = false;
			   	   while(!done)
			   	   {
			   		   if(inputLine == null)
 
			   		   done = true;
 
			   		   else
			   		   {
			   			   StringTokenizer tokenizer = new StringTokenizer(inputLine, " ");
 
			   			   while( tokenizer.hasMoreElements() )
 
			   			   out.println( (String)tokenizer.nextElement() );
			   		   }
			       }
 
	  	}
 
 
    static void insertWord(String w)
   {
    // Insert the word w into the array of words, unless it already
    // appears there.  If the word already appears in the list,
    // add 1 to the counter for that word.  The words in the array are in
    // lower case,  and w is converted to lower case before it is processed.
    // Note that the words in the array are kept in alphabetical order.
    // If the array has no more space to hold w, then it is doubled
    // in size.
 
    int pos = 0;
 
    w = w.toLowerCase();
 
    /* Find the position in the array where w belongs, after all the
	   words that precede w alphabetically.  If a copy of w already
	   occupies that position, then it is not necessary to insert
	   w, so just add 1 to the counter associated with the word
       and return.
    */
 
    while (pos < wordCount && words[pos].word.compareTo(w) < 0)
	      pos++;
		if (pos < wordCount && words[pos].word.equals(w))
		{
	      words[pos].count++;
	      return;
		}
		insertWord(in.getAlpha());
   }
 
   static void putWordList(FileWriter outFileName)
   {
   // Write the list of words from the words array, along with their
   // associated frequencies, to the output stream specified in the
   // parameter to this subroutine.  Words are output in a column
   // that is 20 spaces wide.  If an individual word is longer than
   // 15 spaces, the output won't be quite so neat.
          for (int i = 0; i < wordCount; i++)
          {
             out.print("   ");
             out.println(words[i].word);
             for (int space = words[i].word.length(); space < 20; space++)
             out.println(" ");
             out.println(" ");
             out.println(words[i].count);
          }
   }
 
   static void sortByFrequency()
   {
    // Use insertion sort to sort the words in the list so that they
    // are in order of decreasing frequency.  (Note that insertion sort
    // has the following neat property:  In a group of words that all
    // have the same frequency, the words will remain in alphabetical
    // order after the words have been sorted by frequency.)
 
            for (int i = 1; i < wordCount; i++)
            {
                WordsAndCount temp = words[i];  // Save the word in position i.
                int position;              // An index in the array.
                position = i - 1;
                while (position >= 0 && words[position].count < temp.count)
              	{
                      // Bump words that have frequencies less than the frequency
                      // of temp up one space in the array.
                   words[position + 1] = words[position];
                   position--;
            	}
                words[position + 1] = temp;  // Put temp in last vacated space.
			}
    };
 
   }
}