• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Java I/O
 

Java I/O

on

  • 1,390 views

 

Statistics

Views

Total Views
1,390
Views on SlideShare
1,390
Embed Views
0

Actions

Likes
0
Downloads
40
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Java I/O Java I/O Presentation Transcript

    • Java  I/O   Jussi  Pohjolainen   Tampere  University  of  Applied  Sciences  
    • Intro   •  Input  /  Output   –  Input  from  file  or  keyboard   –  Output  to  screen  or  a  file   •  To  deliver  data,  stream  is  used  
    • READ  AND  WRITE  CONSOLE  
    • Read  and  Write  to  Console   •  Output  stream:   –  System.out   •  Input  Stream:   –  System.in  
    • PrintStream  (System.out)  
    • InputStream  (System.in)   Read  a  byte  from  user  input?  
    • 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  specified   charset   •  InputStreamReader  has  methods  for  reading  one   char  at  a  Kme   •  We  don’t  want  to  read  one  char  at  a  .me  from   user!  
    • 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.  
    • Scanner   •  Or  just  use  Scanner  from  Java  1.5!   Scanner s = new Scanner(System.in); String mj = s.nextLine();
    • READ  AND  WRITE  FILES  
    • Binary  vs  text   •  All  data  are  in  the  end  binary:   –  01010101001011100110   •  Binary  files:  bits  represent  encoded   informaKons,  executable  instrucKons  or   numeric  data.   •  Text  files:  the  binarys  represent  characters.  
    • Text  files   •  In  text  files  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
    • Example  Encoding:  ASCII  
    • 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' } }
    • Character  Streams   •  To  read  characters   –  FileReader •  To  write  characters   –  FileWriter
    • 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(); } }
    • 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(); } }
    • 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(); } }
    • 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  
    • BufferedReader   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(); } }
    • PrintWriter,  BufferedWriter   •  Convenient  way  of  wriKng  files  using   PrintWriter:   PrintWriter pw = new PrintWriter( new BufferedWriter( new FileWriter("output.txt"))); pw.println("hello!"); pw.close();
    • READING  AND  WRITING  BYTES  
    • Read  and  Write   •  To  Read   –  FileInputStream   •  To  Write   –  FileOutputStream  
    • 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();
    • CLOSING  STREAMS  
    • 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(); } } } }
    • JAVA  7  NEW  FEATURES  
    • Java  7  to  the  rescue!  
    • How?   •  Virtual  Machine  will  call  automaIcally  the   close  method  upon  exiKng  the  try  block  (like   finally)   •  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  
    • Java  7  API  
    • 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  
    • 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()) { .. }
    • java.nio.file.Path •  Absolute  or  relaKve  path,  refers  to  files  in  file  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”);
    • Demo:  Path  -­‐  class  
    • java.nio.file.Files •  Features   –  Copy   –  Create  directories   –  Create  files   –  Create  links   –  Use  of  the  “temp”  –  folder   –  Delete   –  Adributes  –  Modified/Owner/Permission   –  Read  /  Write  
    • java.nio.file.Files •  StaKc  methods  for  reading,  wriKng  and   manipulaKng  files  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)
    • Example  
    • Example  
    • SERIALIZATION  
    • 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  
    • 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; } }
    • 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();
    • 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  
    • JAVA  NIO  
    • 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  efficient  use  of   operaKng  system   •  Provides  scalable  I/O  operaKons  on  both   binary  and  character  files.  Also  a  simple   parsing  facility  based  on  regular  expressions   •  A  lidle  bit  harder  to  use  than  java.io  
    • 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  
    • 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  
    • Buffer  Types   •  There  are  many  classes  for  buffers.  These  classes   inherit  java.nio.Buffer:   •  ByteBuffer  -­‐  byte  array   •  CharBuffer   •  ShortBuffer   •  IntBuffer   •  LongBuffer   •  FloatBuffer   •  DoubleBuffer  
    • About  Channels   •  You  never  write  a  byte  directly  into  a  channel.   Bytes  must  be  wrapped  inside  a  buffer   •  Channels  are  bi-­‐direcIonal   •  Channels  can  be  opened  for  reading,  wriKng,   or  both  
    • 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  );    
    • 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 );
    • 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.  
    • Buffer  Example  1  
    • Buffer  Example  2  
    • Buffer  Example  3  
    • Buffer  Example  4  
    • Buffer  Example  5  
    • Buffer  Example  6  
    • Buffer  Example  7  
    • 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); }