Working with files

1. Working with files By the end of this lecture you should be able to: • explain the principles of input and output and identify a number of different input and output devices; • explain the concept of an I/O stream; • describe the basic file-handling techniques used in the Java language; • distinguish between text, binary and object encoding of data; • distinguish between serial access files and random access files; • create and access files in Java using all the above encoding and access methods.

2. standard input stream standard output stream Input and output file input stream Input:receiving information from the outside world Output: sending information back to the outside world. file output stream

3. Encoding Java supports three different ways of encoding data: Can be read by text editors as well as programs. “Java” “Charatan Kans” “34.99” TEXT Can only programs. 0010110110100 0001000100100 1101001001000 BINARY Can only read by another Java program. 1010111011010 1101000100101 1101001 00101 OBJECT

4. Types of File Access Serial access Each item of data is read (or written) in turn. Random access We go directly to the record we want .

5. The Car Class public class Car { private String registration; private String make; private double price; public Car (String registrationIn, String makeIn, double priceIn) { registration = registrationIn; make = makeIn; price = priceIn; } public String getRegistration() { return registration; } public String getMake() { return make; } public double getPrice() { return price; } }

6. Writing to text files “XV1 2AS” “Ford” “2499” PrintWriter FileWriter Cars.txt

7. Writing to text files private static void writeList (List<Car> carListIn) { try { FileWriter carFile = new FileWriter ("Cars.txt"); PrintWriter carWriter = new PrintWriter (carFile); for (Car item : carListIn) { carWriter.println ( item.getRegistration() ); carWriter.println ( item.getMake() ); carWriter.println ( item.getPrice() ); } carWriter.close(); } catch (IOException e) { System.out.println("There was a problem writing the file"); } }

8. Effects of writing to a text file

9. Reading from text files “XV1 2AS” “Ford” “2499” FileReader BufferedReader Cars.txt

10. private static void readList (List<Car> carListIn) { String tempReg; String tempMake; String tempStringPrice; double tempDoublePrice; try { FileReader carFile = new FileReader ("Cars.txt"); BufferedReader carStream = new BufferedReader (carFile); tempReg = carStream.readLine(); while (tempReg != null) { // code to read data goes here } carStream.close(); } // code to catch exceptions goes here }

11. Code to read data tempMake = carStream.readLine(); tempStringPrice = carStream.readLine(); tempDoublePrice = Double.parseDouble(tempStringPrice); carListIn.add (new Car(tempReg,tempMake,tempDoublePrice)); tempReg = carStream.readLine();

12. Code to catch exceptions catch(FileNotFoundException e) { System.out.println("\nNo file was read"); } catch(IOException e) { System.out.println ("\nThere was a problem reading the file"); }

13. Writing to binary files 0010010011001 1110101001001 0001001001111 DataOutputStream FileOutputStream Cars.bin

14. private static void writeList (List<Car> carListIn) { Car tempCar; try { FileOutputStream carFile = new FileOutputStream("Cars.bin"); DataOutputStream carWriter = new DataOutputStream(carFile); for (Car item : carListIn) { carWriter.writeUTF(item.getRegistration()); carWriter.writeUTF(item.getMake()); carWriter.writeDouble(item.getPrice()); } carWriter.close(); } catch(IOException e) { System.out.println("There was a problem writing the file"); } }

15. The effects of writing to a binary file

16. Reading from binary files 0010010011001 1110101001001 0001001001111 DataInputStream FileInputStream Cars.bin

17. Reading from a binary file private static void readList (List<Car> carListIn) { String tempReg; String tempMake; double tempPrice; boolean endOfFile = false; try { FileInputStream carFile = new FileInputStream ("Cars.bin"); DataInputStream carStream = new DataInputStream (carFile); while(endOfFile == false) { // code to read data here } carStream.close(); } // code to catch FileNotFoundException and IOException here }

18. Code to read data try { tempReg = carStream.readUTF(); tempMake = carStream.readUTF(); tempPrice = carStream.readDouble(); carListIn.add(new Car(tempReg, tempMake, tempPrice)); } catch(EOFException e) { endOfFile = true; }

19. Object serialization Enables us to read and write whole objects from and to files; The process of converting an object into a stream of data suitable for storage on a disk is called serialization; Any class whose objects are to be read and written using the above methods must implement the interface Serializable; import java.io.*; public class Car implements Serializable { // rest of code here }

20. Writing to object files 0010010011001 1110101001001 0001001001111 ObjectOutputStream FileOutputStream Cars.obf

21. Writing objects to a file private static void writeList(List<Car> carListIn) { try { FileOutputStream carFile = new FileOutputStream("Cars.obf"); ObjectOutputStream carStream = new ObjectOutputStream(carFile); for (Car item : carListIn) { carStream.writeObject(item); } carStream.close(); } catch(IOException e) { System.out.println("There was a problem writing the file"); } }

22. Reading from object files 0010010011001 1110101001001 0001001001111 ObjectInputStream FileInputStream Cars.obf

23. Reading objects from a file private static void readList(List<Car> carListIn) { boolean endOfFile = false; Car tempCar; try { FileInputStream carFile = new FileInputStream("Cars.obf"); ObjectInputStream carStream = new ObjectInputStream(carFile); tempCar = (Car) carStream.readObject(); while(endOfFile != true) { // code to read data here } carStream.close(); } // code to catch exceptions here }

24. Code to read data try { carListIn.add(tempCar); tempCar = (Car) carStream.readObject(); } catch(EOFException e) { endOfFile = true; }

25. catch(FileNotFoundException e) { System.out.println("\nNo file was read"); } catch(ClassNotFoundException e) // thrown by readObject { System.out.println ("\nTrying to read an object of an unknown class"); } catch(StreamCorruptedException e) // thrown by the constructor { System.out.println("\nUnreadable file format"); } catch(IOException e) { System.out.println("There was a problem reading the file"); }