The discussion revolves around how to count the number of lines, words, and characters in a text file using Java. Participants explore various methods and classes related to file input and output, including BufferedReader, StreamTokenizer, and the distinction between streams and readers/writers.
Participants express varying levels of understanding regarding file I/O concepts, with some agreeing on the methods to use while others remain confused about the distinctions between streams and readers/writers. No consensus is reached on the best approach to implement the counting functions.
Participants mention specific Java classes and methods, but there are unresolved issues related to the correct implementation of counting characters, words, and lines, as well as the proper use of StreamTokenizer. Some assumptions about the structure of the file and the counting logic are not fully explored.
public static int countChar(File f)
{
int charCount = 0;
try
{
FileReader fr = new FileReader(f);
BufferedReader br = new BufferedReader(fr);
while (br.readLine() != null)
{
String stringRead = br.readLine();
StringTokenizer st = new StringTokenizer(stringRead);
while (st.hasMoreTokens())
{
charCount += (st.nextToken()).length();
}
}
br.close();
}
catch (FileNotFoundException fnfe)
{
UserInterface.showFileNotFoundError();
}
catch (IOException ioe)
{
JOptionPane.showMessageDialog(null, ioe.toString(), "Error",
JOptionPane.ERROR_MESSAGE);
}
return charCount;
}Here you are reading the line twice--that's two calls to br.readLine() you have here. That's not what you want, and indeed it might cause you to go past the end of the file. Instead you should saymuna580 said:
while ((stringRead = br.readLine()) != null)
{The total number of characters in the file is not the combined length of all the tokens. "the cat" has seven characters, not 6. Instead of counting the token lengths, you should say
By the way, it will be easier to count all three lengths at the same time. In addition to having a charCount variable, you should have a lineCount variable that you increase by 1 at each step (every time you read a line), and a wordCount variable that you increase by 1 for each token. You can return them in an array.
public static int countLines(File f)
{
int lineCount = 0;
try
{
FileReader fr = new FileReader(f);
StreamTokenizer s = new StreamTokenizer(fr);
s.eolIsSignificant(true);
while(s.nextToken() != s.TT_EOF)
{
lineCount = s.lineno();
}
}
catch (FileNotFoundException fnfe)
{
UserInterface.showFileNotFoundError();
}
catch (IOException ioe)
{
JOptionPane.showMessageDialog(null, ioe.toString(), "Error",
JOptionPane.ERROR_MESSAGE);
}
return lineCount;
}
// coutns the numebr of words
public static int countWords(File f)
{
int wordCount = 0;
try
{
FileReader fr = new FileReader(f);
BufferedReader br = new BufferedReader(fr);
String x = br.readLine();
while (x != null)
{
String stringRead = x;
StringTokenizer st = new StringTokenizer(stringRead);
while (st.hasMoreTokens())
{
st.nextToken();
wordCount++;
}
x = br.readLine();
}
br.close();
}
catch (FileNotFoundException fnfe)
{
UserInterface.showFileNotFoundError();
}
catch (IOException ioe)
{
JOptionPane.showMessageDialog(null, ioe.toString(), "Error",
JOptionPane.ERROR_MESSAGE);
}
return wordCount;
}
public static int countChar(File f)
{
int charCount = 0;
try
{
FileReader fr = new FileReader(f);
BufferedReader br = new BufferedReader(fr);
String x = br.readLine();
while (x != null)
{
String stringRead = x;
StringTokenizer st = new StringTokenizer(stringRead);
while (st.hasMoreTokens())
{
charCount += (st.nextToken()).length();
}
x = br.readLine();
}
br.close();
}
catch (FileNotFoundException fnfe)
{
UserInterface.showFileNotFoundError();
}
catch (IOException ioe)
{
JOptionPane.showMessageDialog(null, ioe.toString(), "Error",
JOptionPane.ERROR_MESSAGE);
}
return charCount;
} // Method countLineWordChar counts the number of lines, words, and chars, in
// a file given as a parameter. This method returns an array of intergers. In
// the array, the first position is the amount of lines, the second posistion
// is the amount of words, and the third is the amount of chars.
public static int[] countLineWordChar(File f)
{
int[] countInfo = new int[3];
int lineCount = 0;
int wordCount = 0;
int charCount = 0;
try
{
FileReader fr = new FileReader(f);
StreamTokenizer st = new StreamTokenizer(fr);
st.eolIsSignificant(true);
while(st.nextToken() != StreamTokenizer.TT_EOF)
{
switch(st.ttype)
{
case StreamTokenizer.TT_WORD:
wordCount++;
String wordRead = st.sval;
charCount += wordRead.length();
break;
case StreamTokenizer.TT_EOL:
lineCount++;
break;
default:
break;
}
}
}
catch (FileNotFoundException fnfe)
{
UserInterface.showFileNotFoundError();
}
catch (IOException ioe)
{
JOptionPane.showMessageDialog(null, ioe.toString(), "Error",
JOptionPane.ERROR_MESSAGE);
}
countInfo[0] = lineCount;
countInfo[1] = wordCount;
countInfo[2] = charCount;
return countInfo;
}
// Based on the countLineWordChar method, returns the amount of lines.
public static int getLineCount(int[] countInfo)
{
return countInfo[0];
}
// Based on the countLineWordChar method, returns the amount of words.
public static int getWordCount(int[] countInfo)
{
return countInfo[1];
}
// Based on the countLineWordChar method, returns the amount of chars.
public static int getCharCount(int[] countInfo)
{
return countInfo[2];
}Well, FileReader is just a convenience class. Basically,muna580 said:
That depends entirely on what information you want to know about the exception. The printStackTrace() will give you the description of the problem as well as information about where the problem occurred, and the toString() will give you just the description of the problem. Basically in I/O anytime you do any reading or writing, you'll probably run the risk of an IOException. If you use Eclipse to write your code, it will remind you to put try/catch blocks if you've forgotten them.
I'm not familiar with the StreamTokenizer. Usually I just use a StringTokenizer. You might watch out that StreamTokenizer parses numbers by default--it doesn't just break up the file by whitespace.
try {
PrintWriter pw = new PrintWriter(new File("C:/Writer.txt"));
pw.print(123);
pw.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} finally {
}
try {
OutputStream is = new FileOutputStream("C:/InputStream.txt");
is.write(123);
is.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}Scanner consoleInput = new Scanner(System.in);
consoleInput.readInt();Scanner fileInput = new Scanner(new File(filename));
while(fileInput.hasNextLine()){
String line = fileInput.nextLine();
// ... do work on the line
}
fileInput.close(); // just to be sure.haki said: