• Raw I/O:
  • A way to read bytes from a stream
• The Limitations:
  • Converting from bytes to characters is complicated because of the different encoding schemes

• Character-Based I/O:
  • Reader and Writer classes that can be used to decorate InputStream and OutputStream objects
• Providing Additional Functionality:
  • Use the decorator pattern again (however, since there is no interface at the top, each decorator both extends its parent and delegates important operations to its parent)

1. Get an InputStream
• System.in
• From a File (by constructing a FileInputStream )
• From a URL (using the openStream method)
• From a Socket (using the getInputStream method)
2. Create an InputStreamReader (from the InputStream )
3. Create a BufferedReader (from the InputStreamReader )

1. Get an OutputStream
• System.out
• From a File (by constructing a FileOutputStream )
• From a Socket (using the getOutputStream method)
2. Create an OutputStreamWriter (from the OutputStream )
3. Create a PrintWriter (from the OutputStreamWriter )

javaexamples/iobasics/WriterReaderExample.java

        import java.io.*;

/**
 * A simple exho application that demonstrates character-based I/O in Java.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class WriterReaderExample
{
    /**
     * The entry point of the application
     *
     * @param args   The command-line arguments
     */
    public static void main(String[] args) throws IOException
    {
        BufferedReader  in;
        PrintWriter     out;
        String          s;


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

        out.print("Enter a word: ");
        out.flush();

        s = in.readLine();

        out.print("\nYou typed: " + s + "\n");
        out.flush();
    }
}
        

An Example

javaexamples/iobasics/ReaderExample.java

        import java.io.*;
import java.net.*;

/**
 * An example that illustrates the flexibility of I/O streams
 * in Java
 *
 * -k              To use the keyboard
 * -f filename     To use a file (e.g., cs.txt)
 * -u url          To use a URL  (e.g., http://www.cs.jmu.edu/common/coursedocs/BernsteinMaterials/javaexamples/iobasics/cs.txt)
 */
public class ReaderExample
{
    /**
     * The entry point of the application
     *
     * @param args   The command-line arguments
     */
    public static void main(String[] args) throws IOException
    {
        BufferedReader       in;
        FileReader           fileReader;
        InputStreamReader    isReader;
        PrintWriter          out;
        String               line;
        URL                  url;


        in = null;

        // Construct the appropriate kind of BufferedReader based
        // on the command-line options
        if (args[0].equals("-f")) {         // Read from a file

            fileReader = new FileReader(args[1]);
            in = new BufferedReader(fileReader);

        } else if (args[0].equals("-u")) { // Read from a URL

            url = new URL(args[1]);
            isReader = new InputStreamReader(url.openStream());
            in = new BufferedReader(isReader);

        } else {                         // Read from the keyboard

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


        out = new PrintWriter(System.out);

        // Keep reading and printing until EOF
        do {

            line = in.readLine();
            if (line != null) {
                out.println(line);
                out.flush();
            }

        } while (line != null);
    }




}
        

• The Approach You've Probably Seen:
  • The Concept - Provide formatting information to the output method
  • The Participants - The printf() method in the PrintWriter class
• Another Approach:
  • The Concept - Provide formatted String objects to the output method
  • The Participants - NumberFormat , ChoiceFormat , the format() method in
  the String class, and the print()/println() methods in the PrintWriter class

An Example that Formats "Choices"

javaexamples/iobasics/ChoiceFormatExample.java

        import java.io.*;
import java.text.*;

/**
 * An example that illustrates the use of the NumberFormat
 * class
 */
public class ChoiceFormatExample
{
    /**
     * The entry point of the application
     *
     * @param args   The command-line arguments
     */
    public static void main(String[] args) throws IOException
    {
        ChoiceFormat          formatter;
        double                grade;
                              // The intervals are half-open [low, high)
        double[]              limits =       { 0, 60, 70, 80, 90};
        String[]              letterGrades = {"F","D","C","B","A"};
        String                outputString;


        // Note that the constuctor is used (unlike NumberFormat)
        formatter = new ChoiceFormat(limits, letterGrades);

        grade = 82.5;
        outputString = formatter.format(grade);

        System.out.println("Numeric Grade: "+grade);
        System.out.println("Letter  Grade: "+outputString);
    }
}
        

• Internationalization:
  • Numbers, dates, currencies, etc... are often formatted diffferently in different countries
• The Locale Class:
  • An encpasulation of a geographical, political or cultural region that can be used for locale-sensitive tasks
• International Standards:
  • ISO Language Codes
  • ISO Country Code

An Example that Formats Numbers

javaexamples/iobasics/NumberFormatExample.java

