JAVA I/O - CIS @ Temple University

Document technical information

Format ppt
Size 216.6 kB
First found May 22, 2018

Document content analysis

Category Also themed
Language
English
Type
not defined
Concepts
no text concepts found

Persons

Organizations

Places

Transcript

JAVA I/O:
Streams and Files
CIS 068
I/O
• Usual Purpose: storing data to ‘nonvolatile‘
devices, e.g. harddisk
• Classes provided by package java.io
• Data is transferred to devices by ‘streams‘
output - stream
Program
Device
input - stream
Program
Device
CIS 068
Streams
JAVA distinguishes between 2 types of streams:
•
Text – streams, containing ‘characters‘
Program
I ‘ M
A
S T R I N G \n
Device
•Binary Streams, containing 8 – bit information
Program
01101001 11101101 00000000
Device
CIS 068
Streams
Streams in JAVA are Objects, of course !
Having
•
•
2 types of streams (text / binary) and
2 directions (input / output)
results in 4 base-classes dealing with I/O:
1.
2.
3.
4.
Reader: text-input
Writer: text-output
InputStream: byte-input
OutputStream: byte-output
CIS 068
Streams
InputStream
OutputStream
binary
Reader
Writer
text
CIS 068
Streams
•
InputStream, OutputStream, Reader, Writer are
abstract classes
•
Subclasses can be classified by 2 different
characteristics of sources / destinations:
– For final device (data sink stream)
purpose: serve as the source/destination of the
stream
(these streams ‘really’ write or read !)
– for intermediate process (processing stream)
Purpose: alters or manages information in the stream
(these streams are ‘luxury’ additions, offering methods for convenient
or more efficient stream-handling)
CIS 068
I/O: General Scheme
In General:
Reading (writing):
– open an input (output) stream
– while there is more information
read(write) next data from the stream
– close the stream.
In JAVA:
–
–
–
Create a stream object and associate it with a disk-file
– Give the stream object the desired functionality
while there is more information
read(write) next data from(to) the stream
close the stream.
CIS 068
Example 1
Writing a textfile:
–
–
Create a stream object and
associate it with a disk-file
– Give the stream object the
desired functionality
write data to the stream
–
close the stream.
CIS 068
Writing Textfiles
Class: FileWriter
Frequently used methods:
CIS 068
Writing Textfiles
Using FileWriter
• is not very convenient (only String-output
possible)
• Is not efficient (every character is written in
a single step, invoking a huge overhead)
Better: wrap FileWriter with processing streams
• BufferedWriter
• PrintWriter
CIS 068
Wrapping Textfiles
BufferedWriter:
• Buffers output of FileWriter, i.e. multiple
characters are processed together,
enhancing efficiency
PrintWriter
• provides methods for convenient
handling, e.g. println()
( remark: the System.out.println() – method is a method of the
PrintWriter-instance System.out ! )
CIS 068
Wrapping a Writer
A typical codesegment for opening a
convenient, efficient textfile:
FileWriter out = new FileWriter("test.txt");
BufferedWriter b = new BufferedWriter(out);
PrintWriter p = new PrintWriter(b);
Or with anonymous (‘unnamed‘) objects:
PrintWriter p = new PrintWriter(
new BufferedWriter(
new FileWriter("test.txt")));
CIS 068
Reading Textfiles
Class: ReadText
Frequently used Methods:
(The other methods are used for
positioning, we don’t cover that here)
CIS 068
Wrapping a Reader
Again:
Using FileReader is not very efficient. Better
wrap it with BufferedReader:
BufferedReader br =
new BufferedReader(
new FileReader(“name“));
Remark: BufferedReader contains the method readLine(), which is
convenient for reading textfiles
CIS 068
EOF Detection
Detecting the end of a file (EOF):
• Usually amount of data to be read is not known
• Reading methods return ‘impossible‘ value if
end of file is reached
• Example:
–
–
•
FileReader.read returns -1
BufferedReader.readLine() returns ‘null‘
Typical code for EOF detection:
while ((c = myReader.read() != -1){ // read and check c
...do something with c
}
CIS 068
Example 2: Copying a Textfile
import java.io.*;
public class IOTest
{
public static void main(String[] args)
{
try{
BufferedReader myInput = new BufferedReader(new
FileReader("IOTest.java"));
BufferedWriter myOutput = new BufferedWriter(new
FileWriter("Test.txt"));
int c;
while ((c=myInput.read()) != -1)
myOutput.write(c);
myInput.close();
myOutput.close();
}catch(IOException e){}
}
}
CIS 068
Binary Files
•
•
•
Stores binary images of information
identical to the binary images stored in
main memory
Binary files are more efficient in terms of
processing time and space utilization
drawback: not ‘human readable‘, i.e. you
can‘t use a texteditor (or any standardtool) to read and understand binary files
CIS 068
Binary Files
Example: writing of the integer ’42‘
• TextFile: ‘4‘ ‘2‘ (internally translated to 2
16-bit representations of the characters
‘4‘ and ‘2‘)
• Binary-File: 00101010, one byte
(= 42 decimal)
CIS 068
Writing Binary Files
Class: FileOutputStream
... see FileWriter
The difference:
No difference in usage, only in output format
CIS 068
Reading Binary Files
Class: FileInputStream
... see FileReader
The difference:
No difference in usage, only in output format
CIS 068
Binary vs. TextFiles
pro
Binary
con
Efficient in terms of Preinformation
about data needed
time and space
to understand
content
Text
Human readable, Not efficient
contains redundant
information
CIS 068
Binary vs. TextFiles
When use Text- / BinaryFiles ?
• ALWAYS use TextFiles for final results if
there’s no imperative reason to favor efficiency against readability.
Example: SIP - Standard
• Binary Files might be used for non-final
interchange between programs
• Binary Files are always used for large
amount of data (images, videos etc.), but
there’s always an exact definition of the meaning of the bytestream
Example: JPG, MP3, BMP
CIS 068
... outlook
Next time:
•
Exception handling
•
Other types than Files (Console,
Serializing)
CIS 068

Similar documents

×

Report this document