"A stream is a flowing sequence of characters."

System.out.println("my output string");

While (System.in.read() != -1) ...

System.out refers to an output stream managed by the System class that implements the standard output system.

close() - Closes the stream. 
flush() - Flushes the stream. 
write(int) - Writes a byte. 
write(byte[]) - Writes an array of bytes. 
write(byte[], int, int) - Writes a sub array of bytes.

A PrintStream adds functionality to another output stream -- namely, the ability to print representations of various data values conveniently. 

Two other features are provided as well. Unlike other output streams, a PrintStream never throws an IOException; instead, exceptional situations merely set an internal flag that can be tested by the checkError method. 

Optionally, a PrintStream can be created so as to "autoflush"; this means that after an array of bytes is written, or after a single byte equal to '\n' is written, the flush method is automatically invoked.

checkError() - Flushes the print stream and returns whether or not there was 
an error on the output stream. 
close() - Closes the stream. 
flush() - Flushes the stream. 

print(various argument types) - Prints the argument. 

println(various argument types) - Prints the argument. 
println(String) Prints a string followed by a newline. 

write(int) - Writes a byte. 
write(byte[], int, int) - Writes a sub array of bytes.

• Object is the class from which all other classes are derived 
• OutputStream is a subclass of Object. 
• FilterOutputStream is a subclass of OutputStream. 
• PrintStream is a subclass of FilterOutputStream. 
• System contains a class variable named out of type PrintStream. 

While (System.in.read() != -1) ...

The general contract of read is that it reads one byte from the input stream. The byte is returned as an integer in the range 0 to 255 (0x00-0xff). If no byte is available because the stream is at end of file, the value -1 is returned. 

This method blocks until input data is available, end of file is detected, or an exception is thrown. 

If the byte cannot be read for any reason other than end of file, an IOException is thrown. In particular, an IOException is thrown if the input stream has been closed

• Object is the class from which all other classes are derived 
• InputStream is an abstract subclass of the class Object 
• in is a class variable of type InputStream 

Object
        InputStream
                FileInputStream
                PipedInputStream
                FilterInputStream (abstract)
                        DataInputStream
                        BufferedInputStream
                        LineNumberInputStream
                        PushbackInputStream
                ByteArrayInputStream
                SequenceInputStream
                StringBufferInputStream

Object
        OutputStream
                FileOutputStream
                PipedOutputStream
                FilterOutputStream (abstract)
                        DataOutputStream
                        BufferedOutputStream
                        PrintStream
                ByteArrayOutputStream

A FileDescriptor is an opaque representation of a connection to an actual file in a file system, or to a network socket, or to another source or sink of bytes. The main practical use for a file descriptor is to create a FileInputStream or FileOutputStream to contain it.

/* File files01.java Copyright 1997, R.G.Baldwin
This application illustrates writing and then reading a 
file one byte at a time.

The instantiation of a file stream object is illustrated 
using two different approaches:
1.  Using a literal string containing the name of the file.
2.  Using an object of type File containing the name of 
the file.

Also illustrates use of the methods of the File class to
inquire about the properties of the file:  absolute path 
and length.

The output from the program is:

Start the program and write a file
Get info on, read, and print the file
Path is C:\BALDWIN\Java\SampProg\Java\junk.txt
Length 4
Dick
End of program
**********************************************************/

import java.io.*;

class files01{
  public static void main(String[] args)
  {
    System.out.println(
                    "Start the program and write a file");
    try{
    //Instantiate and initialize an output file stream 
    // object using a string containing the name of the 
    // file.
    FileOutputStream outFile = 
                          new FileOutputStream("junk.txt");
  
    //Write four bytes to the file and close it
    outFile.write('D');
    outFile.write('i');
    outFile.write('c');
    outFile.write('k');
    outFile.close();
  }catch(IOException e){}

    System.out.println(
                  "Get info on, read, and print the file");
  
  //Instantiate an object of type file containing the name
  // of the file.
  File junkFile = new File("junk.txt");
  
  //Use the File object to get info about the file
  System.out.println(
                 "Path is " + junkFile.getAbsolutePath());
  System.out.println("Length " + junkFile.length() );
  
  //Now read and print the data in the file
  try{
    //Instantiate and initialize the stream object using 
    // the File object.
    FileInputStream inFile = new FileInputStream(junkFile);
    int data;
  
    //Read and print until eof indicated by -1.  read() 
    // method returns integer.  Must cast as char to print.
    // Otherwise, the numeric value of the byte is 
    // displayed.
    while( (data = inFile.read()) != -1)
      System.out.print((char)data);
    inFile.close();
  }catch(IOException e){}
  System.out.println(); //new line
  System.out.println("End of program");
  }// end main

}//end class files01 definition

/* File pipe01.java Copyright 1997, R.G.Baldwin
This Java application illustrates the piping of the output
from one thread to the input of another thread.

The SenderThread sends the integers 0, 1, 2, and 3 with 
pauses in between.  The ReceiverThread receives and sums 
the integers.

The actual sequence of data in the output depends on the 
values obtained from the random number generator used to 
produce pauses.  

Tested using JDK 1.1.3 under Win95.

For one particular run, the output was as 
follows:

Starting SenderThread
Sending 0
Starting ReceiverThread
Received 0
Sum = 0
Sending 1
Received 1
Sum = 1
Sending 2
Sending 3
Received 2
Sum = 3
Received 3
Sum = 6
SenderThread done
ReceiverThread done, sum = 6
Finalizing sender thread
Finalizing receiver thread
**********************************************************/
import java.io.*;

class SenderThread extends Thread{
  //Piped output stream obj init by constructor
  PipedOutputStream pos; 

  //-----------------------------------------------------//
  
  //Constructor
  public SenderThread(PipedOutputStream posIn){
    pos = posIn; //save piped output stream object
  }//end SenderThread constructor
  //-----------------------------------------------------//

