Java I/O

1. Java I/O Jussi Pohjolainen Tampere University of Applied Sciences

2. Intro •  Input / Output –  Input from ﬁle or keyboard –  Output to screen or a ﬁle •  To deliver data, stream is used

3. READ AND WRITE CONSOLE

4. Read and Write to Console •  Output stream: –  System.out •  Input Stream: –  System.in

5. PrintStream (System.out)

6. InputStream (System.in) Read a byte from user input?

7. Using InputStreamReader •  To use InputStreamReader –  InputStreamReader a = new InputStreamReader(System.in); •  An InputStreamReader is a bridge from byte streams to character streams: It reads bytes and decodes them into characters using a speciﬁed charset •  InputStreamReader has methods for reading one char at a Kme •  We don’t want to read one char at a .me from user!

8. Using BufferedReader •  To use InputStreamReader –  BufferedReader a = new BufferedReader(new InputStreamReader(System.in)); –  String mj = a.readLine(); •  Read text from a character-‐input stream, buffering characters so as to provide for the efficient reading of characters, arrays, and lines.

9. Scanner •  Or just use Scanner from Java 1.5! Scanner s = new Scanner(System.in); String mj = s.nextLine();

10. READ AND WRITE FILES

11. Binary vs text •  All data are in the end binary: –  01010101001011100110 •  Binary ﬁles: bits represent encoded informaKons, executable instrucKons or numeric data. •  Text ﬁles: the binarys represent characters.

12. Text ﬁles •  In text ﬁles bits represent printable characters •  In ASCII encoding, one byte represents one character •  Encoding is a rule where you map chars to integers. •  ‘a’ =97 > => 1100001

13. Example Encoding: ASCII

