Java Input/Output

6 May 2019 OSU CSE 1

 Overview
• The Java I/O (Input/Output) package
java.io contains a group of interfaces
and classes similar to the OSU CSE
components’ SimpleReader and
SimpleWriter component families
– Except that java.io is far more general,
configurable, and powerful (and messy)
– Hence, the names SimpleReader and
SimpleWriter

6 May 2019 OSU CSE 2

 I/O Streams
• An input/output stream is a (conceptually
not necessarily finite) series of data items
– An input stream is a “flow” of data items from
a source to a program
• The program reads from the source (or from the
stream)
– An output stream is a “flow” of data items
from a program to a destination
• The program writes to the destination (or to the
stream)
6 May 2019 OSU CSE 3
 Input Streams
input stream program

source

single data item

6 May 2019 OSU CSE 4

 Input Streams
input stream program

source

single data item

Source may be the keyboard, a file

on disk, a physical device, another
program, even an array or String
in the same program.

6 May 2019 OSU CSE 5

 Output Streams
program output stream
desti-
nation

single data item

6 May 2019 OSU CSE 6

 Output Streams
program output stream
desti-
nation

single data item

Destination may be the console

window, a file on disk, a physical
device, another program, even an array
or String in the same program.

6 May 2019 OSU CSE 7

 Part I: Beginner’s Guide
• This part is essentially a “how-to” guide for
using java.io that assumes knowledge
of the OSU CSE components’
SimpleReader and SimpleWriter
component families

6 May 2019 OSU CSE 8

Keyboard Input (SimpleReader)
• Here’s some code in main to read input
from the keyboard, using SimpleReader:
public static void main(String[] args) {
SimpleReader input = new SimpleReader1L();
String s = input.nextLine();
...
input.close();
}

6 May 2019 OSU CSE 9

Keyboard Input
Advice (except for the (SimpleReader)
simplest
programs): to guard against the user
entering “unexpected” input, read a line
• atHere’s some
a time into codeand
a String in then
main to read input
parse
itfrom
to seethe
whether it looks like
keyboard, expected.
using SimpleReader:
public static void main(String[] args) {
SimpleReader input = new SimpleReader1L();
String s = input.nextLine();
...
input.close();
}

6 May 2019 OSU CSE 10

 Overview of java.io Input
Readable Closeable

Reader

InputStream-
BufferedReader
Reader

FileReader There are more classes

and interfaces not
discussed here!

6 May 2019 OSU CSE 11

 Keyboard Input (java.io)
• Here’s some code in main to read input
from the keyboard, using java.io:
public static void main(String[] args)
throws IOException {
BufferedReader input =
new BufferedReader(
new InputStreamReader(System.in));
String s = input.readLine();
...
input.close();
}

6 May 2019 OSU CSE 12

 Keyboard Input (java.io)
Some methods in java.io throw
exceptions (discussed later) under
certain circumstances, and you either
• Here’s
need tosome
catch code
them orinletmain
them to read input
propagate
from the“up the call chain”,
keyboard, using like this.
java.io:
public static void main(String[] args)
throws IOException {
BufferedReader input =
new BufferedReader(
new InputStreamReader(System.in));
String s = input.readLine();
...
input.close();
}

6 May 2019 OSU CSE 13

 Keyboard Input (java.io)
The variable System.in is a Java
standard stream (discussed later), so
you may use it without declaring it; but it
• is
Here’s some (discussed
a byte stream code in main to read input
later), so
from theyou keyboard,
want to wrap using
it ... java.io:
public static void main(String[] args)
throws IOException {
BufferedReader input =
new BufferedReader(
new InputStreamReader(System.in));
String s = input.readLine();
...
input.close();
}

6 May 2019 OSU CSE 14

 Keyboard Input (java.io)
... in a character stream (discussed
later) like this ...
• Here’s some code in main to read input
from the keyboard, using java.io:
public static void main(String[] args)
throws IOException {
BufferedReader input =
new BufferedReader(
new InputStreamReader(System.in));
String s = input.readLine();
...
input.close();
}

6 May 2019 OSU CSE 15

 Keyboard Input (java.io)
... and then you want to wrap that
character stream in a buffered stream
• Here’s some
(discussed code
later), in main
like this, so ... to
read input
from the keyboard, using java.io:
public static void main(String[] args)
throws IOException {
BufferedReader input =
new BufferedReader(
new InputStreamReader(System.in));
String s = input.readLine();
...
input.close();
}