  public void run(){ //this method runs as a thread
    System.out.println("Starting SenderThread");
    try{
      for( int i = 0; i < 4; i++){
        //write a byte to the piped output stream
        pos.write(i); 
        System.out.println("Sending " + i);
        try{//sleep for awhile
          sleep((int)(Math.random() * 1000)); 
        }catch(InterruptedException e){}
      }//end for loop
    }catch(IOException e){}
    System.out.println("SenderThread done");
  }//end run() method
  //-----------------------------------------------------//
  
  public void finalize(){
    System.out.println("Finalizing sender thread");
  }//end finalize
  //-----------------------------------------------------//

}//end SenderThread class definition
//=======================================================//


class ReceiverThread extends Thread{
  //piped input stream obj init by constructor
  PipedInputStream inputStream; 
  int sum = 0, inData = 0; //working variables
  //-----------------------------------------------------//
  
  //Constructor
  public ReceiverThread(PipedInputStream inStream){
    //save piped input stream object
    inputStream = inStream; 
  }//end ReceiverThread constructor
  //-----------------------------------------------------//

  public void run(){ //this method runs as a thread
    System.out.println("Starting ReceiverThread");
    try{
      //read the first byte as an integer
      inData = inputStream.read(); 
      System.out.println("Received " + inData);
      while (inData != -1){ 
        //read until integer -1 signals no more data
        sum += inData; //accumulate the sum
        System.out.println("Sum = " + sum);
        //read next byte as an integer
        inData = inputStream.read(); 
        System.out.println("Received " + inData);
      }//end while loop
    }catch(IOException e){}
    System.out.println(
                      "ReceiverThread done, sum = " + sum);
  }//end run() method
  
  public void finalize(){
    System.out.println("Finalizing receiver thread");
  }//end finalize
  //-----------------------------------------------------//

}//end ReceiverThread class definition
//=======================================================//

class pipe01{ //controlling class
  public static void main(String[] args){
    System.runFinalizersOnExit(true);
    try{
      //Instantiate a PipedInputStream object
      PipedInputStream inStr = new PipedInputStream();
  
      //Instantiate a PipedOutputStream object and connect 
      // it to the existing PipedInputStream object
      PipedOutputStream pos = new PipedOutputStream(inStr);
  
      //Instantiate two thread objects
      SenderThread T1 = new SenderThread(pos );
      ReceiverThread T2 = new ReceiverThread(inStr );

      //And start the threads running  
      T1.start();
      T2.start();
    }catch(IOException e){}  
  }//end main()
  //-----------------------------------------------------//

  public void finalize(){
    System.out.println("Finalizing main thread");
  }//end finalize
  //-----------------------------------------------------//
}//end pipe01 class definition

/* File files02.java Copyright 1997, R.G.Baldwin
This application is a modification of the application named
files01.  The purpose is to illustrate the use of filtered
I/O classes to write and then read a file, one string at a
time.

Objects of types DataOutputStream and DataInputStream are 
instantiated using objects of types FileOutputStream and
FileInputStream as parameters to the constructor.  This 
makes all of the methods for objects of types 
DataOutputStream and DataInputStream available to write 
and read the file.

The program was tested using JDK 1.1.3 under Win95.

The output from the program is:

Start the program and write a file
Get info about, read, and print the file
Path is C:\BALDWIN\Java\SampProg\Java\junk.txt
Length 13
Dick
Baldwin
End of program
**********************************************************/

import java.io.*;

class files02{
  public static void main(String[] args)
  {
    System.out.println(
                    "Start the program and write a file");
    try{

      //Instantiate and initialize a DataOutputStream 
      // object using a FileOutputStream object as a 
      // parameter to the constructor. This makes it 
      // possible to write to the file using the methods
      // of the DataOutputStream class.
      DataOutputStream dataOut = 
        new DataOutputStream(
                        new FileOutputStream("junk.txt"));
  
      //Write two strings to the file and close it
      dataOut.writeBytes("Dick\n");
      dataOut.writeBytes("Baldwin\n");
      dataOut.close();
    }catch(IOException e){}

    System.out.println(
              "Get info about, read, and print the file");
  
    //Instantiate an object of type file containing the 
    // name of the file.  Same as app named files01.java.
    File junkFile = new File("junk.txt");
  
    //Use the File object to get info about the file. 
    // Same as files01.java.
    System.out.println(
                 "Path is " + junkFile.getAbsolutePath());
    System.out.println("Length " + junkFile.length() );
  
    //Now read and print the data in the file
    try{
      //Instantiate a DataInputStream object on the 
      // FileInputStream object which uses the File object
      // named junkFile to open the stream and link to 
      // the file.
            
      //Note that the compiler reports readLine() as a
      // deprecated method and suggests using methods 
      // from the reader class instead.
      
      DataInputStream inData = 
        new DataInputStream(new FileInputStream(junkFile));

      String data; //temp holding area
  
      //Read and print strings until eof is indicated by 
      // null.  
      while( (data = inData.readLine()) != null)
        System.out.println(data);
      inData.close();
    }catch(IOException e){}
    System.out.println("End of program");
  }// end main
}//end class files02 definition

/* File stream02.java
This application illustrates the use of a 
StringBufferInputStream object to read the contents of an
object of type String.

Note that even though this class is called 
StringBufferInputStream it does not read the contents of
objects of type StringBuffer.  Rather, the data source 
must be an object of type String.

The output from the program is:

Start the program and create a String object.
Create stream object of type StringBufferInputStream.
Read and display the contents of the String object.
This is an object of type String.
End of program
**********************************************************/
import java.io.*;
  
