• What Are They:
  • A sequence of bytes with indeterminate length that ends with an END-OF-STREAM character (Ctrl-D in Unix and Ctrl-Z in Windows)
• Why They Are Used:
  • The way you work with a stream is independent of its channel (e.g., keyboard, console, network connection, storage devices)

• What Are They?
  • Streams that are associated with (what used to be) the standard channels for input and output
• What Does This Mean Now?
  • The terminal window (sometimes called the console) has standard streams associated with it
  • Most IDEs have standard streams associated with one or more windows/panes/views

• When Are They Created?
  • Before main() is called
• What Are They Named?
  • System.in
  • System.out
  • System.err

• Some Questions (Related to Output):
  • What is System (and how can you tell)?
  • What is System.out (and how can you tell)?
  • What is System.err (and how can you tell)?
• Some Questions (Related to Input):
  • What is System (and how can you tell)?
  • What is System.in (and how can you tell)?
  • What methods does System.in have (and not have)?
• Some Questions Related to Both:
  • How would you use System.out, System.err, and/or System.in?

• Standard Output/Error:
  • System.out and System.err are PrintStream objects
• Standard Input:
  • System.in is an InputStream object

• Unformatted Output:
  • PrintStream.print(java.lang.String) prints the String (i.e., sends it to the stream)
  • PrintStream.println(java.lang.String) prints the String followed by the line separator String (which is "\n" in Linux, "\r" in OSX and "\r\n" in MSW)
• An Important Point:
  • Text sent to an output stream may be buffered
  • To force text through the buffer use PrintStream.flush()
  • This is particularly important to be aware of when debugging

• An Observation:
  • Output often needs to be formatted in a very particular way
• Format Strings:
  • Encapsulated in the Formatter class
• Two Approaches to Using Format Strings:
  • Use the String.format(java.lang.String, java.lang.Object...) method to create a formatted String and then call print() or println()
  • Use the PrintStream.printf(java.lang.String, java.lang.Object...) convenience method to perform both steps in one call

• Components:
  • String literals
  • Format specifiers
• Format Specifiers:
  • Syntax: %[flags][width][.precision]conversion
• Conversions:
  • 'b' for a boolean
  • 'c' for a char
  • 'd' for an integer
  • 'e' for a real number in scientific notation
  • 'f' for a real number
  • 's' for a String
• Flags:
  • '-' for left-justified
  • '+' to always include the sign
  • ' ' to use a space for the sign of a positive number
  • '0' to pad with zeros
  • ',' to use grouping separators
  • '(' to put negative numbers in parentheses

An Example that uses printf()

javaexamples/iobasics/PrintfExample.java

import java.io.PrintStream;

/**
 * An example that illustrates the use of the printf()
 * method in the PrintStream class
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class PrintfExample
{
    /**
     * The entry point of the application
     *
     * @param args   The command-line arguments
     */
    public static void main(String[] args)
    {
       int     age, weight;
       double  monday, tuesday, wednesday;
       
       age = 27;
       
       System.out.printf("%d\n", age);
       System.out.printf("%10d\n", age);
       
       weight = 155;
       
       System.out.printf("Prof. B. is %d years old\n", age);
       System.out.printf("Age: %d\tWeight: %d\n", age, weight);
       

       monday    =  35.8;
       tuesday   =   0.0;
       wednesday = -10.2;

       System.out.println("\nWith No Flags, Width or Precision");       
       System.out.printf("%f\n", monday);
       System.out.printf("%f\n", tuesday);
       System.out.printf("%f\n", wednesday);

       System.out.println("\nWith No Flags");       
       System.out.printf("%5.1f\n", monday);
       System.out.printf("%5.1f\n", tuesday);
       System.out.printf("%5.1f\n", wednesday);

       System.out.println("\nWith + Flags");       
       System.out.printf("%+5.1f\n", monday);
       System.out.printf("%+5.1f\n", tuesday);
       System.out.printf("%+5.1f\n", wednesday);
    }
}
        

• Raw Input:
  • The read() methods can be used to read one or more bytes
• An Observation:
  • We don't want to have to work with the binary representation of char, double, or int
• A Better Approach:
  • "Wrap" the InputStream in a Scanner object and use its next___() methods

• Important Constructors:
  • Scanner(java.io.InputStream)
• Some Relevant Methods:
  • Scanner.useDelimiter(java.lang.String)
  • Scanner.hasNextDouble() , Scanner.hasNextInt() , and Scanner.hasNextLine()
  • Scanner.nextDouble() , Scanner.nextInt() , and Scanner.nextLine()

An Example that uses a Scanner

javaexamples/iobasics/ScannerExample.java

import java.util.Scanner;

/**
 * An example that illustrates the use of the Scanner class
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class ScannerExample
{
    /**
     * The entry point of the application
     *
     * @param args   The command-line arguments
     */
    public static void main(String[] args)
    {
       int        age, weight;
       double     salary;
       Scanner    keyboard;
       String     line, name;
       String[]   parts;       
       
       keyboard = new Scanner(System.in);
       
       System.out.print("Name: ");
       name = keyboard.nextLine();

       System.out.print("Salary: ");
       salary = keyboard.nextDouble();
       keyboard.nextLine(); // Consume the end-of-line character

       System.out.print("Phone number (###-###-####): ");
       line   = keyboard.nextLine();

       System.out.print("Age Weight (# #): ");
       age    = keyboard.nextInt();
       weight = keyboard.nextInt();

       keyboard.close();       
    }
}
        

An Inconvenience when Using Scanner Objects

javaexamples/basics/ScannerInconvenienceExample.java

import java.util.Scanner;

/**
 * An example that illustrates an inconvenience assoicated with
 * the behavior of Scanner objects.
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class ScannerInconvenienceExample
{
    /**
     * The entry point of the application.
     *
     * @param args The command-line arguments (which are ignored)
     */
    public static void main(String[] args)
    {
        int     age;
        Scanner keyboard;        
        String  name;
        
        keyboard = new Scanner(System.in);
        
        // If you run this program you won't be able to enter your
        // name because the return you enter after your age will
        // be considered the "next line"
        System.out.print("Enter your age: ");
        age = keyboard.nextInt();
        System.out.print("Enter your name: ");
        name = keyboard.nextLine();

        keyboard.close();
    }
}

        

• The Issue:
  • The methods that read "up to" a delimiter do not consume newline characters
• A "Work Around":
  • Invoke nextLine() immediately after invoking one of these methods

• A Recent Addition:
  • A Console object can be retrieved using the System.console() method and it has both readLine() and printf() methods
• Problems with this Approach:
  • The console() method returns null in IDEs
  • The streams can't be re-directed within a program making it inappropriate for many testing environments