6 May 2019 OSU CSE 16

 Keyboard Input (java.io)
... you can read one line at a time into a
String, like this.
• Here’s some code in main to read input
from the keyboard, using java.io:
public static void main(String[] args)
throws IOException {
BufferedReader input =
new BufferedReader(
new InputStreamReader(System.in));
String s = input.readLine();
...
input.close();
}

6 May 2019 OSU CSE 17

 Keyboard Input (java.io)
The declared types of variables when
you use java.io are class types
• Here’s some code in main
rather to read
than interface input
types.
from the keyboard, using java.io:
public static void main(String[] args)
throws IOException {
BufferedReader input =
new BufferedReader(
new InputStreamReader(System.in));
String s = input.readLine();
...
input.close();
}

6 May 2019 OSU CSE 18

 KeyboardThis
Input (java.io)to
technique of slightly extending
features or capabilities of an object by
wrapping it inside another object is a
• Here’s somepopular
code object-oriented
in main to read designinput
pattern
from the keyboard, using
called java.io:
the decorator pattern.
public static void main(String[] args)
throws IOException {
BufferedReader input =
new BufferedReader(
new InputStreamReader(System.in));
String s = input.readLine();
...
input.close();
}

6 May 2019 OSU CSE 19

 An Alternative (java.util)
• An attractive alternative to using
java.io.BufferedReader is to use
java.util.Scanner
– Important difference: no IOExceptions can
be raised, so you don’t need to worry about
catching or throwing them
– Features for parsing input are powerful, e.g.,
the use of regular expressions to describe
delimiters between data items

6 May 2019 OSU CSE 20

 An Alternative (java.util)
• Here’s some code in main to read input
from the keyboard, using Scanner:
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String s = input.nextLine();
...
input.close();
}

6 May 2019 OSU CSE 21

 An Alternative
Now, main (java.util)
does not declare that it
throws IOException; in this sense it
is similar to using SimpleReader.
• Here’s some code in main to read input
from the keyboard, using Scanner:
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String s = input.nextLine();
...
input.close();
}

6 May 2019 OSU CSE 22

 An Alternative (java.util)
Notice that initialization does not involve
layers of wrapping of one object inside
another; Scanner also has different
• constructors
Here’s some code in
read input
main to
so it can be used with files.
from the keyboard, using Scanner:
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String s = input.nextLine();
...
input.close();
}

6 May 2019 OSU CSE 23

 An Alternative (java.util)
The method for reading a line into a
String has a different name than for
BufferedReader: it is nextLine (like
• Here’s some code in main to
SimpleReader).
read input
from the keyboard, using Scanner:
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String s = input.nextLine();
...
input.close();
}

6 May 2019 OSU CSE 24

End-of-Stream (SimpleReader)
public static void main(String[] args) {
SimpleReader input = new SimpleReader1L();
while (!input.atEOS()) {
s = input.nextLine();
...
}
...
input.close();
}

6 May 2019 OSU CSE 25

End-of-Stream (SimpleReader)
public static void main(String[] args) {
SimpleReader input = new SimpleReader1L();
while (!input.atEOS()) {
s = input.nextLine();
...
}
...
SimpleReader has a method to report “at
input.close();
} end-of-stream”, and it can tell you this before
you read “past the end of the input stream”;
similarly, Scanner has method hasNext.

6 May 2019 OSU CSE 26

 End-of-Stream (java.io)
public static void main(String[] args)
throws IOException {
BufferedReader input =
new BufferedReader(
new InputStreamReader(System.in));
String s = input.readLine();
while (s != null) {
...
s = input.readLine();
}
...
input.close();
}
6 May 2019 OSU CSE 27
 End-of-Stream (java.io)
BufferedReader has no method to
detect when you cannot read any more
public static void main(String[] args)
input, so you can check it only after you
throws IOException {
try to read “past the end of the stream”.
BufferedReader input =
new BufferedReader(
new InputStreamReader(System.in));
String s = input.readLine();
while (s != null) {
...
s = input.readLine();
}
...
input.close();
}
6 May 2019 OSU CSE 28
 End-of-Stream (java.io)
public static void main(String[] args)
throws IOException {
BufferedReader input =
new BufferedReader(
new InputStreamReader(System.in));
String s = input.readLine();
while (s != null) {
... Before checking again,
s = input.readLine(); you must try to read
} another line.
...
input.close();
}
6 May 2019 OSU CSE 29
 File Input (SimpleReader)