class stream02{//controlling class
  public static void main(String[] args)
  {
    System.out.println(
         "Start the program and create a String object.");
    String myString = "This is an object of type String.";
        
    System.out.println("Create stream object of type " +
                              "StringBufferInputStream.");
                              
    //Note that StringBufferInputStream is deprecated.  The
    // documentation recommends using the StringReader
    // class instead.
    StringBufferInputStream myStream = 
                    new StringBufferInputStream(myString);

    System.out.println("Read and display the contents " +
                                 "of the String object.");
          for(int cnt = 0; cnt < myString.length(); cnt++)
            System.out.print((char)myStream.read());
        
        System.out.println("\nEnd of program");
  }// end main
}//end class stream02 definition

/* File stream01.java Copyright 1997, R.G.Baldwin
This application illustrates the creation of custom filter
classes to filter I/O.  The classes can write objects of
type MyData to a disk file and read them back.

This application extends FilterOutputStream and 
FilterInputStream to implement the new filter classes.

The new filter output class named MyFilterOutputClass 
contains a method named MyWrite()

The MyWrite method accepts an input object of type MyData,
  converts it to a stream of bytes and writes them onto
  the disk using the write(int b) method of 
  FileOutputStream

The general contract for write is that one byte is written
  to the output stream. The byte to be written is the 
  eight low-order bits of the argument b which is an 
  integer. The 24 high-order bits of the integer b are 
  ignored.  

The individual bytes for the int data member named intData
  are selected and passed to the write() method by 
  shifting bits to the right 3 times, 8 bits per shift

This class does not override the write() method.  Rather,
  it provides a new MyWrite() method which makes use of 
  one form of the existing write() method.

The program was tested using JDK 1.1.3 under Win95.

The output from the program is:

Start the program and write an object to file
Read the object from the file and display it
The file contains X 123456789
End of program
**********************************************************/
import java.io.*;

class MyData{//data structure used for testing
  public char charData;
  public int intData;

  public MyData(){}//default constructor
  
  //parameterized constructor
  public MyData(char inChar, int inIntData){
    charData = inChar;
  intData = inIntData;
  }//end constructor
}//end class MyData definition
//=======================================================//

//This is a custom filter class for writing objects of
// type MyData into a file.
class MyFilterOutputClass extends FilterOutputStream{

  MyFilterOutputClass(FileOutputStream out) //constructor
  { super(out);} //pass the output object up the line
  
  //This is the new write method for objects
  void MyWrite(MyData obj){
    try{
      //write the character data member to the file
      write(obj.charData);
  
      //Now use bit shifting to decompose the integer 
      // data member into bytes and write them to the file
      for(int cnt = 0; cnt < 4; cnt++)
        write( (int) obj.intData  8*cnt);
    }catch(IOException e){}
  }//end write(MyData obj)
}//end MyFilterOutputClass definition
//=======================================================//

//This is a custom filter class for reading bytes from
// a file and constructing them into objects of type 
// MyData.
class MyFilterInputClass extends FilterInputStream{
  MyFilterInputClass(FileInputStream in) //constructor
  { super(in);} //pass the output object up the line

  //The following method reads bytes from a file and 
  // constructs an object of type MyData.  The object is
  // returned to the calling method.
  MyData MyRead(){
    MyData obj = new MyData();
    try{//read char data member from the file
      obj.charData = (char)read();
  
      //Now read bytes from the file and construct 
      // the integer data member
      for(int cnt = 0; cnt < 4; cnt++)
        obj.intData = obj.intData | 
                    ( (char)read()<< 8*cnt); //next 8 bits
    }catch(IOException e){}
    return obj; //return the constructed object
  }//end MyRead()
}//end MyFilterOutputClass definition
//=======================================================//
  
class stream01{//controlling class
  public static void main(String[] args){
    System.out.println(
          "Start the program and write an object to file");

    //Instantiate new type filter out obj linked to 
    // FileOutputStream
    try{
      MyFilterOutputClass fileOut = 
        new MyFilterOutputClass( 
                        new FileOutputStream("junk.txt") );
    
      //Construct an object of type MyData
      MyData myObject = new MyData('X',123456789);
    
      //Use new type filter method to write the object 
      // to the file
      fileOut.MyWrite(myObject);
      fileOut.close();
    }catch(IOException e){}

    System.out.println(
           "Read the object from the file and display it");
    //Instantiate new type filter inp obj linked to 
    // FileInputStream
    try{
      MyFilterInputClass fileIn = 
        new MyFilterInputClass( 
                         new FileInputStream("junk.txt") );
    
      //Use new filter method to read object from file
      MyData inData = fileIn.MyRead();
      fileIn.close();
  
      //Display the contents of the object
      System.out.println("The file contains " + 
                   inData.charData + " " + inData.intData);
    }catch(IOException e){}

    System.out.println("End of program");
  }// end main
}//end class stream01 definition

new RandomAccessFile(name, mode)

/* File files03.java Copyright 1997, R.G.Baldwin
This application is a modification of the application 
named files02.  The purpose is to illustrate the use of 
the RandomFileAccess class to read and write data interior 
to the file.

Tested using JDK 1.1.3 under Win95

The output from the program is:

Start the program and write a file
Now open and read the file in random access mode
Display the entire file as characters.
Dick
Baldwin
Now display four bytes interior to the file.
Bald
Now write four bytes interior to the file.
Now display the entire file again.
Note that four bytes have been overwritten.
Dick
WXYZwin

End of program
**********************************************************/

import java.io.*;

