• 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

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

The Following Also Seems Fine

javaexamples/streams/DataReader.java

• 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

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