Chapter 6

CHAPTER 6 FILES AND STREAMS
By
Sirage Zeynu (M.Tech)
School of Computing

13-04-2021 Files and Streams 2
Streams
 A stream is a sequence of data. A program uses an input stream to
read data from a source, one item at a time:
 A stream is an abstraction that either produces or consumes.
 Streams support many different kinds of data
simple bytes, primitive data types, localized characters, and
objects
 Thus, the same I/O classes and methods can be applied to any type
of device. This means that an input stream can abstract many
different kinds of input: from a disk file, a keyboard, or a network
socket.
I/O Basics

 An I/O Stream represents an input source or an output destination.
 A stream can represent many different kinds of sources and destinations,
including disk files, devices, other programs, and memory arrays.
 Streams support many different kinds of data, including simple bytes,
primitive data types, localized characters, and objects. Some streams
simply pass on data; others manipulate and transform the data in useful
ways.
 No matter how they work internally, all streams present the same simple
model to programs that use them
 Streams are a clean way to deal with input/output without having every
part of your code understands the difference between a keyboard and a
network, for example. Java implements streams within class hierarchies
defined in the java.io package.
Input and Output Streams(1)

A program uses an input stream to read data
from a source, one item at a time

 A program uses an output stream to write data to a destination,
one item at time

input (sources) streams
Can read from these streams Root classes of all input streams:
• The InputStream Class
• The Reader Class
Output or sink (destination) streams
Can write to these streams Root classes of all output streams:
• The OutputStream Class
• The Writer Class

Byte streams are defined by using two class hierarchies.
 At the top are two abstract classes: InputStream and OutputStream.
Each of these abstract classes has several concrete subclasses that
handle the differences between various devices, such as disk files,
network connections, and even memory buffers.
 The abstract classes InputStream and OutputStream define several
key methods that the other stream classes implement. Two of the
most important are read() and write(), which, respectively, read and
write bytes of data.
 Both methods are declared as abstract inside InputStream and
OutputStream. They are overridden by derived stream classes.
Byte Streams and Character Streams(1)

 Programs use byte streams to perform input and output of 8-
bit bytes.
 All byte stream classes are descended from InputStream and
OutputStream
 There are many byte stream classes.
 To demonstrate how byte streams work, we'll focus on
the file IO byte streams, FileInputStream and FileOutputStream
 Other kinds of byte streams are used in much the same way;
they differ mainly in the way they are constructed.

 The Java platform stores character values using Unicode conventions.
 Character stream I/O automatically translates this internal format to and
from the local character set.
 In Western locales, the local character set is usually an 8-bit superset of
ASCII.
 For most applications, I/O with character streams is no more complicated
than I/O with byte streams.
 Input and output done with stream classes automatically translates to and
from the local character set.
 A program that uses character streams in place of byte streams
automatically adapts to the local character set and is ready for
internationalization
Character Streams

 Byte streams
For binary data
Root classes for byte streams:
● The InputStream Class
● The OutputStream Class
● Both classes are abstract
Byte Streams and Character Streams(2)
Character streams
For Unicode characters
Root classes for character
streams:
● The Reader class
● The Writer class
● Both classes are abstract

Example of character streams

 System contains three predefined stream variables, in, out, and err.
 These fields are declared as public and static within System. This means
that they can be used by any other part of your program and without
reference to a specific System object.
 System.out refers to the standard output stream. By default, this is the
console.
 System.in refers to standard input, which is the keyboard by default.
System.err refers to the standard error stream, which also is the console by
default.
 However, these streams may be redirected to any compatible I/O device.
 System.in is an object of type InputStream; System.out and System.err are
objects of type PrintStream.
 These are byte streams, even though they typically are used to read and
write characters from and to the console.
The Predefined Streams

 In Java, console input is accomplished by reading from
System.in
 To obtain a character- based stream that is attached to the
console, you wrap System.in
 in a BufferedReader object, to create a character stream.
 BuffereredReader supports a buffered input stream. Its most
commonly used constructor is shown here:
BufferedReader(Reader inputReader)
Here, inputReader is the stream that is linked to the instance of
BufferedReader that is being created.
Reading Console Input

Reading Characters

 To read a string from the keyboard, use the version of