class files03{
  public static void main(String[] args)
  {
    System.out.println(
                     "Start the program and write a file");
    try{

      //Instantiate and initialize a DataOutputStream 
      // object using a FileOutputStream object as a 
      // parameter to the constructor. This makes it 
      // possible to write to the file using the methods
      // of the DataOutputStream class.  This is a 
      // sequential stream operation and NOT a random 
      // access operation.
      DataOutputStream dataOut = new DataOutputStream(
                         new FileOutputStream("junk.txt"));
  
      //Write two strings to the file and close it
      dataOut.writeBytes("Dick\n");
      dataOut.writeBytes("Baldwin\n");
      dataOut.close();
    }catch(IOException e){}

    //Instantiate an object of type file containing the 
    // name of the file to illustrate the use of File 
    // objects in instantiating an object later of type 
    // RandomAccessFile
    File junkFile = new File("junk.txt");
  
    System.out.println(
       "Now open and read the file in random access mode");
    try{
      //Instantiate a RandomAccesSfile object for reading 
      // and writing using the File object named junkFile
      // to open and link to the file.
      RandomAccessFile inData = 
                       new RandomAccessFile(junkFile,"rw");
      int temp;

      System.out.println(
                 "Display the entire file as characters.");
      //Note that the file pointer is initially at the 
      // beginning of the file.
      while( (temp = inData.read()) != -1)
        System.out.print((char)temp);
  
      System.out.println(
           "Now display four bytes interior to the file.");
      //Get current location of the file pointer.
      long filePointer = inData.getFilePointer();
  
      //Set the file pointer to a location interior to 
      // the file.
      inData.seek(filePointer-8);
  
      //Now read and display four bytes.
      for(int cnt = 0; cnt < 4; cnt++)
        System.out.print( (char)inData.read() );
  
      System.out.println(
           "\nNow write four bytes interior to the file.");
      filePointer = inData.getFilePointer();
      inData.seek(filePointer-4);
      for(int cnt = 0; cnt < 4; cnt++)
        inData.write('W'+cnt);
  
      System.out.println(
                     "Now display the entire file again.");
      System.out.println(
            "Note that four bytes have been overwritten.");
      //Note that it is necessary to reposition the file 
      // pointer to the beginning of the file.
      inData.seek(0);
      while( (temp = inData.read()) != -1)
        System.out.print((char)temp);
  
      inData.close();
    }catch(IOException e){}
    System.out.println("\nEnd of program");
  }// end main
}//end class files03 definition

/* File files04.java Copyright 1998, R.G.Baldwin
This program is an upgrade to the program named
files02.  The purpose is to convert the original program
that used byte streams for input and output to one that
uses unicode character streams for input and output.

To understand the differences, you should compare the
code in this program with the code in files02.java.

Some of the code in the original program had nothing to
do with the difference between byte streams and character
streams, so that code was omitted from this version.

The output from the program is:

Start the program and write a file
Read and print the file
Dick
Baldwin
End of program


The program was tested using JDK 1.1.6 under Win95.
**********************************************************/

import java.io.*;

class files04{
  public static void main(String[] args)
  {
    System.out.println(
                    "Start the program and write a file");
    try{
      //Open an output character stream using the Writer
      // classes.
      PrintWriter dataOut = 
         new PrintWriter(new FileWriter("junk.txt"),true);

      dataOut.println("Dick");
      dataOut.println("Baldwin");
  
      dataOut.close();

      System.out.println("Read and print the file");
      //Open an input character stream using the Reader
      // classes.
      BufferedReader inData = 
           new BufferedReader(new FileReader("junk.txt"));

      String data; //temp holding area
      while( (data = inData.readLine()) != null)
        System.out.println(data);
      inData.close();
    }catch(IOException e){}
    System.out.println("End of program");
  }// end main
}//end class files04 definition

Start the program and write a file
Read, and display the file
Dick
End of program

/* File SampProg110.java from lesson 60
Copyright 1997, R.G. Baldwin
Without viewing the solution which follows, write a Java
application that illustrates writing and then reading a 
file one byte at a time.

=========================================================//
*/
import java.io.*;

class SampProg110{
  public static void main(String[] args){
    System.out.println(
    "Start the program and write a file");
    try{
      //Instantiate and initialize an output file stream 
      // object using a literal string containing the name
      // of the file.
      FileOutputStream outFile = new FileOutputStream(
        "junk.txt");
        
      //Write four bytes in the file and close it
      outFile.write('D');
      outFile.write('i');
      outFile.write('c');
      outFile.write('k');
      outFile.close();
    }catch(IOException e){}
    
    System.out.println("Read, and display the file");  
      
    //Now read and print the data in the file
    try{
      FileInputStream inFile = new FileInputStream(
        "junk.txt");
      int data;
        
      //Read and print until eof indicated by -1.  read() 
      // method returns integer.  Must cast as char to 
      // print. Otherwise, the numeric value of the byte 
      // is displayed.
      while( (data = inFile.read()) != -1)
        System.out.print((char)data);
      inFile.close();
    }catch(IOException e){}
    System.out.println();//new line
    System.out.println("End of program");
  }// end main
}//end class SampProg110 definition

Start the program and write a file
Get info about, read, and print the file
Path is C:\BALDWIN\Cis2103K\Fall97\SampProg\junk.txt
Length 5
65 66 67 68 69 
End of program

/* File SampProg111.java from lesson 60
Copyright 1997, R.G.Baldwin
Without viewing the solution that follows, write a Java
application that illustrates writing and then reading a 
file one byte at a time.

=========================================================//
*/

import java.io.*;

class SampProg111{
  public static void main(String[] args)
  {
    System.out.println(
                     "Start the program and write a file");
    //Instantiate an object of type File
    File fileObj = new File("junk.txt");
        
    try{
      //Instantiate and initialize the stream object 
      // using the File object.
      FileOutputStream outFile = 
        new FileOutputStream(fileObj);
    
      //Write five bytes to the file and close it
      outFile.write('A');
      outFile.write('B');
      outFile.write('C');
      outFile.write('D');
      outFile.write('E');
      outFile.close();
    }catch(IOException e){}

    System.out.println(
      "Get info about, read, and print the file");  
    
    //Use the File object to get info about the file
    System.out.println("Path is " 
      + fileObj.getAbsolutePath());
    System.out.println("Length " + fileObj.length() );
  
    //Now read and print the data in the file
    try{
      //Instantiate and initialize the stream object 
      // using the File object.
      FileInputStream inFile = 
                              new FileInputStream(fileObj);
      int data;
  
      //Read and print until eof indicated by -1.  
      // read() method returns integer.  
      while( (data = inFile.read()) != -1)
        System.out.print(data + " ");
      inFile.close();
    }catch(IOException e){}
    System.out.println(); //new line
    System.out.println("End of program");
  }// end main
}//end class SampProg111 definition

