File I/O

Reading/writing from/to files is an important component of many Java programs.

The File class from java.io package is used to represent a file in Java.

• A file can represent a file or a directory/folder.
• Representing a file:
  • In the current directory

File inFile = new File("stuff.txt");

• In a specified directory directory

File inFile = new File("C:/data/stuff.txt");

• Representing a directory:

File directory = new File("C:/data");

• Here are a few methods that will likely prove useful to you:
  • inFile.exists() – true if inFile is correctly associated with a file or directory
  • inFile.isFile() – true if inFile is correctly associated with a file
  • inFile.isDirectory() – true if inFile is correctly associated with a directory
  • inFile.list() – returns an array of strings naming the files and directories in the directory associated with inFile (or null, if not a directory)

The following example code will display a does not exist message if the stuff.txt file is not in the current directory.

File inFile = new File("stuff.txt");
if(inFile.exists()==false) {
  System.out.println("stuff.txt does not exist");
}

The following example code will display a list of all of the filenames (but not subdirectory names) of the files in the specified directory.

String dirName = "c:/data/se1020/eclipse/se1020";
File directory = new File(dirName);
if(directory.isDirectory()==false) {
  System.out.println(dirName + "does not exist");
} else {
  File[] files = directory.listFiles();
  for(int i=0; i<files.length; ++i)
  {
    if(files[i].isFile()) {
      System.out.println(files[i]);
    }
  }
}

• File input and output is managed through data streams.
• These file streams function in much the same way as the console input and output streams do.
• There are a variety of standard streams provided in Java
• Low-level file I/O for raw byte I/O, similar to System.in.read() and System.out.write()
  • FileInputStream – reads raw bytes
  • FileOutputStream – writes raw bytes
• High-level file I/O for I/O of primitive data types
  • DataInputStream – reads primitive data types
  • DataOutputStream – writes primitive data types
• Text file I/O for I/O of text
  • Scanner – reads and parses text
  • PrintWriter – writes text
• Object file I/O for I/O of arbitrary object data
  • ObjectInputStream – reads arbitrary object data
  • ObjectOutputStream – writes arbitrary object data

• Low-Level refers to techniques being closer to what the computer understands whereas High-Level refers to techniques being abstracted away from how the computer understands them.
• Typically High-Level is more intuitive for humans but usually requires more steps (for the computer anyway) to accomplish.
• Low-Level file I/O involves reading and writing byte chunks of data.
• Writing involves use of the FileOutputStream.write() method which can accept either a byte value (specified as an int) or an array of bytes.
• The following code appends some data to a file. The file is created if it did not exist prior to running this code:

File outFile = new File("test.dat");
if(!outFile.isDirectory())
{
  try {
    if(!outFile.isFile())
    {
      outFile.createNewFile();
    }
    boolean append = true;
    FileOutputStream out = new FileOutputStream(outFile, append);
    out.write('a');
    out.write('d');
    out.write(1000000);
    out.write(-1000000);
    byte[] byteArray = { 5, 20, 32, 'C', 'T' };
    out.write(byteArray);
    System.out.println("Data written");
    out.close();
  }
  catch(FileNotFoundException e) {
    System.err.println("File not found");
    System.err.println(e.getMessage());
  }
  catch(IOException e) {
    System.err.println(e.getMessage());
  }
} else {
  System.err.println("Sorry.  We can't append to a directory");
}

• Reading involves use of a FileInputStream.read() method. Two of these are:
  • FileInputStream.read() which returns the byte (as an int) that it read.
  • FileInputStream.read(byte[] b) which reads up to b.length bytes from the input stream and places them in the byte array. The method returns the number of bytes that it read from the input stream.
• The following code reads some data from a file:

File inFile = new File("test.dat");
if(inFile.isFile())
{
  try {
    FileInputStream in = new FileInputStream(inFile);
    int i = in.read();
    int j = in.read();
    int k = in.read();
    int l = in.read();
    int m = in.read();
    byte[] byteArray = new byte[5];
    if(5!=in.read(byteArray))
    {
      System.err.println("Couldn't find five bytes in the file");
    }
    System.out.println("Data read");
    in.close();
  }
  catch(FileNotFoundException e) {
    System.err.println("File not found");
    System.err.println(e.getMessage());
  }
  catch(IOException e) {
    System.err.println(e.getMessage());
  }
}

• High-level file I/O involves making use of an additional layer of classes to add “improved” functionality.
• The DataInputStream makes use of a FileInputStream object to do the actual work.
• The DataInputStream class provides methods to read primitive data types:
  • readBoolean()
  • readByte()
  • readChar()
  • readInt()
  • readDouble()
  • readFloat()
  • read(byte[] b) – same as FileInputStream's method
