File I/O and figuring out how to get this working

Question

I need to get this code to readi in a file from anywhere, which it does, and then calculate the sentences, words per sentence and syllables per word, this is my code so far
// Standard imports.
import javax.swing.*;
import javax.swing.event.*;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;
class WritingFilesWithChooser extends JFrame implements ActionListener {
     JButton myButton, myButton2;
     JTextArea myText;
     // Usual setup stuff goes in here.
     public WritingFilesWithChooser() {
          Container c = getContentPane();
          myButton = new JButton ("Write To File");
          myButton.addActionListener (this);
          myButton2 = new JButton ("Load from File");
          myButton2.addActionListener (this);
          c.add (myButton, BorderLayout.NORTH);
          myText = new JTextArea (10, 10);
          c.add (myText, BorderLayout.CENTER);
          c.add (myButton2, BorderLayout.SOUTH);
     // Usual main stuff.
     public static void main(String args[]) {
          WritingFilesWithChooser mainFrame = new WritingFilesWithChooser();
          mainFrame.setSize(400, 400);
          mainFrame.setTitle("WritingFilesWithChooser");          
          mainFrame.setVisible(true);
     // The actionPerformed for this class is a busy little beaver. It handles
     // opening and saving files, trying and catching exceptions, and dealing
     // with the chooser dialog.
     public void actionPerformed (ActionEvent e) {
     // We need these variables for our File IO.
     FileWriter base;
          PrintWriter out;
          FileReader readBase;
          BufferedReader in;
          String temp;
          JFileChooser myChooser;
          // We create an instance of JFileChooser, which allows us to use a
          // GUI style file manager to choose filenames.
          myChooser = new JFileChooser();
          // Okay, they've chosen the save button.
          if (e.getSource() == myButton) {
               // First we show the save dialog, which lets the user specifiy a
               // filename to save. If the user clicks 'save', then this if
               // condition will evaluate to true and the code within will be
               // executed. If they select cancel, then nothing will happen.
               if (myChooser.showSaveDialog(this) == JFileChooser.APPROVE_OPTION) {
                    // There are often exceptions thrown when dealing with file I/O,
                    // so we need this code to deal with it.
                    try {                         
                         // We create an instance of the FileWriter object using the
                         // Chooser object. GetSelectedFile of the chooser object returns
                         // a file reference, and we call getAbsolutePath on that to get
                         // the full filename, which is returned as a string.
                         base = new FileWriter (myChooser.getSelectedFile().getAbsolutePath());
                         // We use the FileWriter object we created above as the base of
                         // the printwriter object.
                         out = new PrintWriter (base);
                         // We grab the text out of our textbox and write it to a text
                         // file.
                         out.write (myText.getText());
                         // When we're done, we close the file.
                         out.close();
                    catch (Exception except) {
                         // This will appear if there is a horrible error. More on this
                         // in week twelve.
                         JOptionPane.showMessageDialog (null, "A Horrible Error!");               
          else {
               // First we show the open dialog, which lets the user specifiy a
               // filename to open. If the user clicks 'open', then this if
               // condition will evaluate to true and the code within will be
               // executed. If they select cancel, then nothing will happen.
               if (myChooser.showOpenDialog(this) == JFileChooser.APPROVE_OPTION) {
                    // There are often exceptions thrown when dealing with file I/O,
                    // so we need this code to deal with it.
                    try {
                         // We create an instance of the FileReader object using the
                         // Chooser object. GetSelectedFile of the chooser object returns
                         // a file reference, and we call getAbsolutePath on that to get
                         // the full filename, which is returned as a string.
                         readBase = new FileReader (myChooser.getSelectedFile().getAbsolutePath());
                         // We use the FileReader object we created above as the base of
                         // the BufferedReaderobject.
                         in = new BufferedReader (readBase);
                         // We read a single line from the file we selected.
                         temp = in.readLine();                         
                         temp.toLowerCase();
                         String i;
                         String word;
                         word = temp;
                         int nsyl = 0;
                         int leng = 0;
                         boolean last = true;
                         for (int j=0; j<word.length(); j ++)
                              if(word.charAt(i) = ' ')
                                   leng ++;
                         for (int k =0;k<word.length(); k++)
                              if (word.charAt(i) == 'a' || word.charAt(i) == 'e' ||
                                   word.charAt(i) == 'i' || word.charAt(i) == 'o' ||
                                   word.charAt(i) == 'u')
                                   nsyl++;
                              if (word.charAt(i) == 'a' || word.charAt(i) == 'e' ||
                                   word.charAt(i) == 'i' || word.charAt(i) == 'o' ||
                                   word.charAt(i) == 'u')
                                        last = false;
                              else {
                              last = true;
                              if (word.length(word) == "e ")
                              nsyl --;
                         // We clear the textbox, ready for us to dump our goodness into
                         // it.                         
                         myText.setText ("");
                         // This loop will continue while there are still lines to read.
                         // When the readLine method gets to the end of the file, it will
                         // assign the value 'null' to the temp variable.
                         while (temp != null) {
                              // While the temp variable isn't null, we append it to the
                              // text already in the textbox. We add the \n character to
                              // the end to force a new line.
                              myText.append (temp + "\n");
                              // We read in the next line of the file.
                              temp = in.readLine();
                         // Finally, we close the file.
                         in.close();
                    catch (Exception except) {
                         // This will appear if there is a horrible error. More on this
                         // in week twelve.
                         JOptionPane.showMessageDialog (null, "A Horrible Error!");               

Answer 1

How about taking a look at the String class. In jdk1.4 and later there are methods such as split() which can
split a paragraph up into sentances. (split(".") ) then can split the sentance up into words (split(" ")). Push
all of the words into a HashMap with an integer indicating the number of times they have occured.
Then run through the HashMap and for each entry search for vowels/sylables/whatever.
This is probably the easiset method of doing what you want but it is limited in the size of file it can parse
efficiently.
matfud