Starting ReceiverThread 
Starting SenderThread 
Received: Dick Baldwin 
ReceiverThread done 

/* File SampProg112.java from lesson 60
Copyright 1997, R.G.Baldwin

Without viewing the following solution, write a Java
application that illustrates the piping of the output from 
one thread to the input of another thread.
=========================================================//
*/
import java.io.*;

class SenderThread extends Thread{
  PipedOutputStream pos; //ref to piped output stream obj
  String msgToSend = "Dick Baldwin";

  public SenderThread(PipedOutputStream posIn){
    pos = posIn; //save ref to piped output stream object
  }//end SenderThread constructor

  public void run(){ //override run method
    System.out.println("Starting SenderThread");
    try{
      for( int i = 0; i < msgToSend.length(); i++){
        //write a character to the piped output stream
        pos.write(msgToSend.charAt(i)); 
      }//end for loop
    }catch(IOException e){}
    //SenderThread has finished its task here
  }//end run() method
}//end SenderThread class definition

class ReceiverThread extends Thread{
  //ref to piped input stream obj
  PipedInputStream inputStr; 
  int inData = 0; //working variable
  
  public ReceiverThread(PipedInputStream inStr){
    inputStr = inStr; //save ref to piped input stream obj
  }//end ReceiverThread constructor

  public void run(){ //override run method
    System.out.println("Starting ReceiverThread");
    try{
      //read the first character as an integer
      inData = inputStr.read();
      System.out.print("Received: " + (char)inData);
      //read until integer -1 signals no more data
      while (inData != -1){ 
        //read next char as an integer
        inData = inputStr.read();
        System.out.print((char)inData);//display it
      }//end while loop
    }catch(IOException e){}
    System.out.println();//new line
    System.out.println("ReceiverThread done");
  }//end run() method
}//end ReceiverThread class definition


class SampProg112{ //controlling class
  public static void main(String[] args){
    try{
      //Instantiate a PipedInputStream object
      PipedInputStream inStr = new PipedInputStream();
  
      //Instantiate a PipedOutputStream object and connect 
      // it to the existing PipedInputStream object
      PipedOutputStream pos = new PipedOutputStream(inStr);
  
      //Instantiate two thread objects
      SenderThread T1 = new SenderThread(pos );
      ReceiverThread T2 = new ReceiverThread(inStr );

      //And start the threads running  
      T2.start();
      T1.start();
    }catch(IOException e){}  
  }//end main()
}//end SampProg112 class definition

Start the program and write a file 
Read, and print the file 
Double: 3.14159 
Long: 1234 
Character: X 
End of program

/* File SampProg113.java from lesson 60
Copyright 1997, R.G.Baldwin

Without viewing the solution that follows, write a Java
application that writes a double, a long, and a character
to a file and then reads the file and displays the data.
=========================================================//
*/

import java.io.*;

class SampProg113{
  public static void main(String[] args)
  {
    System.out.println(
      "Start the program and write a file");
    try{

      //Instantiate and initialize a DataOutputStream 
      // object using a FileOutputStream object as a 
      // parameter to the constructor. This makes it 
      // possible to write to the file using the
      // methods of the DataOutputStream class.
      DataOutputStream dataOut = 
        new DataOutputStream(
          new FileOutputStream("junk.txt"));

      //Write a double, a long, and a character to the file
      dataOut.writeDouble(3.14159);
      dataOut.writeLong(1234);
      dataOut.writeChar('X');
    }catch(IOException e){}

    System.out.println("Read, and print the file");  
  
    //Now read and print the data in the file
    try{
      //Instantiate a DataInputStream object on the 
      // FileInputStream object
      DataInputStream inData = 
        new DataInputStream(
          new FileInputStream("junk.txt"));
    
      //Read and print a double, a long, and a character
      System.out.println("Double: " + inData.readDouble());
      System.out.println("Long: " + inData.readLong());
      System.out.println("Character: " + inData.readChar());
      inData.close();
    }catch(IOException e){}
    System.out.println("End of program");
  }// end main
}//end class SampProg113 definition

Write formatted data to a ByteArrayOutputStream object 
Read and display formatted data from the byte array 
Double: 3.14159 
Long: 1234 
Character: X 
End of program 

/* File SampProg114.java from lesson 60
Copyright 1997, R.G.Baldwin

This application illustrates the use of 
ByteArrayOutputStream and ByteArrayInputStream in 
conjunction with filtered I/O classes to write and then
read formatted data of specific mixed types into an array
of bytes in memory.

An object of type DataOutputStream is instantiated using
an object of type ByteArrayOutputStream as a parameter to
the constructor.  This makes all of the methods for objects
of type DataOutputStream available to write formatted data
into the memory represented by the ByteArrayOutputStream 
object.

A double, a long, and a character are written to the 
ByteArrayOutputStream object.

Then, an ordinary byte array is extracted from the
ByteArrayOutputStream object which contains the bytes
representing the double, the long, and the character.

This byte array is passed to a ByteArrayInputStream
constructor creating an object that is passed in turn to
a DataInputStream object.  This makes all of the methods
for objects of type DataInputStream available to read data
from the memory represented by the ByteArrayInputStream
object.

The double, long, and character data are read and 
displayed.

The output from the program should be similar to the 
following:
  
Write formatted data to a ByteArrayOutputStream object
Read and display formatted data from the byte array
Double: 3.14159
Long: 1234
Character: X
End of program
===========================================================
*/

