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

2. Intro
• Input
/
Output
– Input
from
file
or
keyboard
– Output
to
screen
or
a
file
• 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
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!

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
files:
bits
represent
encoded
informaKons,
executable
instrucKons
or
numeric
data.
• Text
files:
the
binarys
represent
characters.

12. 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

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. 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();
}
}

21. PrintWriter,
BufferedWriter
• Convenient
way
of
wriKng
files
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
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

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
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”);

34. Demo:
Path
-­‐
class

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

36. 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)

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
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

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
buffer
• 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. Buffer
Example
1

54. Buffer
Example
2

55. Buffer
Example
3

56. Buffer
Example
4

57. Buffer
Example
5

58. Buffer
Example
6

59. Buffer
Example
7

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);
}