readLine() that is a member of the BufferedReader class.
Its general form is shown here:
 String readLine() throws IOException As you can see, it
returns a String object.
 The following program demonstrates BufferedReader and the
readLine() method; the program reads and displays lines of
text until you enter the word “stop”:
Reading Strings

Example Reading Strings

 Console output is most easily accomplished with print() and
println()
 These methods are defined by the class PrintStream (which is
the type of the object referenced by System.out).
 Even though System.out is a byte stream, using it for simple
program output is still acceptable.
 Because PrintStream is an output stream derived from
OutputStream, it also implements the low-level method write().
Thus, write() can be used to write to the console.
 The simplest form of write() defined by PrintStream is shown
here:
Writing Console Output

void write(int byteval)
This method writes to the stream the byte specified by byteval.
Although byteval is declared as an integer, only the low-order
eight bits are written. Here is a short example that uses write()
to output the character “A” followed by a newline to the screen:
You will not often use write() to perform console output (although doing so might be useful in some situations),
because print() and println() are substantially easier to use.

The streams used most often are the standard input (the
keyboard) and the standard output (the CRT display).
Alternatively, standard input can arrive from a disk file using
"input redirection", and standard output can be written to a disk
file using "output redirection".
A more flexible mechanism to read or write disk files is
available through Java's file streams.
File Streams(1)

The two file streams presented here are
The file reader stream
The file writer stream.
 As with the standard I/O streams, we access these through objects
of the associated class,
 namely the FileReader class and the FileWriter class. Unlike the
standard I/O streams, however, we must explicitly "open" a file
stream before using it.
 After using a file stream, it is good practice to "close" the stream,
although, strictly speaking, this is not necessary as all streams are
automatically closed when a program terminates.
File Streams(2)

 To open a file output stream to which text can be written, we
use the FileWriter class.
 As always, it is best to buffer the output. The following sets up
a buffered file writer stream named outFile to write text into a
file named save.txt:
Writing Files
PrintWriter outFile = new PrintWriter(new BufferedWriter(new FileWriter("save.txt"));
The object outFile, above, is of the PrintWriter class, just like System.out.
If a string, s, contains some text, it is written to the file as follows:
outFile.println(s);
When finished, the file is closed as expected:
outFile.close();

 FileWriter is useful to create a file writing characters into it.
 This class inherits from the OutputStream class.
 The constructors of this class assume that the default
character encoding and the default byte-buffer size are
acceptable.
 To specify these values yourself, construct an
OutputStreamWriter on a FileOutputStream.
 FileWriter is meant for writing streams of characters.
 For writing streams of raw bytes, consider using a
FileOutputStream.
 FileWriter creates the output file , if it is not present already.
FileWriter

 FileWriter(File file) – Constructs a FileWriter object given a File object.
 FileWriter (File file, boolean append) – constructs a FileWriter object
given a File object.
 FileWriter (FileDescriptor fd) – constructs a FileWriter object associated
with a file descriptor.
 FileWriter (String fileName) – constructs a FileWriter object given a file
name.
 FileWriter (String fileName, Boolean append) – Constructs a FileWriter
object given a file name with a Boolean indicating whether or not to
append the data written.

Constructors

public void write (char c) throws IOException – Writes a single
character.
 public void write (char [] str) throws IOException – Writes an array
of characters.
 public void write(String str)throws IOException – Writes a string.
 public void write(String str,int off,int len)throws IOException –
Writes a portion of a string. Here off is offset from which to start
writing characters and len is number of character to write.
 public void flush() throws IOException flushes the stream
 public void close() throws IOException flushes the stream first and
then closes the writer.
Methods

Following program depicts how to create a text file using FileWriter

 Let's begin with the FileReader class.
As with keyboard input, it is most efficient to work through the
BufferedReader
If we wish to read text from a file named foo.txt, it is opened as a
file input stream as follows:
The line above "opens" foo.txt as a FileReader object and passes it
to the constructor of the BufferedReader class.
The result is a BufferedReader object named inputFile.
Reading Files
BufferedReader inputFile = new BufferedReader(new FileReader(“foo.txt”))

 FileReader is useful to read data in the form of characters from
a ‘text’ file.
 This class inherit from the InputStreamReader Class.
 The constructors of this class assume that the default character
encoding and the default byte-buffer size are appropriate.
 To specify these values yourself, construct an
InputStreamReader on a FileInputStream.
 FileReader is meant for reading streams of characters.
 For reading streams of raw bytes, consider using a
FileInputStream.
FileReader

 FileReader(File file) – Creates a FileReader , given the File
to read from
 FileReader(FileDescripter fd) – Creates a new FileReader ,
given the FileDescripter to read from
 FileReader(String fileName) – Creates a new FileReader ,
given the name of the file to read from
Constructors

 public int read () throws IOException – Reads a single character. This
method will block until a character is available, an I/O error occurs, or the
end of the stream is reached.
 public int read(char[] cbuff) throws IOException – Reads characters
into an array. This method will block until some input is available, an I/O
error occurs, or the end of the stream is reached.
 public abstract int read(char[] buff, int off, int len) throws
IOException –Reads characters into a portion of an array. This method
will block until some input is available, an I/O error occurs, or the end of
the stream is reached.
public void close() throws IOException closes the reader.
 public long skip(long n) throws IOException –Skips characters. This
method will block until some characters are available, an I/O error occurs,
or the end of the stream is reached.
Methods:

Following program depicts how to read from the ‘text’ file using FileReader

a simple Java program to open a text file called temp.txt and to count the number of lines and characters in the
file.

 There are several ways to read a plain text file in Java
e.g. you can use FileReader, BufferedReader or Scanner to read
a text file.
 Every utility provides something special
e.g. BufferedReader provides buffering of data for fast reading,
and Scanner provides parsing ability.
 We can also use both BufferReader and Scanner to read a text
file line by line in Java.
Different ways of Reading a text file in Java

1. Using FileReader class: Convenience class for reading
character files. The constructors of this class assume that the
default character encoding and the default byte-buffer size are
appropriate.
Constructors defined in this class are:
// Creates a new FileReader, given the File to read from. FileReader(File file)
// Creates a new FileReader, given the FileDescriptor to read from.
FileReader(FileDescriptor fd)
// Creates a new FileReader, given the name of the file to read from. FileReader(String
fileName)
Here are some of the many ways of reading files(1)