import java.io.*;

class SampProg114{
  public static void main(String[] args)
  {
    System.out.println(
      "Write formatted data to a " 
        + "ByteArrayOutputStream object");
    //Instantiate the ByteArrayOutputStream object
    ByteArrayOutputStream myByteArrayOutputStream = 
      new ByteArrayOutputStream();
    try{
      //Instantiate and initialize a DataOutputStream 
      // object using the ByteArrayOutputStream object as a
      // parameter to the constructor. This makes it 
      // possible to write to the ByteArrayOutputStream 
      // object using the methods of the DataOutputStream 
      // class.
      DataOutputStream dataOut = 
        new DataOutputStream(myByteArrayOutputStream);

      //Write a double, a long, and a character to 
      // the ByteArrayOutputStream object  
      dataOut.writeDouble(3.14159);
      dataOut.writeLong(1234);
      dataOut.writeChar('X');
    }catch(IOException e){}
    
    //Extract an ordinary byte array from the 
    // ByteArrayOutputStream object to use below.
    byte[] myByteArray = 
      myByteArrayOutputStream.toByteArray();

    System.out.println(
     "Read and display formatted data from the byte array");
  
    try{
      //Instantiate a DataInputStream object on a 
      // ByteArrayInputStream object linked to the
      // ordinary byte array.  This makes it possible to
      // use the methods of the DataInputStream class to
      // read formatted data from the byte array.
      DataInputStream inData = 
        new DataInputStream(
          new ByteArrayInputStream(myByteArray));
    
      //Read and display a double, a long, and a character
      // from the byte array.
      System.out.println("Double: " + inData.readDouble());
      System.out.println("Long: " + inData.readLong());
      System.out.println("Character: " + inData.readChar());
      inData.close();
    }catch(IOException e){}
    
    System.out.println("End of program");
  }// end main
}//end class SampProg114 definition

Start the program and write an object to file 
Read the object from the file and display it 
The file contains First String 
End of program 

/* File SampProg115.java from lesson 60

Copyright 1997, R.G.Baldwin

This application illustrates the creation of custom filter
classes to filter I/O.  The two custom filter classes can 
write objects of type MyData to a disk file and read them 
back.

This application extends FilterOutputStream and 
FilterInputStream to implement the new filter classes.

The new filter output class named MyFilterOutputClass 
contains a method named MyWrite()

The MyWrite method accepts an input object of type MyData,
converts it to a stream of bytes and writes them onto the
disk.

The output from this program should be similar to the
following:
  
Start the program and write an object to file
Read the object from the file and display it
The file contains First String
End of program  
===========================================================
*/
import java.io.*;

class MyData{//data structure used for testing
  public String firstString = "First String";
}//end class MyData definition
//=========================================================

//This is a custom filter class for writing objects of
// type MyData into a file.
class MyFilterOutputClass extends FilterOutputStream{
  MyFilterOutputClass(FileOutputStream out) //constructor
  { super(out);} //invoke superclass constructor
  
  //This is the new write method for objects
  void MyWrite(MyData obj){
    try{
      //write the string as a byte array     
      write(obj.firstString.getBytes());
    }catch(IOException e){}
  }//end write(MyData obj)
}//end MyFilterOutputClass definition
//=========================================================

//This is a custom filter class for reading bytes from
// a file and constructing them into an object 
// of type MyData.
class MyFilterInputClass extends FilterInputStream{
  MyFilterInputClass(FileInputStream in) //constructor
  { super(in);} //invoke superclass constructor

  //This is the new read method for objects. This method 
  // reads bytes from a file and constructs an object of 
  // type MyData.  The object is returned to the calling 
  // function.
  MyData MyRead(){
    MyData obj = new MyData();//construct empty object
    //Try to populate it by reading bytes and converting
    // them into a string.
    try{
      byte[] tempByteArray = new byte[40];
      in.read(tempByteArray);
      obj.firstString = new String(tempByteArray);
    }catch(IOException e){}
    return obj; //return the constructed object
  }//end MyRead()
}//end MyFilterOutputClass definition
//=========================================================
 
class SampProg115{//controlling class
  public static void main(String[] args){//main method
    System.out.println(
      "Start the program and write an object to file");
    
    //Instantiate new type filtered output obj linked to 
    // FileOutputStream
    try{
      MyFilterOutputClass fileOut = 
        new MyFilterOutputClass(
          new FileOutputStream("junk.txt") );
      
      //Construct an object of type MyData
      MyData myObject = new MyData();
      
      //Use new type filter method to write the object 
      // to the file
      fileOut.MyWrite(myObject);
      fileOut.close();
    }catch(IOException e){}

    System.out.println(
      "Read the object from the file and display it");
    //Instantiate new type filter input obj linked 
    // to FileInputStream
    try{
      MyFilterInputClass fileIn = 
        new MyFilterInputClass(
          new FileInputStream("junk.txt") );
      
      //Use new filter method to read object from file
      MyData inData = fileIn.MyRead();
      fileIn.close();
    
      //Display the contents of the object
      System.out.println("The file contains " 
        + inData.firstString);
    }catch(IOException e){}

    System.out.println("End of program");
    
  }// end main
}//end class SampProg115 definition

Start the program and write a file in sequential mode 
Now open and read the file in random access mode 
Display the entire file as characters. 
First String 
Second String 
Now display four bytes interior to the file. 
nd S 
Now write four bytes interior to the file. 
Now display the entire file again. 
Note that four bytes have been overwritten. 
First String 
SecoABCDtring

