Assoc. Prof.
Marenglen Biba
(C) 2010 Pearson Education, Inc. All rights reserved.
Data stored in variables and arrays is temporary
It’s lost when a local variable goes out of scope or when the
program terminates
For long-term retention of data, computers use files.
Computers store files on secondary storage devices
hard disks, optical disks, flash drives and magnetic tapes.
Data maintained in files is persistent data because it
exists beyond the duration of program execution.
Programmers prefer to work with decimal digits (0–9),
letters (A–Z and a–z), and special symbols (e.g., $, @,
%, &, *, (, ), –, +, ", :, ? and / ).
Known as characters.
Character set — the set of all the characters used to
write programs and represent data items.
Java uses Unicode characters that are composed of two
bytes, each composed of eight bits
Java type byte can be used to represent byte data.
Unicode contains characters for many of the world’s
languages.
Fields are composed of characters or bytes.
A field is a group of characters or bytes that conveys
meaning.
Data items processed by computers form a data
hierarchy that becomes larger and more complex in
structure as we progress from bits to characters to
fields, and so on.
Typically, several fields compose a record
(implemented as a class in Java).
A record is a group of related fields.
A file is a group of related records.
Java views each file as a sequential stream of bytes
(Fig. 17.2).
Every operating system provides a mechanism to
determine the end of a file, such as an end-of-file
marker or a count of the total bytes in the file that is
recorded in a system-maintained administrative data
structure.
A Java program simply receives an indication from the
operating system when it reaches the end of the stream
File streams can be used to input and output data as bytes
or characters.
Streams that input and output bytes are known as byte-
based streams, representing data in its binary format.
Streams that input and output characters are known as
character-based streams, representing data as a sequence
of characters.
Files that are created using byte-based streams are referred
to as binary files.
Files created using character-based streams are referred to
as text files. Text files can be read by text editors.
Binary files are read by programs that understand the
specific content of the file and the ordering of that content.
A Java program opens a file by creating an object and associating a
stream of bytes or characters with it.
Java creates three stream objects when a program begins executing
System.in (the standard input stream object) normally inputs
bytes from the keyboard
System.out (the standard output stream object) normally
outputs character data to the screen
System.err (the standard error stream object) normally
outputs character-based error messages to the screen.
Class System provides methods setIn, setOut and setErr to
redirect the standard input, output and error streams, respectively.
Java programs perform file processing by using classes
from package java.io.
Includes definitions for stream classes
FileInputStream (for byte-based input from a file)
FileOutputStream (for byte-based output to a file)
FileReader (for character-based input from a file)
FileWriter (for character-based output to a file)
You open a file by creating an object of one these
stream classes. The object’s constructor opens the file.
Java can perform input and output of objects or variables of
primitive data types without having to worry about the details of
converting such values to byte format.
To perform such input and output, objects of classes
ObjectInputStream and ObjectOutputStream can be
used together with the byte-based file stream classes
FileInputStream and FileOutputStream.
The complete hierarchy of classes in package java.io can be
viewed in the online documentation at
◦ http://docs.oracle.com/javase/8/docs/api/java/i
o/package-tree.html
Class File provides information about files and
directories.
Character-based input and output can be performed
with classes Scanner and Formatter.
Class Scanner is used extensively to input data from the
keyboard. This class can also read data from a file.
Class Formatter enables formatted data to be output to any
text-based stream in a manner similar to method
System.out.printf.
Class File provides four constructors.
The one with a String argument specifies the name of a file or
directory to associate with the File object.
The name can contain path information as well as a file or
directory name.
A file or directory’s path specifies its location on disk.
An absolute path contains all the directories, starting with
the root directory, that lead to a specific file or directory.
A relative path normally starts from the directory in which
the application began executing and is therefore ―relative‖ to
the current directory.
The constructor with two String arguments specifies an absolute
or relative path and the file or directory to associate with the File
object.
The constructor with File and String arguments uses an
existing File object that specifies the parent directory of the file or
directory specified by the String argument.
The fourth constructor uses a URI object to locate the file.
A Uniform Resource Identifier (URI) is a more general form of
the Uniform Resource Locators (URLs) that are used to locate
websites.
Figure 17.3 lists some common File methods.
http://docs.oracle.com/javase/8/docs/api/java/io/File
.html
(C) 2010 Pearson Education, Inc. All
rights reserved.
A separator character is used to separate directories
and files in the path.
On Windows, the separator character is a backslash (\).
On Linux/UNIX, it’s a forward slash (/).
Java processes both characters identically in a path
name.
When building Strings that represent path
information, use File.separator to obtain the
local computer’s proper separator.
This constant returns a String consisting of one character —
the proper separator for the system.
Sequential-access files store records in order by the
record-key field.
Text files are human-readable files.
Java imposes no structure on a file
Notions such as records do not exist as part of the Java
language.
Formatter outputs formatted Strings to the
specified stream.
The constructor with one String argument receives
the name of the file, including its path.
If a path is not specified, the JVM assumes that the file is in
the directory from which the program was executed.
If the file does not exist, it will be created.
If an existing file is opened, its contents are truncated.
A SecurityException occurs if the user does not
have permission to write data to the file.
A FileNotFoundException occurs if the file
does not exist and a new file cannot be created.
static method System.exit terminates an
application.
An argument of 0 indicates successful program termination.
A nonzero value, normally indicates that an error has occurred.
The argument is useful if the program is executed from a batch
file on Windows or a shell script on UNIX/Linux/Mac OS X.
Scanner method hasNext determines whether the end-
of-file key combination has been entered.
A NoSuchElementException occurs if the data being
read by a Scanner method is in the wrong format or if
there is no more data to input.
Formatter method format works like
System.out.printf
A FormatterClosedException occurs if the
Formatter is closed when you attempt to output.
Formatter method close closes the file.
If method close is not called explicitly, the operating system
normally will close the file when program execution terminates.
Different platforms use different line-separator characters.
On UNIX/Linux-/Mac OS X, the line-separator is a newline
(\n).
On Windows, it is a combination of a carriage return and a line
feed — represented as \r\n.
You can use the %n format specifier in a format control string
to output a platform-specific line separator.
Method System.out.println outputs a platform-
specific line separator after its argument.
Regardless of the line separator used in a text file, a Java
program can still recognize the lines of text and read them.
The application in Figs. 17.10 and 17.11 reads records
from the file "clients.txt" created by the
application of Section 17.5.1 and displays the record
contents.
(C) 2010 Pearson Education, Inc. All
rights reserved.
(C) 2010 Pearson Education, Inc. All
rights reserved.
If a Scanner is closed before data is input, an
IllegalStateException occurs.
To retrieve data sequentially from a file, programs start
from the beginning of the file and read all the data
consecutively until the desired information is found.
It might be necessary to process the file sequentially
several times (from the beginning of the file) during
the execution of a program.
Class Scanner does not allow repositioning to the
beginning of the file.
The program must close the file and reopen it.
The data in many sequential files cannot be modified
without the risk of destroying other data in the file.
If the name ―White‖ needed to be changed to
―Worthington,‖ the old name cannot simply be
overwritten, because the new name requires more space.
Fields in a text file—and hence records—can vary in size.
Records in a sequential-access file are not usually updated
in place. Instead, the entire file is usually rewritten.
Rewriting the entire file is uneconomical to update just one
record, but reasonable if a substantial number of records
need to be updated.
To read an entire object from or write an entire object
to a file, Java provides object serialization.
A serialized object is represented as a sequence of
bytes that includes the object’s data and its type
information.
After a serialized object has been written into a file, it
can be read from the file and deserialized to recreate
the object in memory.
Classes ObjectInputStream and
ObjectOutputStream, which respectively
implement the ObjectInput and ObjectOutput
interfaces, enable entire objects to be read from or
written to a stream.
To use serialization with files, initialize
ObjectInputStream and
ObjectOutputStream objects with
FileInputStream and FileOutputStream
objects.
ObjectOutput interface method writeObject takes
an Object as an argument and writes its information to an
OutputStream.
A class that implements ObjectOutput (such as
ObjectOutputStream) declares this method and
ensures that the object being output implements
Serializable.
ObjectInput interface method readObject reads and
returns a reference to an Object from an InputStream.
After an object has been read, its reference can be cast to the
object’s actual type.
Objects of classes that implement interface Serializable
can be serialized and deserialized with
ObjectOutputStreams and ObjectInputStreams.
Interface Serializable is a tagging interface.
It does not contain methods.
A class that implements Serializable is tagged as being a
Serializable object.
An ObjectOutputStream will not output an object unless
it is a Serializable object.
In a class that implements Serializable, every
variable must be Serializable.
Any one that is not must be declared transient so it
will be ignored during the serialization process.
All primitive-type variables are serializable.
For reference-type variables, check the class’s
documentation (and possibly its superclasses) to ensure
that the type is Serializable.
The program in Figs. 17.19–17.20 reads records from a
file created by the program in Section 17.6.1 and
displays the contents.
ObjectInputStream method readObject reads
an Object from a file.
Method readObject throws an EOFException if
an attempt is made to read beyond the end of the file.
Method readObject throws a
ClassNotFoundException if the class for the
object being read cannot be located.
Class JFileChooser displays a dialog that enables
the user to easily select files or directories.
JFile-Chooser method setFileSelectionMode specifies
what the user can select from the fileChooser.
JFileChooser static constant
FILES_AND_DIRECTORIES indicates that files and directories
can be selected.
Other static constants include FILES_ONLY (the default) and
DIRECTORIES_ONLY.
Method showOpenDialog displays a JFileChooser dialog
titled Open.
A JFileChooser dialog is a modal dialog.
Method showOpenDialog returns an integer specifying which
button (Open or Cancel) the user clicked to close the dialog.
JFileChooser method getSelectedFile returns the
selected file as a File object.
Reading
◦ Chapter 17
