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, IOException and FileNotFoundException)

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)

The FileReader and FileWriter classes always 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 :

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

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

Scanner scanner = 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.*;
2. 
   
3. publicclassReadWriteTextFile{
4. 
   
5. /**
6. *Fetchtheentirecontentsofatextfile,andreturnitinaString.
7. *ThisstyleofimplementationdoesnotthrowExceptionstothecaller.
8. *
9. *@paramaFileisafilewhichalreadyexistsandcanberead.
10. */
11. staticpublicStringgetContents(FileaFile){
12. //...checksonaFileareelided
13. StringBuildercontents=newStringBuilder();
15. try{
16. //usebuffering,readingonelineatatime
17. //FileReaderalwaysassumesdefaultencodingisOK!
18. BufferedReaderinput=newBufferedReader(newFileReader(aFile));
19. try{
20. Stringline=null;//notdeclaredwithinwhileloop
21. /*
22. *readLineisabitquirky:
23. *itreturnsthecontentofalineMINUSthenewline.
24. *itreturnsnullonlyfortheENDofthestream.
25. *itreturnsanemptyStringiftwonewlinesappearinarow.
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(IOExceptionex){
37. ex.printStackTrace();
38. }
40. returncontents.toString();
41. }
42. 
    
43. /**
44. *Changethecontentsoftextfileinitsentirety,overwritingany
45. *existingtext.
46. *
47. *Thisstyleofimplementationthrowsallexceptionstothecaller.
48. *
49. *@paramaFileisanexistingfilewhichcanbewrittento.
50. *@throwsIllegalArgumentExceptionifparamdoesnotcomply.
51. *@throwsFileNotFoundExceptionifthefiledoesnotexist.
52. *@throwsIOExceptionifproblemencounteredduringwrite.
53. */
54. staticpublicvoidsetContents(FileaFile,StringaContents)
55. throwsFileNotFoundException,IOException{
56. if(aFile==null){
57. thrownewIllegalArgumentException("Fileshouldnotbenull.");
58. }
59. if(!aFile.exists()){
60. thrownewFileNotFoundException("Filedoesnotexist:"+aFile);
61. }
62. if(!aFile.isFile()){
63. thrownewIllegalArgumentException("Shouldnotbeadirectory:"+aFile);
64. }
65. if(!aFile.canWrite()){
66. thrownewIllegalArgumentException("Filecannotbewritten:"+aFile);
67. }
68. 
    
69. //usebuffering
70. Writeroutput=newBufferedWriter(newFileWriter(aFile));
71. try{
72. //FileWriteralwaysassumesdefaultencodingisOK!
73. output.write(aContents);
74. }
75. finally{
76. output.close();
77. }
78. }
79. 
    
80. /**Simpletestharness.*/
81. publicstaticvoidmain(String...aArguments)throwsIOException{
82. FiletestFile=newFile("C:\\Temp\\blah.txt");
83. System.out.println("Originalfilecontents:"+getContents(testFile));
84. setContents(testFile,"Thecontentofthisfilehasbeenoverwritten...");
85. System.out.println("Newfilecontents:"+getContents(testFile));
86. }
87. }
88. 
    

Example 2 This example demonstrates using Scanner to read a file line by line (it does not perform a write operation) :

1. importjava.io.*;
2. importjava.util.Scanner;
4. publicfinalclassReadWithScanner{
6. publicstaticvoidmain(String...aArgs)throwsFileNotFoundException{
7. ReadWithScannerparser=newReadWithScanner("C:\\Temp\\test.txt");
8. parser.processLineByLine();
9. log("Done.");
10. }
12. /**
13. *@paramaFileNamefullnameofanexisting,readablefile.
14. */
15. publicReadWithScanner(StringaFileName){
16. fFile=newFile(aFileName);
17. }
19. /**Templatemethodthatcalls{@link#processLine(String)}.*/
20. publicfinalvoidprocessLineByLine()throwsFileNotFoundException{
21. Scannerscanner=newScanner(fFile);
22. try{
23. //firstuseaScannertogeteachline
24. while(scanner.hasNextLine()){
25. processLine(scanner.nextLine());
26. }
27. }
28. finally{
29. //ensuretheunderlyingstreamisalwaysclosed
30. scanner.close();
31. }
32. }
34. /**
35. *Overridablemethodforprocessinglinesindifferentways.
36. *
37. *<P>Thissimpledefaultimplementationexpectssimplename-valuepairs,separatedbyan
38. *'='sign.Examplesofvalidinput:
39. *<tt>height=167cm</tt>
40. *<tt>mass=65kg</tt>
41. *<tt>disposition="grumpy"</tt>
42. *<tt>thisisthename=thisisthevalue</tt>
43. */
44. protectedvoidprocessLine(StringaLine){
45. //useasecondScannertoparsethecontentofeachline
46. Scannerscanner=newScanner(aLine);
47. scanner.useDelimiter("=");
48. if(scanner.hasNext()){
49. Stringname=scanner.next();
50. Stringvalue=scanner.next();
51. log("Nameis:"+quote(name.trim())+",andValueis:"+quote(value.trim()));
52. }
53. else{
54. log("Emptyorinvalidline.Unabletoprocess.");
55. }
56. //(noneedforfinallyhere,sinceStringissource)
57. scanner.close();
58. }
60. //PRIVATE//
61. privatefinalFilefFile;
63. privatestaticvoidlog(ObjectaObject){
64. System.out.println(String.valueOf(aObject));
65. }
67. privateStringquote(StringaText){
68. StringQUOTE="'";
69. returnQUOTE+aText+QUOTE;
70. }
71. }