Download Slides

Introduction to Java 2
Programming
Lecture 7
IO, Files, and URLs
Overview
• Java I/O
– The java.io package
– Streams, Readers and Writers
• Files
– Working with Files
• URLs
– Working with Internet Resources
Java I/O – The Basics
• Java I/O is based around the concept of a stream
– Ordered sequence of information (bytes) coming from a
source, or going to a ‘sink’
– Simplest stream reads/writes only a single byte, or an
array of bytes at a time
• Designed to be platform-independent
• The stream concept is very generic
– Can be applied to many different types of I/O
– Files, Network, Memory, Processes, etc
Java I/O – The Basics
• The java.io package contains all of the I/O
classes.
– Many classes specialised for particular kinds of stream
operations, e.g. file I/O
• Reading/writing single bytes is quite limited
– So, it includes classes which provide extra functionality
– e.g. buffering, reading numbers and Strings (not bytes),
etc.
• Results in large inheritance hierarchy, with
separate trees for input and output stream classes
Java I/O -- InputStream
Java I/O – InputStreams
Java I/O – Using InputStreams
• Basic pattern for I/O programming is as
follows:
Open a stream
While there’s data to read
Process the data
Close the stream
Java I/O – Using InputStreams
• I/O in Java:
InputStream in = new
FileInputStream(“c:\\temp\\myfile.txt”);
int b = in.read();
//EOF is signalled by read() returning -1
while (b != -1)
{
//do something…
b = in.read();
}
in.close();
Java I/O – Using InputStreams
• But using buffering is more efficient, therefore we
always nest our streams…
InputStream inner = new
FileInputStream(“c:\\temp\\myfile.txt”);
InputStream in = new BufferedInputStream(inner);
int b = in.read();
//EOF is signalled by read() returning -1
while (b != -1)
{
//do something…
b = in.read();
}
in.close();
Java I/O – Using InputStreams
• We’ve omitted exception handling in the
previous examples
• Almost all methods on the I/O classes
(including constructors) can throw an
IOException or a subclass.
• Always wrap I/O code in try…catch blocks
to handle errors.
Java I/O – Using InputStreams
InputStream in = null;
try
{
InputStream inner = new
FileInputStream(“c:\\temp\\myfile.txt”);
in = new BufferedInputStream(inner);
//process file
} catch (IOException e)
{
e.printStackTrace();
}
finally
{
try { in.close(); } catch (Exception e) {}
}
Java I/O – OutputStream
Java I/O – OutputStreams
Java I/O – Using InputStreams
• Basic pattern for output is as follows:
Open a stream
While there’s data to write
Write the data
Close the stream
Java I/O – Using OutputStreams
• Output in Java:
OutputStream out = new
FileOutputStream(“c:\\temp\\myfile.txt”);
while (…)
{
out.write(…);
}
out.close();
Java I/O – Using OutputStreams
OutputStream out = null;
try
{
OutputStream inner = new
FileOutputStream(“c:\\temp\\myfile.txt”);
out = new BufferedOutputStream(inner);
//write data to the file
} catch (IOException e)
{
e.printStackTrace();
}
finally
{
try { out.close(); } catch (Exception e) {}
}
But That’s Not All!
• Input/OutputStream and sub-classes were part of
Java 1.1.
• Java 1.2 adds more classes specialised for
character based I/O
– The stream classes are for data I/O.
• Classes for character I/O are called Readers and
Writers
• Why have specialised classes?
– To support foreign languages
Unicode
• Each character in the ASCII character set fits into
a single byte
– …but that’s not enough for chinese, and other complex
alphabets
– Need more than a single byte
– A Java character (char) is 2 bytes
• Java handles text using Unicode
– International standard character set, containing
characters for almost all known languages
– And a few imaginary ones! (Klingon, Elvish…)
• Inside the JVM all text is held as Unicode
Java Text I/O
• Because byte != character for all languages, you
have to turn bytes into chars using a
Input/OutputStream
• Java provides Readers and Writers to save you this
work.
• These classes deal with streams of characters
– Read/write single character or array of characters
– Again there are classes specialised for particular
purposes
Java I/O – Reader
Java I/O – Readers
Using Readers
Reader in = null;
try
{
Reader inner = new FileReader(“c:\\temp\\myfile.txt”);
in = new BufferedReader(inner);
//process file
} catch (IOException e)
{
e.printStackTrace();
}
finally
{
try { in.close(); } catch (Exception e) {}
}
Java I/O – Writer
Java I/O – Writers
Using Writers
Writer out = null;
try
{
Writer inner = new FileWriter(“c:\\temp\\myfile.txt”);
out = new BufferedWriter(inner);
//write data to the file
} catch (IOException e)
{
e.printStackTrace();
}
finally
{
try { out.close(); } catch (Exception e) {}
}
Bridging the Gap
• Sometimes you need to bridge across the two
hierachies
– Use InputStreamReader or OutputStreamWriter
• InputStreamReader
– Reads bytes from an InputStream, and turns them into
characters using a character encoding
• OutputStreamWriter
– Turns characters sent to the Writer into bytes written by
the OutputStream, again using a character encoding.
The File Object
• Java provides access to the file system through the
java.io.File object
– Represents files and directories
• Has methods for working with files and directories
– Making directories, listing directory contents
– renaming and deleting, checking permissions, etc
• Check whether the File corresponds to a directory
or a file with isDirectory()
• Well-featured, and intuitive
– Take a look through the javadocs
• Quick example…
The URL Object
• Similar to File is the java.net.URL class
– Provides access to information about website addresses
• Most useful is a means to open an InputStream to
a remote website
– Use the openStream() method
• Makes it very simple to retrieve files from the
Internet.
• Throws MalformedURLException if you provide
an illegal internet address in its constructor
• Example…
URL Object Example
try
{
URL p = new
URL(“http://www.ldodds.com/lectures/person.jar”);
InputStream inner = p.openStream();
BufferedInputStream in = new
BufferedInputStream(inner);
//process the file…
in.close()
catch (Exception e)
{
e.printStackTrace();
}