IO

Terms:

• stdin
• stdout
• sterr
• Files
• FileInputStream
• FilterInputStream
  • DataInputStream
• URLInputStream

How to

Then with 1.5, the java.util.Scanner -- here is a small example from the CSCI 111 class (Main)

These streams supersede the byte streams for all textual I/O

Subs:

A stream is a path of communication between the source of some information and its destination. Overview of IO streams (old but nice hierarchy diagram) and newer tutorial version ("No matter how they work internally, all streams present the same simple model to programs that use them: a stream is a sequence of data.")

This information, an uninterpreted stream of bytes, can come from any "pipe source", the computer's memory, the Internet, etc. In fact, the source and destination of the information are completely arbitrary producers and consumers of bytes. Therein lies the power of the abstraction; you don't need to know about the source of the information when reading from a stream or the destination when writing to one.

General-purpose methods accept a stream argument to specify that source or destination. Arbitrary processors (or filters) of data have two stream arguments - read first, write to second. The processors have no clue about the streams - stream could be to files, could be to sockets, ...

UNIX users and users familiar with command lines have used a type of I/O commonly known as standard I/O.

• The standard input file (stdin) is just the keyboard
• The standard output file (stdout) is typically the terminal screen.
• The standard error output file (stderr) is also normally the terminal screen, but is implemented as a separate file so you can distinguish between normal output and error messages.

Java gives access to standard I/O via the System class. Specifically, the three files are implemented in Instance Variables there.

Stdin

implements stdin as an instanceof the InputStream class (java.io.InputStream). With System.in, you have access to the read() and skip(long n)

methods.
read() allows you to read one byte of input.
skip(long n) skips over n bytes of the input

Stdout

implements Stdout as a PrintStream. Youcan use the print() and println() methods supplying any of the Java base types as arguments

Stderr

implements stderr in the same was as stdout. As with System.out, you have access to the PrintStream methods.

Here is a myCat example that works similarly to the UNIX cat or DOS type utility - repeating what you typed in. Using a scanner these days would be even easier:

import java.io.*; class myCat { public static void main (String args[]) throws IOException { int b; int count = 0; while ((b = System.in.read()) != -1) { count++; System.out.print((char)b); } System.out.println(); // blank line // here we would have the Filestream System.out as the Printstream System.err.println("counted " + count + " total bytes."); } }

Common I/O classes - the tutorial and particularly: Character Streams and Byte Streams

The File class provides several utilities for dealing with files and obtaining basic information about these files:
Java In a Nutshell Files and Directories

To create a file, you can use any of three constructors:

File myFile; myFile = new File("/dir/filename"); or myFile = new File("/dir", "filename"); // could be more useful if the directory and file are variables or File myDir = new File("/dir"); myFile = new File(myDir, "filename");

The constructor you use will depend on the other file objects you need to access. For example, if you use only one file in your application, the first is easiest. Several files from a common directory indicates the other two.

See API for methods (e.g. canRead(), exists(), list(), length(), isFile(), isDirectory(), ...)

A sample stand-alone application to display basic file information on files passed in as command-line arguments:

import java.io.*; /* * fileInfo * A simple File object test program. */ class fileInfo { public static void main(String args[ ]) throws IOException { File fileToCheck; if (args.length > 0) { for (int i = 0; i < args.length; i++) { fileToCheck = new File(args[i]); info(fileToCheck); } } else { System.out.println("No file given."); } } public static void info (File f) throws IOException { System.out.println("Name: " + f.getName( )); System.out.println("Path: " + f.getPath( )); if (f.exists()) { System.out.print("File exists"); System.out.print((f.canRead() ? " and is Readable":"")); System.out.print((f.canWrite()? " and is Writable":"")); System.out.println("."); System.out.println("File is "+f.length( )+" bytes."); } else { System.out.println("File does not exist."); } } }

FileInputStream and FileOutputStream read from and write to files. ByteArrayInputStream and ByteArrayOutputStream read from and write to an array of bytes in memory. PipedInputStream reads bytes from a PipedOutputStream (and vice versa with writes) These classes work together to implement a "pipe" for communication between threads.
Java In a Nutshell: Input and Output Streams

FileInputStreams

FileInputStreams typically represent text files accessed in sequential order, byte by byte. With FileInputStreams, you can choose to access one byte, several bytes or the entire file.

To open, you give a String or a File object to the constructor

FileInputStream myFileStream; myFileStream = new FileInputStream ("/dir/filename");

File myfile FileInputStream myFileStream; myFile = new File ("/dir/filename"); myFileStream = new FileInputStream (myFile);

Reading a FileInputStream

• int read() : reads one byte, returns -1 at end of stream
• int read(byte b[]) : fills entire arrray, if possible then returns number of bytes read, returns -1 if end of stream is reached
• int read(byte b[], int offset, int len) : reads len bytes into b starting at b[offset]

Most noticable are the following:

* Reader
* Writer

Reader is the superclass of all character input streams and
Writer is the superclass of all character output streams.
These streams supersede the byte streams for all textual I/O

Subs:

• Buffered (Reader/Writer)
• CharArray (Reader/Writer)
• Filter (Reader/Writer)
• InputStreamReader/OutputStreamWriter -
  File (Reader/Writer)
• Piped (Reader/Writer)
• String (Reader/Writer)

The most noticable difference from version 1.0 was that the method readLine() from DataInputStream is no longer there.

It is now available in BufferedReader

java.io.Reader

BufferedReader: Reads text from a character- input stream, buffering characters so as to provide for the efficient reading of characters, arrays and lines. The buffer size may be specified or the default size used.

In general, each read request made of a Reader causes a corresponding read request to be made of the underlying character or byte stream. It is therefore advisable to wrap a BufferedReader around any Reader whose read() operations may be costly, such as FileReaders and InputStreamReaders.

For example:
InputStreamReader is a bridge fom byte streams to character streams: It reads bytes and translates them into characters according to a specified character encoding. The encoding that is uses may be specified by name, or the platform's default encoding may be accepted.

Each invocation of one of an InputStreamReader's read() methods may cause one or more bytes to be read from the underlying byte-input stream. For top efficiency, consider wrapping an InputStreamReader within a BufferedReader:

BufferedReader in = new BufferedReader(new InputStreamReader (System.in));

URL Input Streams

URL is at java.net.URL

Also:

URL sourceURL = new URL(URLname); instream = sourceURL.openStream(); inFile = new DataInputStream(instream);

You can also explicitly connect to the URL (so you could test - openConnection throws an IOException - as do most I/O streams). openConnection() returns a URLConnection object that represents a connection to the remote object referred to by this URL.

Now you can use istream to read information like you do with a FileInputStream object

istream.read(buffer, 0, buffer.length);

Also, always remember to do I/O in try/catch blocks since most I/O methods throw exceptions.