        import java.io.*;
import java.text.*;
import java.util.Locale;

/**
 * An example that illustrates the use of the NumberFormat
 * class
 */
public class NumberFormatExample
{
    /**
     * The entry point of the application
     *
     * @param args   The command-line arguments
     */
    public static void main(String[] args) throws IOException
    {
        NumberFormat          formatter;
        String                outputString;


        // Note that the constuctor is often not used directly
        formatter = NumberFormat.getInstance();

        // An example similar to %d in printf
        formatter.setMinimumIntegerDigits(5);
        formatter.setGroupingUsed(false);
        outputString = formatter.format(20);
        System.out.println(outputString);

        // An example similar to %f in printf
        formatter.setMinimumIntegerDigits(0);
        formatter.setMaximumFractionDigits(2);
        formatter.setGroupingUsed(false);
        outputString = formatter.format(1052.2891554);
        System.out.println(outputString);

        // An example that prints currency values
        formatter = NumberFormat.getCurrencyInstance();
        outputString = formatter.format(1953249.25);
        System.out.println(outputString);


        // An example that prints currency values in a different locale
        formatter = NumberFormat.getCurrencyInstance(Locale.GERMANY);
        outputString = formatter.format(1953249.25);
        System.out.println(outputString);


        
    }
}
        

• An Approach You've Seen:
  • Use a Scanner object and its next___() methods
• Shortcomings of this Approach:
  • "Unexpected" consumption (or lack thereof) of newline characters
  • Not robust with respect to formatting defects

• A More Robust Approach:
  • Only read String objects
  • Break the String into parts and convert the parts
• Some Relevant Classes/Methods:
  • The split() method in the String class and the StringTokenizer class
  • Double and Integer

Using the StringTokenizer

javaexamples/iobasics/FacultyRecordTokenizer.java

        import java.io.*;
import java.util.*;

/**
 * An example that illustrates the use of reading from a file
 * and using the StringTokenizer class.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class FacultyRecordTokenizer
{
    /**
     * The entry point of the application
     *
     * @param args   The command-line arguments
     */
    public static void main(String[] args)
    {
        BufferedReader       in;
        FileReader           fileReader;
        InputStreamReader    isReader;
        String               delimiters, email, line, name, phone;
        StringTokenizer      tokenizer;


        try
        {
            // Setup the reader and writer
            fileReader = new FileReader("cs.txt");
            in = new BufferedReader(fileReader);
            
            // Keep reading, tokenizing and processing
            while ((line = in.readLine()) != null)
            {
                tokenizer = new StringTokenizer(line, "\t", false);
                while (tokenizer.hasMoreTokens()) 
                {
                    try
                    {
                        name = tokenizer.nextToken();
                        phone = tokenizer.nextToken();
                        email = tokenizer.nextToken();
                        
                        // Do something with the information

                    }
                    catch (NoSuchElementException nsee)
                    {
                        // Do something when there is a problem
                    }
                }
            }
            in.close();
        }
        catch (IOException ioe)
        {
            System.err.println("IO Problem");
        }
    }
}
        

Using the parse___() Methods

javaexamples/iobasics/ExpressionTokenizer.java

        import java.io.*;
import java.util.*;

/**
 * An example that illustrates the use of the
 * StringTokenizer class
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class ExpressionTokenizer
{
    /**
     * The entry point of the application
     *
     * @param args   The command-line arguments
     */
    public static void main(String[] args) throws IOException
    {
        double                 value;
        String                 token;
        StringTokenizer        tokenizer;


        // Setup the delimiters
        if (args.length == 0) {

            System.out.println("You didn't enter an expression!");

        } else {

            tokenizer = new StringTokenizer(args[0], 
                                            "+-x/%() \t\n",
                                            true);   // Return delimiters

            // Tokenize the argument
            while (tokenizer.hasMoreTokens()) {

                token = tokenizer.nextToken();
                System.out.print(token);
                System.out.flush();

                // Try to convert the token into a double
                try {

                    value = Double.parseDouble(token);
                    System.out.print(" is a number");
                    System.out.flush();

                } catch (NumberFormatException nfe) {
                    
                    System.out.print(" is not a number");
                    System.out.flush();
                }

                System.out.println();
            }
        }
    }




}
        

• Similarities of String.split() and StringTokenizer:
  • Tokenize a String
• Differences between String.split() and StringTokenizer:
  • split() uses regular expressions, StringTokenizer uses a list of delimiters
  • split() returns an array, StringTokenizer is an iterator
  • StringTokenizer can return the delimiters as tokens

A Comparison of StringTokenizer and String.split()

javaexamples/iobasics/BufferedReaderExample.java

        import java.io.*;
import java.util.*;



/**
 * An example that illustrates the use of the Scanner class
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class BufferedReaderExample
{
    /**
     * The entry point of the application
     *
     * @param args   The command-line arguments
     * @throws IOException if any line can't be read
     */
    public static void main(String[] args) throws IOException
    {
        BufferedReader      in;
        double              salary;        
        InputStreamReader   isr;
        int                 age, weight;        
        String              line, name, phone;
        String[]            tokens;
        StringTokenizer     st;        

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

        System.out.print("Name: ");
        name = in.readLine();

        System.out.print("Salary: ");
        line   = in.readLine();
        salary = Double.parseDouble(line);

        System.out.print("Phone number (###-###-####): ");
        phone = in.readLine();

        System.out.print("Age Weight (# #): ");
        line   = in.readLine();
        // One way to tokenize: Using the split() method
        tokens = line.split(" ");
        age    = Integer.parseInt(tokens[0]);
        weight = Integer.parseInt(tokens[1]);
        // Another way to tokenize: Using a StringTokenizer
        st     = new StringTokenizer(line, " ");
        age    = Integer.parseInt(st.nextToken());
        weight = Integer.parseInt(st.nextToken());
        

        in.close();
    }
    
    
}