• Here’s some code in main to read input
from a file, using SimpleReader:
public static void main(String[] args) {
SimpleReader input =
new SimpleReader1L("data/test.txt");
String s = input.nextLine();
...
input.close();
}

6 May 2019 OSU CSE 30

 File Input (SimpleReader)
SimpleReader has a constructor from
a String, which is the name of the file
• Here’syou
some code
want to in main to
read input
read from.
from a file, using SimpleReader:
public static void main(String[] args) {
SimpleReader input =
new SimpleReader1L("data/test.txt");
String s = input.nextLine();
...
input.close();
}

6 May 2019 OSU CSE 31

 File Input (java.io)
• Here’s some code in main to read input
from a file, using java.io:
public static void main(String[] args)
throws IOException {
BufferedReader input =
new BufferedReader(
new FileReader("data/test.txt"));
String s = input.readLine();
...
input.close();
}

6 May 2019 OSU CSE 32

 File Input (java.io)
Now, you wrap a BufferedReader
around a FileReader (which has a
constructor from a String, which is the
• name
Here’s some
of the code
file you inread
want to main to
from). read input
from a file, using java.io:
public static void main(String[] args)
throws IOException {
BufferedReader input =
new BufferedReader(
new FileReader("data/test.txt"));
String s = input.readLine();
...
input.close();
}

6 May 2019 OSU CSE 33

 Independence From Source
• With SimpleReader, BufferedReader,
and Scanner used as shown, the source
is identified in a constructor call, and
subsequent code to read data is
independent of the source
– This is a really handy feature in many
software maintenance situations
– But notice: methods differ between
BufferedReader and the other two!

6 May 2019 OSU CSE 34

Console Output (SimpleWriter)
• Here’s some code in main to write output
to the console, using SimpleWriter:
public static void main(String[] args) {
SimpleWriter output = new SimpleWriter1L();
output.print("foo");
output.println(" and bar");
...
output.close();
}

6 May 2019 OSU CSE 35

Console
Both print and Output (SimpleWriter)
println are available,
and the latter should be used to output
the line separator string for the current
• Here’s some
“platform” code
(i.e., the in the
system mainJavato write output
to theprogram
console, is running
usingon).SimpleWriter:
public static void main(String[] args) {
SimpleWriter output = new SimpleWriter1L();
output.print("foo");
output.println(" and bar");
...
output.close();
}

6 May 2019 OSU CSE 36

 Overview of java.io Output
Appendabl
Closeable Flushable
e

Writer

OutputStream-
BufferedWriter PrintWriter
Writer

FileWriter There are more classes

and interfaces not
discussed here!

6 May 2019 OSU CSE 37

 Console Output (java.io)
• Here’s some code in main to write output
to the console, using java.io:
public static void main(String[] args) {
...
System.out.print("foo");
System.out.println(" and bar");
...
}

6 May 2019 OSU CSE 38

 Console Output (java.io)
System.out is another Java standard
stream (discussed later), which you
neither declare nor close; both print
• Here’s some code in main towrite output
and println are available.
to the console, using java.io:
public static void main(String[] args) {
...
System.out.print("foo");
System.out.println(" and bar");
...
}

6 May 2019 OSU CSE 39

 Console Output (java.io)
It is fine to use System.out for console
output, but there are potential problems
using (unwrapped) System.in for
• Here’s some code in main to write
keyboard input.
output
to the console, using java.io:
public static void main(String[] args) {
...
System.out.print("foo");
System.out.println(" and bar");
...
}

6 May 2019 OSU CSE 40

 File Output (SimpleWriter)
• Here’s some code in main to write output
to a file, using SimpleWriter:
public static void main(String[] args) {
SimpleWriter output =
new SimpleWriter1L("data/test.txt");
output.print("foo");
output.println(" and bar");
...
output.close();
}

6 May 2019 OSU CSE 41

 File Output (SimpleWriter)
SimpleWriter has a constructor from
a String, which is the name of the file
• Here’s you
some
wantcode
to writeinto.main to
write output
to a file, using SimpleWriter:
public static void main(String[] args) {
SimpleWriter output =
new SimpleWriter1L("data/test.txt");
output.print("foo");
output.println(" and bar");
...
output.close();
}

6 May 2019 OSU CSE 42

 File Output (java.io)
