• boolean readBoolean()
• byte readByte()
• char readChar()
• double readDouble()
• float readFloat()
• int readInt()
• long readLong()
• short readShort()

• writeBoolean(boolean v)
• writeByte(int v)
• writeChar(int v)
• writeDouble(double v)
• writeFloat(float v)
• writeInt(int v)
• writeLong(long v)
• writeShort(int v)

• Complications when using the console
• Complications caused by byte ordering

The Following Seems Fine

javaexamples/streams/DataWriter.java

        import java.io.*;

/**
 * An example of value-type I/O 
 * (that might not behave as expected)
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class DataWriter
{

    /**
     * The entry point
     *
     * @param args   The command-line arguments
     */
    public static void main(String[] args) throws Exception
    {
       DataOutputStream    out;
       double              d;
       int                 i;


       i = 97;
       d = 97.0;

       out = new DataOutputStream(System.out);
       out.writeInt(i);
       out.writeChar('|');

       out.writeDouble(d);
       out.writeChar('|');

       out.flush();
    }

}
        

• Why does the int 97 become ' a'?
• Why does the double 97 become '@X@ '?

The Following Also Seems Fine

javaexamples/streams/DataReader.java

        import java.io.*;

/**
 * An example of value-type I/O 
 * (that might not behave as expected)
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class DataReader
{

    /**
     * The entry point
     *
     * @param args   The command-line arguments
     */
    public static void main(String[] args) throws Exception
    {
       DataInputStream     in;
       double              d;
       int                 i;
       
       
       in = new DataInputStream(System.in);
       System.out.print("\nEnter an int: ");
       i = in.readInt();
       System.out.println("\nYou entered "+i);
       
       System.out.print("\nEnter a double: ");
       d = in.readDouble();
       System.out.println("\nYou entered "+d);
    }

}
        

• Try typing a 1-digit int (terminated by a CR+LF)
• Try typing a 2-digit int (terminated by a CR+LF)
• Try typing a 1-digit double (terminated by a CR+LF)
• Try typing a 6-digit double (terminated by a CR+LF)

Using one byte to represent unsigned integers is straightforward. For example, using the usual conventions, the decimal number 26 can be represented as follows:

  00011010
  

Using two bytes to represent unsigned integers is a little trickier. For example, which of the following is the correct representation of the number 256?

  00000001 00000000
  

Most significant byte first (Big-endian or network byte order)

or

  00000000 00000001
  

Least significant byte first (Little-endian)

• A "Real-World" Examples: Dates
  • 7/4/1776
  • July 4 1776
  • 4 July 1776
  • 1776 July 4
• Doesn't the Same Issue Arise with Strings?
  • ASCII uses one byte
  • EBCDIC is a different one-byte system
  • Unicode uses two/four bytes (depending on the encoding) in a fixed order

• Use a mask to "extract" a particular byte
• Use bit-shifting to "move" a byte
• "Combine" the bytes

To "extract" the LSB:

        01100001 00011010
  &     00000000 11111111
        _________________
        00000000 00011010
  

That is, perform a bitwise AND with the decimal number 255 (or 0x00FF).

To "extract" the MSB:

        01100001 00011010
  &     11111111 00000000 
        _________________
        01100001 00000000
  

That is, perform a bitwise AND with the decimal number 65280 (or 0xFF00).

Shifting Bits:

        00000011 00000000 
   >>   8
        _________________
        00000000 00000011
  

That is, 768 >> 8 evaluates to 3.

Combining Bytes:

        00000011 00000000 
      | 00000000 00000001
        _________________
        00000011 00000001
  

That is, 768 | 1 evaluates to 769.

• Java:
  • Uses network byte order (i.e., big-endian) on all platforms
• C/C++:
  • Do not specify a byte order and typically use whatever the platform uses (e.g., big-endian on Unix, little-endian on MS-DOS)

javaexamples/streams/DataWriter.java

        import java.io.*;

/**
 * An example of value-type I/O 
 * (that might not behave as expected)
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class DataWriter
{

    /**
     * The entry point
     *
     * @param args   The command-line arguments
     */
    public static void main(String[] args) throws Exception
    {
       DataOutputStream    out;
       double              d;
       int                 i;


       i = 97;
       d = 97.0;

       out = new DataOutputStream(System.out);
       out.writeInt(i);
       out.writeChar('|');

       out.writeDouble(d);
       out.writeChar('|');

       out.flush();
    }

}
        

What will be printed if we assign 97 + (65 << 8) to i?