14. TesKng in Java class CharTest { public static void main(String [] args) { char myChar1 = 'a'; int myChar2 = 97; System.out.println(myChar1); // 'a' System.out.println(myChar2); // 97 System.out.println( (int) myChar1); // 97 System.out.println((char) myChar2); // 'a' } }

15. Character Streams •  To read characters –  FileReader •  To write characters –  FileWriter

16. FileReader import java.io.FileReader; import java.io.IOException; public class CharTest { public static void main(String[] args) throws IOException { FileReader inputStream = new FileReader("CharTest.java"); char oneChar = (char) inputStream.read(); System.out.println(oneChar); inputStream.close(); } }

17. FileReader: Reading MulKple Chars import java.io.FileReader; import java.io.IOException; public class CharTest { public static void main(String[] args) throws IOException { FileReader inputStream = new FileReader("CharTest.java"); int oneChar; while ((oneChar = inputStream.read()) != -1) { System.out.print((char) oneChar); } inputStream.close(); } }

18. FileWriter import java.io.FileWriter; import java.io.IOException; public class CharTest { public static void main(String[] args) throws IOException { FileWriter outputStream = new FileWriter("output.txt"); outputStream.write("hello!"); outputStream.close(); } }

19. Buffering •  Using unbuffered IO is less efficient than using buffered IO. •  Read stuff to buffer in memory and when buffer is full, write it. Less disk access or network acKvity

20. BuﬀeredReader import java.io.FileReader; import java.io.BufferedReader; import java.io.IOException; public class CharTest { public static void main(String[] args) throws IOException { BufferedReader inputStream = new BufferedReader(new FileReader("output.txt")); System.out.println( inputStream.readLine() ); inputStream.close(); } }

21. PrintWriter, BuﬀeredWriter •  Convenient way of wriKng ﬁles using PrintWriter: PrintWriter pw = new PrintWriter( new BufferedWriter( new FileWriter("output.txt"))); pw.println("hello!"); pw.close();

22. READING AND WRITING BYTES

23. Read and Write •  To Read –  FileInputStream •  To Write –  FileOutputStream

24. Read and Write FileInputStream in = new FileInputStream("output.txt"); FileOutputStream out = new FileOutputStream("outagain.txt"); int c; while ((c = in.read()) != -1) { out.write(c); } in.close(); out.close();

25. CLOSING STREAMS

26. import java.io.*; public class CharTest { public static void main(String[] args) { BufferedReader inputStream = null; try { inputStream = new BufferedReader(new FileReader("output.txt")); System.out.println( inputStream.readLine() ); } catch(IOException e) { e.printStackTrace(); } finally { try { if(inputStream != null) { inputStream.close(); } } catch(IOException e) { e.printStackTrace(); } } } }

27. JAVA 7 NEW FEATURES

28. Java 7 to the rescue!

29. How? •  Virtual Machine will call automaIcally the close method upon exiKng the try block (like ﬁnally) •  The resource object must implement AutoCloseable interface •  The interface has only one method: close •  If closing causes excepKon, it’s suppressed (ignore). Possible to get it using getSuppressed() method

30. Java 7 API

31. API Updates to File System •  java.io and java.nio are updated •  Called NIO.2 revision •  New classes (java.nio): –  Path – Locate a file in a file system •  Paths – Convert a URI to Path object –  Files – Operate on files, directories and other types of files –  FileVisitor – Traversing files in a tree –  WatchService – File change modificaKon API

32. File (Java 1.0 – 1.7) •  File class has very useful methods: –  exists –  canRead –  canWrite –  length –  getPath •  Example File f = new File(“file.txt”); If(f.exists()) { .. }

33. java.nio.file.Path •  Absolute or relaKve path, refers to ﬁles in ﬁle system. •  Suppor&ng API to java.io.File •  File to Path: –  File f = new File(”/foo/bar/file.txt”); –  Path p = f.toPath(); •  Path to File –  File f2 = p.toFile(); •  Path is an interface! InstanKaKng using either File or or Paths class –  Path p = Paths.get(“file.txt”);

34. Demo: Path -‐ class

35. java.nio.file.Files •  Features –  Copy –  Create directories –  Create ﬁles –  Create links –  Use of the “temp” – folder –  Delete –  Adributes – Modiﬁed/Owner/Permission –  Read / Write

36. java.nio.file.Files •  StaKc methods for reading, wriKng and manipulaKng ﬁles and directories •  Files uses Path objects! •  Methods like –  createFile(Path p, ..); –  delete(Path p); –  move(…) –  write(Path p, byte [] b, ..) –  readAllLines(Path p, Charset cs)

37. Example

38. Example

39. SERIALIZATION

40. Object Streams •  To read and write objects! •  How? –  Object class must implement serializable marker interface –  Read and write using ObjectInputStream and ObjectOutputStream •  SerializaKon is used in Java RMI

41. Example: Car class Car implements Serializable { private String brand; public Car(String brand) { setBrand(brand); } public String getBrand() { return brand; } public void setBrand(String brand) { this.brand = brand; } }

42. Example: Saving and Reading // Save the object fos = new FileOutputStream("car.dat"); oos = new ObjectOutputStream(fos); oos.writeObject(datsun); // Read the object fis = new FileInputStream("car.dat"); ois = new ObjectInputStream(fis); Car datsun2 = (Car) ois.readObject();

43. Transient •  Every adribute of the object is saved into disk.. except adribute is marked with transient keyword •  Mark adributes to transient when the informaKon is secret or uneccessary. •  When object is deserializaled, transient adributes values are null

44. JAVA NIO

45. NIO: High performance IO •  java.io is suitable for basic needs. When there is a need for higher performance, use Java NIO (New I/O) (java.nio) •  Less GC, less threads, more eﬃcient use of operaKng system •  Provides scalable I/O operaKons on both binary and character ﬁles. Also a simple parsing facility based on regular expressions •  A lidle bit harder to use than java.io

46. Streams vs Blocks •  java.io » Stream: movement of single bytes one at a Kme. •  java.nio » Block: movement of many bytes (blocks) at a Kme •  Processing data by block can be much faster than one byte at a Kme

47. Channels and Buffers •  Channels are what streams were in java.io •  All data transferred in java.nio must go through a Channel •  Buffer is a container object, before sending data into a channel, the data must be wrapped inside a Buffer •  Buffer is an object, which holds an array of bytes

48. Buffer Types •  There are many classes for buffers. These classes inherit java.nio.Buffer: •  ByteBuffer -‐ byte array •  CharBuffer •  ShortBuffer •  IntBuffer •  LongBuffer •  FloatBuffer •  DoubleBuffer

49. About Channels •  You never write a byte directly into a channel. Bytes must be wrapped inside a buﬀer •  Channels are bi-‐direcIonal •  Channels can be opened for reading, wriKng, or both

50. Example: Reading FileInputStream fin = new FileInputStream( "data.txt" ); // Get a channel via the FileInputStream FileChannel fc = fin.getChannel(); // Create a buffer ByteBuffer buffer = ByteBuffer.allocate( 1024 ); // Read from channel into a buffer fc.read( buffer );

51. Example: WriKng FileOutputStream fout = new FileOutputStream( "data.txt" ); // Get a channel via the FileOutputStream FileChannel fc = fout.getChannel(); // Create a buffer ByteBuffer buffer = ByteBuffer.allocate( 1024 ); // Data to be saved byte [] message = "this will be saved".toByteArray(); // Write into buffer for ( int i=0; i<message.length; i++ ) { buffer.put( message[i] ); } // Flip the buffer, this will be explained later buffer.flip(); // Writes SOME bytes from the buffer! fc.write( buffer );

52. Buffer Internals •  Every buffer has posiKon, limit and capacity •  These three variables track the state of the buffer •  posiIon: is the index of the next element to be read or wriden. A buffer's posiKon is never negaKve and is never greater than its limit. •  limit: is the index of the first element that should not be read or wriden. A buffer's limit is never negaKve and is never greater than its capacity •  capacity: is the number of elements buffer contains. The capacity of a buffer is never negaKve and never changes.

53. Buﬀer Example 1

60. FileInputStream fin = new FileInputStream( “infile.exe” ); FileOutputStream fout = new FileOutputStream( “outfile.exe” ); FileChannel fcin = fin.getChannel(); FileChannel fcout = fout.getChannel(); ByteBuffer buffer = ByteBuffer.allocate( 1024 ); while (true) { // Reset the buffer buffer.clear(); int numberOfReadBytes = fcin.read( buffer ); if ( numberOfReadBytes == -1 ) { break; } // prepare the buffer to be written to a buffer buffer.flip(); int numberOfWrittenBytes = 0; do { numberOfWrittenBytes += fcout.write( buffer ); } while(numberOfWrittenBytes < numberOfReadBytes); }

Java I/O

Java I/O

Recommandé

Contenu connexe

Tendances

Tendances(20)

Similaire à Java I/O

Similaire à Java I/O(20)

Plus de Jussi Pohjolainen

Plus de Jussi Pohjolainen(20)

Dernier

Dernier(20)

Java I/O