Java Program to illustrate reading from FileReader using FileReader

2. Using BufferedReader: This method reads text from a
character-input stream.
It does buffering for efficient reading of characters, arrays, and
lines.
The buffer size may be specified, or the default size may be used.
The default is large enough for most purposes.
 In general, each read request made of a Reader causes a
corresponding read request to be made of the underlying
character or byte stream.
For example,
BufferedReader in = new BufferedReader(Reader in, int size);

Java Program to illustrate reading from FileReader using BufferedReader

3. Using Scanner class: A simple text scanner which can parse
primitive types and strings using regular expressions.
A Scanner breaks its input into tokens using a delimiter pattern,
which by default matches whitespace. The resulting tokens may
then be converted into values of different types using the
various next methods.

Java Program to illustrate reading from Text File using Scanner Class

Java provides functions to move files between directories. Two
ways to achieve this are described here.
The first method utilizes Files package for moving while the
other method first copies the file to destination and then deletes
the original copy from the source.
Moving a file from one directory to another using Java

 Renaming and moving the file permanently to a new location.
Syntax:
 public static Path move(Path source, Path target,
CopyOption..options) throws IOException
Parameters:
 source - the path to the file to move
 target - the path to the target file (may be associated with a
different provider to the source path)
 options - options specifying how the move should be done
Returns: the path to the target file
1. Using Files.Path move() method:

 Copying the file and deleting the original file using these two
methods.
Syntax of renameTo():
 public boolean renameTo(File dest)
 Description: Renames the file denoted by this abstract path
name.
 Parameters: dest - The new abstract path name for the
named file
 Returns: true if and only if the renaming succeeded; false
otherwise
 public boolean delete() Deletes the file or directory denoted
by this abstract path name.
2. Using Java.io.File.renameTo() and Java.io.File.delete() methods:

Java program to illustrate Copying the file and deleting the original file

Chapter 6

More Related Content

What's hot

Similar to Chapter 6

More from siragezeynu

Recently uploaded

Chapter 6

Editor's Notes