• Here’s some code in main to write output
to a file, using java.io:
public static void main(String[] args)
throws IOException {
PrintWriter output =
new PrintWriter(
new BufferedWriter (
new FileWriter("data/test.txt")));
output.print("foo");
output.println(" and bar");
...
output.close();
}

6 May 2019 OSU CSE 43

 File Output (java.io)
PrintWriter is needed for convenient
output, and is added as yet another
• Here’s some
wrapper—to codeand
get print in println.
main to write output
to a file, using java.io:
public static void main(String[] args)
throws IOException {
PrintWriter output =
new PrintWriter(
new BufferedWriter (
new FileWriter("data/test.txt")));
output.print("foo");
output.println(" and bar");
...
output.close();
}

6 May 2019 OSU CSE 44

Independence From Destination
• With SimpleWriter, System.out, and
PrintWriter used as shown, the
destination is identified in a constructor
call, and subsequent code to write data is
independent of the destination
– This is a really handy feature in many
software maintenance situations
– Unlike input, methods (print and println)
for all three have same names and behaviors

6 May 2019 OSU CSE 45

 Part II: Some Details
• There are way too many details about
java.io to cover here; see the Javadoc
and the Java Tutorials trail on “Basic I/O”
• A few details previously promised ...

6 May 2019 OSU CSE 46

 IOException
• A general discussion of exceptions in
Java is to come later still, but for now…
• A number of java.io constructors and
methods might throw (raise) an
IOException
– Examples: files to be used as
sources/destinations may not exist, may not
be readable and/or writeable by the user of
the program, etc.
6 May 2019 OSU CSE 47
 Try-Catch
• As an alternative to letting an exception
propagate “up the call chain” to the client
(as in the earlier examples), you may deal
with an IOException by catching
(handling) it, e.g.:
– Report that there has been an I/O error and
exit “gracefully”
– Try to recover from it (which is usually much
harder)

6 May 2019 OSU CSE 48

 Example
• Here’s the overall structure of an example
main in a simple application that reads
input from a file, using java.io:
public static void main(String[] args) {
// Code to open file
// Code to read from file
// Code to close file
}

6 May 2019 OSU CSE 49

 Example: Opening a File
public static void main(String[] args) {
BufferedReader input;
try {
input = new BufferedReader(
new FileReader("data/test.txt"));
} catch (IOException e) {
System.err.println("Error opening file");
return;
}
// Code to read from file
// Code to close file
}

6 May 2019 OSU CSE 50

 Example: Opening a File
public static void main(String[] args) {
BufferedReader input;
try {
input = new BufferedReader(
new FileReader("data/test.txt"));
} catch (IOException e) {
System.err.println("Error opening file");
return;
}
Now,
// Code to read filedoes not declare that it
main
from
throws
// Code to close file IOException if it (always)
} catches the exception.

6 May 2019 OSU CSE 51

 Example: Opening a File
public static void main(String[] args) {
BufferedReader input;
try {
input = new BufferedReader(
new FileReader("data/test.txt"));
} catch (IOException e) {
System.err.println("Error opening file");
return;
}
This variable must be declared (but not
// Code to read from file
initialized) here, so it is in scope later
// Code to close file
}
where the code reads from the file—if the
file is opened successfully.

6 May 2019 OSU CSE 52

 Example: Opening a File
public static void main(String[] args) {
BufferedReader input;
try {
input = new BufferedReader(
new FileReader("data/test.txt"));
} catch (IOException e) {
System.err.println("Error opening file");
return;
}
// Code to read from file
The try block contains the code that
// Code to close file
might throw an IOException ...
}

6 May 2019 OSU CSE 53

 Example: Opening a File
public static void main(String[] args) {
BufferedReader input;
try {
input = new BufferedReader(
new FileReader("data/test.txt"));
} catch (IOException e) {
System.err.println("Error opening file");
return;
}
// Code to read from file
... which this constructor might throw,
// Code to close file
}
e.g., if the file does not exist.

6 May 2019 OSU CSE 54

 Example: Opening a File
public static void main(String[] args) {
BufferedReader input;
try {
input = new BufferedReader(
new FileReader("data/test.txt"));
} catch (IOException e) {
System.err.println("Error opening file");
return;
}
The catch block states the exception it
// Code to read from file
handles, and is executed iff code in the
// Code to close file
}
try block throws that exception (which is
called e in the catch block).

6 May 2019 OSU CSE 55

 Example: Opening a File
