Reading and writing text files

When reading and writing text files :

• it is almost always a good idea to use buffering (default size is 8K)
• it is often possible to use references to abstract base classes, instead of references to specific concrete classes
• there is always a need to pay attention to exceptions (in particular,IOExceptionandFileNotFoundException)

The close method :

• always needs to be called, or else resources will leak
• will automatically flush the stream, if necessary
• calling close on a "wrapper" stream will automatically call close on its underlying stream
• closing a stream a second time has no consequence

Commonly used items :

• BufferedReader- readLine
• BufferedWriter- write + newLine
• Scanner- allows reading files in a compact way (example)

TheFileReaderandFileWriterclassesalways use the system's default character encoding. If this default is not appropriate (for example, when reading an XML file which specifies its own encoding), the recommended alternatives are, for example :

FileInputStreamfis = new FileInputStream("test.txt");
InputStreamReaderin = new InputStreamReader(fis, "UTF-8");

FileOutputStreamfos = new FileOutputStream("test.txt");
OutputStreamWriterout = new OutputStreamWriter(fos, "UTF-8");

Scannerscanner = new Scanner(file, "UTF-8");

Example 1

This example uses JDK 1.5. To make it compatible with JDK 1.4, just change StringBuilder to StringBuffer:

1. importjava.io.*;
3. publicclassReadWriteTextFile {
5. /**
6. * Fetch the entire contents of a text file, and return it in a String.
7. * This style of implementation does not throw Exceptions to the caller.
8. *
9. * @param aFile is a file which already exists and can be read.
10. */
11. staticpublicString getContents(File aFile) {
12. //...checks on aFile are elided
13. StringBuilder contents =newStringBuilder();
15. try{
16. //use buffering, reading one line at a time
17. //FileReader always assumes default encoding is OK!
18. BufferedReader input =newBufferedReader(newFileReader(aFile));
19. try{
20. String line =null;//not declared within while loop
21. /*
22. * readLine is a bit quirky :
23. * it returns the content of a line MINUS the newline.
24. * it returns null only for the END of the stream.
25. * it returns an empty String if two newlines appear in a row.
26. */
27. while(( line = input.readLine()) !=null){
28. contents.append(line);
29. contents.append(System.getProperty("line.separator"));
30. }
31. }
32. finally{
33. input.close();
34. }
35. }
36. catch(IOException ex){
37. ex.printStackTrace();
38. }
40. returncontents.toString();
41. }
43. /**
44. * Change the contents of text file in its entirety, overwriting any
45. * existing text.
46. *
47. * This style of implementation throws all exceptions to the caller.
48. *
49. * @param aFile is an existing file which can be written to.
50. * @throws IllegalArgumentException if param does not comply.
51. * @throws FileNotFoundException if the file does not exist.
52. * @throws IOException if problem encountered during write.
53. */
54. staticpublicvoidsetContents(File aFile, String aContents)
55. throwsFileNotFoundException, IOException {
56. if(aFile ==null) {
57. thrownewIllegalArgumentException("File should not be null.");
58. }
59. if(!aFile.exists()) {
60. thrownewFileNotFoundException ("File does not exist: "+ aFile);
61. }
62. if(!aFile.isFile()) {
63. thrownewIllegalArgumentException("Should not be a directory: "+ aFile);
64. }
65. if(!aFile.canWrite()) {
66. thrownewIllegalArgumentException("File cannot be written: "+ aFile);
67. }
69. //use buffering
70. Writer output =newBufferedWriter(newFileWriter(aFile));
71. try{
72. //FileWriter always assumes default encoding is OK!
73. output.write( aContents );
74. }
75. finally{
76. output.close();
77. }
78. }
80. /** Simple test harness. */
81. publicstaticvoidmain (String... aArguments)throwsIOException {
82. File testFile =newFile("C:\\Temp\\blah.txt");
83. System.out.println("Original file contents: "+ getContents(testFile));
84. setContents(testFile,"The content of this file has been overwritten...");
85. System.out.println("New file contents: "+ getContents(testFile));
86. }
87. }

Example 2 This example demonstrates using Scannerto reada file line by line (it does not perform a writeoperation) :

1. importjava.io.*;
2. importjava.util.Scanner;
4. publicfinalclassReadWithScanner {
6. publicstaticvoidmain(String... aArgs)throwsFileNotFoundException {
7. ReadWithScanner parser =newReadWithScanner("C:\\Temp\\test.txt");
8. parser.processLineByLine();
9. log("Done.");
10. }
12. /**
13. * @param aFileName full name of an existing, readable file.
14. */
15. publicReadWithScanner(String aFileName){
16. fFile =newFile(aFileName);
17. }
19. /** Template method that calls {@link #processLine(String)}. */
20. publicfinalvoidprocessLineByLine()throwsFileNotFoundException {
21. Scanner scanner =newScanner(fFile);
22. try{
23. //first use a Scanner to get each line
24. while( scanner.hasNextLine() ){
25. processLine( scanner.nextLine() );
26. }
27. }
28. finally{
29. //ensure the underlying stream is always closed
30. scanner.close();
31. }
32. }
34. /**
35. * Overridable method for processing lines in different ways.
36. *
37. *

    This simple default implementation expects simple name-value pairs, separated by an

38. * '=' sign. Examples of valid input :
39. *height = 167cm
40. *mass = 65kg
41. *disposition = "grumpy"
42. *this is the name = this is the value
43. */
44. protectedvoidprocessLine(String aLine){
45. //use a second Scanner to parse the content of each line
46. Scanner scanner =newScanner(aLine);
47. scanner.useDelimiter("=");
48. if( scanner.hasNext() ){
49. String name = scanner.next();
50. String value = scanner.next();
51. log("Name is : "+ quote(name.trim()) +", and Value is : "+ quote(value.trim()) );
52. }
53. else{
54. log("Empty or invalid line. Unable to process.");
55. }
56. //(no need for finally here, since String is source)
57. scanner.close();
58. }
60. // PRIVATE //
61. privatefinalFile fFile;
63. privatestaticvoidlog(Object aObject){
64. System.out.println(String.valueOf(aObject));
65. }
67. privateString quote(String aText){
68. String QUOTE ="'";
69. returnQUOTE + aText + QUOTE;
70. }
71. }