• The DataOutputStream makes use of a FileOutputStream object to do the actual work.
• The DataOutputStream class provides methods to write primitive data types:
  • writeBoolean()
  • writeByte()
  • writeChar()
  • writeInt() – writes four bytes, high byte first
  • writeLong() – writes eight bytes, high byte first
  • writeDouble() – converts to long using Double.doubleToLongBits then uses writeLong()
  • writeFloat() – converts to long using Float.floatToIntBits then uses writeInt()
  • writeChars() – Writes a String
• What follows is an example.

File outFile = new File("test2.dat");
if(!outFile.isDirectory())
{
  try {
    if(!outFile.isFile())
    {
      outFile.createNewFile();
    }
    FileOutputStream out = new FileOutputStream(outFile, true);
    DataOutputStream dOut = new DataOutputStream(out);
    dOut.writeInt(43);
    dOut.writeBoolean(false);
    dOut.writeDouble(Math.PI);
    System.out.println("Data written");
    dOut.close();
    out.close();
  }
  catch(FileNotFoundException e) {
    System.err.println("File not found");
    System.err.println(e.getMessage());
  }
  catch(IOException e) {
    System.err.println(e.getMessage());
  }
} else {
  System.err.println("Sorry.  We can't append to a directory");
}
 
File inFile = new File("test.dat");
if(inFile.isFile())
{
  try {
    FileInputStream in = new FileInputStream(inFile);
    DataInputStream dIn = new DataInputStream(in);
    int i = dIn.readInt();
    boolean j = dIn.readBoolean();
    double k = dIn.readDouble();
    System.out.println("Data read");
  }
  catch(FileNotFoundException e) {
    System.err.println("File not found");
    System.err.println(e.getMessage());
  }
  catch(IOException e) {
    System.err.println(e.getMessage());
  }
}

• Often times we may prefer to store data in a file as text instead of raw binary data.
• Doing so makes it possible for someone to read and interpret the data file created by our Java program.
• In much the same way as we display text to the console (using System.out.print() or System.out.println()), we can send text to a file.
• A PrintWriter object has all of the same functionality as System.out.
• In fact, System.out is an object from the PrintStream class which is very similar to the PrintWriter class… Yes, that's right, System.out is an object (and so is System.in).
• The following code creates an input file (if a directory with the same name doesn't already exist) and writes one line of text to it:

File outFile = new File("test.txt");
if(!outFile.isDirectory())
{
  try {
    if(!outFile.isFile())
    {
      outFile.createNewFile();
    }
    FileOutputStream outFS = new FileOutputStream(outFile, false);
    PrintWriter out = new PrintWriter(outFS);
    out.println("This is so much fun");
    System.out.println("Data written");
    out.close();
  }
  catch(FileNotFoundException e) {
    System.err.println("File not found");
    System.err.println(e.getMessage());
  }
  catch(IOException e) {
    System.err.println(e.getMessage());
  }
} else {
  System.err.println("Sorry.  We can't append to a directory");
}

• System.in is an InputStream object.
• The easiest way to read information from the keyboard is to attach a Scanner object to the System.in input stream.
• In much the same way, we can read text data from a file by attaching a Scanner object to a FileInputStream.
• The following code creates a file, writes some text to it, and then reads and displays each word on a separate line.

File inFile = new File("test.txt");
if(inFile.isFile())
{
  try {
    FileInputStream inFS = new FileInputStream(inFile);
    Scanner in = new Scanner(inFS);
    while(in.hasNext())
    {
      System.out.println(in.next());
    }
    System.out.println("Data read");
  }
  catch(FileNotFoundException e) {
    System.err.println("File not found");
    System.err.println(e.getMessage());
  }
  catch(IOException e) {
    System.err.println(e.getMessage());
  }
}

• If we want to store the value of an object in a file, one way would be to store the value of each field.
• This may require a significant amount of code to accomplish.
• However, each object in our Java program is stored in memory as a bunch of ones and zeros.
• What if we could just write this “memory footprint” to a file automatically.
• That's the idea behind Object File I/O.
• ObjectOutputStream provides a writeObject() method
• The data is stored in binary form.
• The code following creates a file and saves three objects (an Integer, String and Date) in it:

FileOutputStream fos = new FileOutputStream("test3.dat");
ObjectOutputStream out = new ObjectOutputStream(fos);
 
out.writeInt(178);
out.writeObject("I am a string");
out.writeObject(new Date());
 
out.close();

• ObjectInputStream provides a readObject() method
• The following code reads the three values back into objects:

FileInputStream fis = new FileInputStream("test3.dat");
ObjectInputStream in = new ObjectInputStream(fis);
 
int i = in.readInt();
String phrase = (String)in.readObject();
Date date = (Date)in.readObject();
 
in.close();

• Notice that the value returned from the readObject() call must be cast to the appropriate type of object.
• Any kind of object can be saved in this way as long as the class declaration includes “implements Serializable” e.g.,

class SomeSillyClass implements Serializable {
  // ...
}

• The class doesn't have to actually implement any additional methods (except under special situations when a class may be required to have a custom implementation of readObject and writeObject)