/* File SampProg116.java from lesson 60
Copyright 1997, R.G.Baldwin

First write a file containing two strings in sequential
mode and close the file.

Then open and display all the bytes in the file in random
access mode.

Then display four bytes interior to the file.

The modify the same four bytes interior to the file and 
display them again.

The output from the program should be similar to the
following:

Start the program and write a file in sequential mode
Now open and read the file in random access mode
Display the entire file as characters.
First String
Second String
Now display four bytes interior to the file.
nd S
Now write four bytes interior to the file.
Now display the entire file again.
Note that four bytes have been overwritten.
First String
SecoABCDtring

End of program
===========================================================
*/

import java.io.*;

class SampProg116{
  public static void main(String[] args)
  {
    System.out.println(
      "Start the program and write a file in " 
        + "sequential mode");
    try{
      //Instantiate and initialize a DataOutputStream 
      // object using a FileOutputStream object as a 
      // parameter to the constructor. 
      DataOutputStream dataOut = 
        new DataOutputStream(
          new FileOutputStream("junk.txt"));
    
      //Write two strings to the file and close it
      dataOut.writeBytes("First String\n");
      dataOut.writeBytes("Second String\n");
      dataOut.close();
    }catch(IOException e){}

    System.out.println(
      "Now open and read the file in random access mode");
    try{
      //Instantiate a RandomAccesSfile object for reading 
      // and writing and link it to the file that was
      // created above.
      RandomAccessFile inData = 
        new RandomAccessFile("junk.txt","rw");
      int temp;
  
      System.out.println(
        "Display the entire file as characters.");
      //Note that the file pointer is initially at the 
      // beginning of the file.
      while( (temp = inData.read()) != -1)
        System.out.print((char)temp);
    
      System.out.println(
        "Now display four bytes interior to the file.");
      //Get current location of the file pointer.
      long filePointer = inData.getFilePointer();
    
      //Set the file pointer to a location interior 
      // to the file.
      inData.seek(filePointer - 10);
    
      //Now read and display four bytes.
      for(int cnt = 0; cnt < 4; cnt++)
        System.out.print( (char)inData.read() );
    
      System.out.println(
        "\nNow write four bytes interior to the file.");
      filePointer = inData.getFilePointer();
      inData.seek(filePointer - 4);

      for(int cnt = 0; cnt < 4; cnt++)
        inData.write('A'+cnt);
    
      System.out.println(
        "Now display the entire file again.");
      System.out.println(
        "Note that four bytes have been overwritten.");
      //Note that it is necessary to reposition the 
      // file pointer to the beginning of the file.
      inData.seek(0);

      while( (temp = inData.read()) != -1)
        System.out.print((char)temp);
    
      inData.close();
    }catch(IOException e){}
    System.out.println("\nEnd of program");
  }// end main
}//end class SampProg116 definition

/* File SampProg151.java Copyright 1997, R.G.Baldwin
From lesson 60.

Without viewing the solution that follows, write a Java
application that replicates the program named files02.java
but doesn't use deprecated methods.

This application is a modification of the application named
files01.  The purpose is to illustrate the use of filtered
I/O classes to write and then read a file, one string at a
time.

The program was tested using JDK 1.1.3 under Win95.

The output from the program is:

Start the program and write a file
Get info about, read, and print the file
Path is C:\BALDWIN\Java\SampProg\Java\junk.txt
Length 13
Dick
Baldwin
End of program
**********************************************************/

import java.io.*;

class SampProg151{
  public static void main(String[] args)
  {
    System.out.println(
                    "Start the program and write a file");
    try{

      //Instantiate and initialize a DataOutputStream 
      // object using a FileOutputStream object as a 
      // parameter to the constructor. This makes it 
      // possible to write to the file using the methods
      // of the DataOutputStream class.
      DataOutputStream dataOut = 
        new DataOutputStream(
                        new FileOutputStream("junk.txt"));
  
      //Write two strings to the file and close it
      dataOut.writeBytes("Dick\n");
      dataOut.writeBytes("Baldwin\n");
      dataOut.close();
    }catch(IOException e){}

    System.out.println(
              "Get info about, read, and print the file");
  
    //Instantiate an object of type file containing the 
    // name of the file.  Same as app named files01.java.
    File junkFile = new File("junk.txt");
  
    //Use the File object to get info about the file. 
    // Same as files01.java.
    System.out.println(
                 "Path is " + junkFile.getAbsolutePath());
    System.out.println("Length " + junkFile.length() );
  
    //Now read and print the data in the file
    try{
      //Instantiate a BufferedReader object on the 
      // FileReader object which uses the File object
      // named junkFile to open the stream and link to 
      // the file.
            
      /*The following note was extracted from the JDK 1.1.3
      documentation:
      Note: readLine() is deprecated. This method does not
      properly convert bytes to characters. As of 
      JDK 1.1, the preferred way to read lines of text is 
      via the BufferedReader.readLine() method. Programs 
      that use the DataInputStream class to read lines can
      be converted to use the BufferedReader class by 
      replacing code of the form
      
          DataInputStream d = new DataInputStream(in); 
      with 
          BufferedReader d
            = new BufferedReader(
              new InputStreamReader(in)); 
      */
      BufferedReader inData =
        new BufferedReader(new FileReader(junkFile));

      String data; //temp holding area
  
      //Read and print strings until eof is indicated by 
      // null.  
      while( (data = inData.readLine()) != null)
        System.out.println(data);
      inData.close();
    }catch(IOException e){}
    System.out.println("End of program");
  }// end main
}//end class SampProg151 definition

/* File SampProg152.java Copyright 1998, R.G.Baldwin
From lesson 60

Without viewing the solution that follows, write a Java
application that replicates the program named Stream02.java
but that does not use deprecated methods.

This application illustrates the use of a StringReader 
object to read the contents of an object of type String.

The output from the program is:

Start the program and create a String object.
Create stream object of type StringReader.
Read and display the contents of the String object.
This is an object of type String.
End of program
**********************************************************/
import java.io.*;
  