public static void main(String[] args) {
BufferedReader input;
try {
input = new BufferedReader(
new FileReader("data/test.txt"));
} catch (IOException e) {
System.err.println("Error opening file");
return;
}
Here, the code prints an error message
// Code to read from file
to System.err, another Java standard
// Code to close file
}
stream (discussed later), and “aborts”
main by returning from it.

6 May 2019 OSU CSE 56

 Example:
In eitherOpening
case (even aftera
theFile
catch block,
if it did not return as it does here),
execution
public static void proceeds
main(String[] with the
args) { next
BufferedReader input; statement.
try {
input = new BufferedReader(
new FileReader("data/test.txt"));
} catch (IOException e) {
System.err.println("Error opening file");
return;
}
// Code to read from file
// Code to close file
}

6 May 2019 OSU CSE 57

 Example: Reading From a File
public static void main(String[] args) {
// Code to open file
try {
String s = input.readLine();
while (s != null) {
...
s = input.readLine();
}
} catch (IOException e) {
System.err.println("Error reading from file");
}
// Code to close file
}

6 May 2019 OSU CSE 58

 Example: Reading From
We need this try-catch a File
because
method readLine might throw an
the

IOException.
public static void main(String[] args) {
// Code to open file
try {
String s = input.readLine();
while (s != null) {
...
s = input.readLine();
}
} catch (IOException e) {
System.err.println("Error reading from file");
}
// Code to close file
}

6 May 2019 OSU CSE 59

 Example:(which
Reading
As From
before, even after a
the catch File
block
in this case does not end with a
return),
public static void execution proceeds
main(String[] args) { with the
// Code to open file next statement.
try {
String s = input.readLine();
while (s != null) {
...
s = input.readLine();
}
} catch (IOException e) {
System.err.println("Error reading from file");
}
// Code to close file
}

6 May 2019 OSU CSE 60

 Example: Closing a File
public static void main(String[] args) {
// Code to open file
// Code to read from file
try {
input.close();
} catch (IOException e) {
System.err.println("Error closing file");
}
}

6 May 2019 OSU CSE 61

 Example:
We needClosing a File
this try-catch because even the
method close might throw an
IOException.
public static void main(String[] args) {
// Code to open file
// Code to read from file
try {
input.close();
} catch (IOException e) {
System.err.println("Error closing file");
}
}

6 May 2019 OSU CSE 62

 The Standard Streams
• The utility class System in java.lang
declares three standard streams:
– System.in
– System.out
– System.err
• You do not declare, open, or close these
streams; but you can always use them
without worrying about exceptions

6 May 2019 OSU CSE 63

 The Standard Streams
• The utility class System in java.lang
declares three standard streams:
– System.in
– System.out
A utility class is a class that cannot be
– System.err
instantiated, i.e., there is no public
• You do not declare, open,
constructor; or close
it is not a type, these
so you
cannot create “an object of that type”.
streams; but you can always use them
without worrying about exceptions

6 May 2019 OSU CSE 64

 The Standard Streams
• The utility class System in java.lang
System.err is intended for
error messages; System.out is
declares three standard
intended streams:
for normal output.
– System.in
– System.out
– System.err
• You do not declare, open, or close these
streams; but you can always use them
without worrying about exceptions

6 May 2019 OSU CSE 65

 Byte and Character Streams
• Java has two categories of streams:
– Byte streams are streams of 8-bit bytes
• This is a kind of low-level I/O that you rarely need
– Character streams are streams of Unicode
characters
• This is preferred for text I/O because it accounts
for the “local” character set and supports
internationalization with little additional effort
• Best practice is to use character streams
with textual I/O
6 May 2019 OSU CSE 66
 Buffered Streams
• Buffered streams minimize disk access
for reading/writing files, and generally
have performance advantages over
unbuffered streams
• Best practice is to “wrap” input and output
character streams to create buffered
versions
– This is done with BufferedReader and
BufferedWriter, as seen earlier
6 May 2019 OSU CSE 67
 Files and Paths
• The File class (an original part of Java)
and the Path interface (new in Java 1.7)
allow you to manipulate directories and
files and the “paths” to them in the file
system, e.g.:
– Check file existence and permissions, create
files and set permissions, delete files, etc.
• See the Java Tutorials: Basic I/O and the
Java libraries’ Javadoc for details
6 May 2019 OSU CSE 68
 Resources
• The Java Tutorials: Basic I/O
– http://docs.oracle.com/javase/tutorial/essential/io/index.html

6 May 2019 OSU CSE 69