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(“ InputStream inner = p.openStream(); BufferedInputStream in = new BufferedInputStream(inner); //process the file… in.close() catch (Exception e) { e.printStackTrace(); }