class SampProg152{//controlling class
  public static void main(String[] args)
  {
    System.out.println(
         "Start the program and create a String object.");
    String myString = "This is an object of type String.";
        
    System.out.println("Create stream object of type " +
                              "StringReader.");
                              
    //Note that StringBufferInputStream is deprecated.  The
    // documentation recommends using the StringReader
    // class instead.
    StringReader myStream = 
                    new StringReader(myString);

    System.out.println("Read and display the contents " +
                                 "of the String object.");
    try{
            for(int cnt = 0; cnt < myString.length(); cnt++)
              System.out.print((char)myStream.read());
    }catch(IOException e){}
        
        System.out.println("\nEnd of program");
  }// end main
}//end class SampProg152 definition

/*File SampProg155.java Copyright 1998, R.G.Baldwin
From lesson 60

Without viewing the solution that follows, write a Java
application that uses the new "reader" classes to read
lines of text from the keyboard and display the text
on the screen.  A line of text is terminated by pressing
the Enter key.

Continue reading and displaying lines until the user
enters "quit".

The program was tested using JDK 1.1.3 running under Win95.
**********************************************************/

import java.io.*;
//=======================================================//

public class SampProg155 {
  public static void main(String[] args){
    System.out.println(
           "Enter lines of text and they will be echoed");
    System.out.println("Enter the word quit to quit.");
    try{
      while(true){
        InputStreamReader is = 
                         new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(is);
        String s = br.readLine();
        if(s.compareTo("quit") == 0)break;
        System.out.println(s);
      }//end while
    }catch(IOException e){}
    System.out.println("Program terminated");
  }//end main
}//end class SampProg155
//=======================================================//

/*File SampProg156.java
Copyright (c) Peter van der Linden,  May 5 1997.

Without viewing the solution that follows, write a Java
application that can read strings and all of the
primitive Java types from the keyboard.

This program was tested using JDK 1.1.3 under Win95.
I found it to experience intermittent problems when
used with JDK 1.1.3 under Win95.  I am assuming that
these intermittent problems will disappear when used
with a later version of the JDK. - rgb.

**********************************************************/
import java.util.*;
import java.io.*;
//=======================================================//

class SampProg156{
  public static void main(String[] args){
    EasyIn easy = new EasyIn();

    String myString;
    int myInt;
    
    System.out.println(
                "Enter a string");
    myString = easy.readString();
    System.out.println("Echo: " + myString);        
      
    System.out.println("Enter an int");
    myInt = easy.readInt();
    System.out.println("Echo: " + myInt);
    
    System.out.println("Terminating program");
        
  }//end main
}//end class SampProg156
//=======================================================//

// Simple input from the keyboard for all primitive types.
// Copyright (c) Peter van der Linden,  May 5 1997.
// Feel free to use this in your programs, as long as this
// comment stays intact.
//
// This is not thread safe, not high performance, and 
// doesn't tell EOF.
// It's intended for low-volume easy keyboard input.
// An example of use is:
//     EasyIn easy = new EasyIn();
//     int i = easy.readInt();   
// reads an int from System.in
// See Just Java and Beyond, Third Edition by Peter
// van der Linden


class EasyIn {    
  static InputStreamReader is = 
                       new InputStreamReader( System.in );
  static BufferedReader br = new BufferedReader( is );
  StringTokenizer st;

  StringTokenizer getToken() throws IOException {
    String s = br.readLine();
    return new StringTokenizer(s);
  }//end getToken()
    
  boolean readBoolean() {
    try {
      st = getToken();
      return new Boolean(st.nextToken()).booleanValue();
    }catch (IOException ioe) {
      System.err.println(
                    "IO Exception in EasyIn.readBoolean");
      return false;
    }//end catch
  }//end readBoolean()

  byte readByte(){
    try {
      st = getToken();
      return Byte.parseByte(st.nextToken());
    }catch (IOException ioe) {
      System.err.println(
                       "IO Exception in EasyIn.readByte");
      return 0;
    }//end catch
  }//end readByte()

  short readShort(){
    try {
      st = getToken();
      return Short.parseShort(st.nextToken());
    }catch (IOException ioe) {
      System.err.println(
                      "IO Exception in EasyIn.readShort");
      return 0;
    }//end catch
  }//end readShort()
    
  int readInt(){
    try {
      st = getToken();
      return Integer.parseInt(st.nextToken());
    }catch (IOException ioe) {
      System.err.println("IO Exception in EasyIn.readInt");
      return 0;
    }//end catch
  }//end readInt()

  long readLong(){
    try {
      st = getToken();
      return Long.parseLong(st.nextToken());
    }catch (IOException ioe) {
      System.err.println(
                      "IO Exception in EasyIn.readFloat");
      return 0L;
    }//end catch
  }//end readLong()

  float readFloat() {
    try {
      st = getToken();
      return new Float(st.nextToken()).floatValue();
    }catch (IOException ioe) {
      System.err.println(
                      "IO Exception in EasyIn.readFloat");
      return 0.0F;
    }//end catch
  }//end readFloat()

  double readDouble() {
    try {
      st = getToken();
      return new Double(st.nextToken()).doubleValue();
    }catch (IOException ioe) {
      System.err.println(
                     "IO Exception in EasyIn.readDouble");
      return 0.0;
    }//end catch
  }//end readDouble()

  char readChar() {
    try {
      String s = br.readLine();
      return s.charAt(0);
    }catch (IOException ioe) {
      System.err.println(
                       "IO Exception in EasyIn.readChar");
      return 0;
    }//end catch
  }//end readChar()

  String readString() {
    try {
      return br.readLine();
    }catch (IOException ioe) {
      System.err.println(
                     "IO Exception in EasyIn.readString");
      return "";
    }//end catch
  }//end readString
}//end class definition
//=======================================================//