Module java.base
Package java.io

## Interface DataOutput

- All Known Subinterfaces:
    `ImageOutputStream`, `ObjectOutput`
  All Known Implementing Classes:
    `DataOutputStream`, `FileCacheImageOutputStream`, `FileImageOutputStream`, `ImageOutputStreamImpl`, `MemoryCacheImageOutputStream`, `ObjectOutputStream`, `RandomAccessFile`

      public interface DataOutput

  The `DataOutput` interface provides for converting data from any of the Java primitive types to a series of bytes and writing these bytes to a binary stream. There is also a facility for converting a `String` into modified UTF-8 format and writing the resulting series of bytes.

  For all the methods in this interface that write bytes, it is generally true that if a byte cannot be written for any reason, an `IOException` is thrown.

  Since:
    1.0
  See Also:
    `DataInput`, `DataOutputStream`

- - ### Method Summary

    All Methods Instance Methods Abstract Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `void` | `write​(byte[] b)` | Writes to the output stream all the bytes in array `b`.
    `void` | `write​(byte[] b, int off, int len)` | Writes `len` bytes from array `b`, in order, to the output stream.
    `void` | `write​(int b)` | Writes to the output stream the eight low-order bits of the argument `b`.
    `void` | `writeBoolean​(boolean v)` | Writes a `boolean` value to this output stream.
    `void` | `writeByte​(int v)` | Writes to the output stream the eight low- order bits of the argument `v`.
    `void` | `writeBytes​(String s)` | Writes a string to the output stream.
    `void` | `writeChar​(int v)` | Writes a `char` value, which is comprised of two bytes, to the output stream.
    `void` | `writeChars​(String s)` | Writes every character in the string `s`, to the output stream, in order, two bytes per character.
    `void` | `writeDouble​(double v)` | Writes a `double` value, which is comprised of eight bytes, to the output stream.
    `void` | `writeFloat​(float v)` | Writes a `float` value, which is comprised of four bytes, to the output stream.
    `void` | `writeInt​(int v)` | Writes an `int` value, which is comprised of four bytes, to the output stream.
    `void` | `writeLong​(long v)` | Writes a `long` value, which is comprised of eight bytes, to the output stream.
    `void` | `writeShort​(int v)` | Writes two bytes to the output stream to represent the value of the argument.
    `void` | `writeUTF​(String s)` | Writes two bytes of length information to the output stream, followed by the modified UTF-8 representation of every character in the string `s`.

- - ### Method Detail

    - #### write

          void write​(int b)
              throws IOException

      Writes to the output stream the eight low-order bits of the argument `b`. The 24 high-order bits of `b` are ignored.
      Parameters:
        `b` - the byte to be written.
      Throws:
        `IOException` - if an I/O error occurs.

    - #### write

          void write​(byte[] b)
              throws IOException

      Writes to the output stream all the bytes in array `b`. If `b` is `null`, a `NullPointerException` is thrown. If `b.length` is zero, then no bytes are written. Otherwise, the byte `b[0]` is written first, then `b[1]`, and so on; the last byte written is `b[b.length-1]`.
      Parameters:
        `b` - the data.
      Throws:
        `IOException` - if an I/O error occurs.

    - #### write

          void write​(byte[] b,
                     int off,
                     int len)
              throws IOException

      Writes `len` bytes from array `b`, in order, to the output stream. If `b` is `null`, a `NullPointerException` is thrown. If `off` is negative, or `len` is negative, or `off+len` is greater than the length of the array `b`, then an `IndexOutOfBoundsException` is thrown. If `len` is zero, then no bytes are written. Otherwise, the byte `b[off]` is written first, then `b[off+1]`, and so on; the last byte written is `b[off+len-1]`.
      Parameters:
        `b` - the data.
        `off` - the start offset in the data.
        `len` - the number of bytes to write.
      Throws:
        `IOException` - if an I/O error occurs.

    - #### writeBoolean

          void writeBoolean​(boolean v)
                     throws IOException

      Writes a `boolean` value to this output stream. If the argument `v` is `true`, the value `(byte)1` is written; if `v` is `false`, the value `(byte)0` is written. The byte written by this method may be read by the `readBoolean` method of interface `DataInput`, which will then return a `boolean` equal to `v`.
      Parameters:
        `v` - the boolean to be written.
      Throws:
        `IOException` - if an I/O error occurs.

    - #### writeByte

          void writeByte​(int v)
                  throws IOException

      Writes to the output stream the eight low- order bits of the argument `v`. The 24 high-order bits of `v` are ignored. (This means that `writeByte` does exactly the same thing as `write` for an integer argument.) The byte written by this method may be read by the `readByte` method of interface `DataInput`, which will then return a `byte` equal to `(byte)v`.
      Parameters:
        `v` - the byte value to be written.
      Throws:
        `IOException` - if an I/O error occurs.

    - #### writeShort

          void writeShort​(int v)
                   throws IOException

      Writes two bytes to the output stream to represent the value of the argument. The byte values to be written, in the order shown, are:

           (byte)(0xff & (v >> 8))
           (byte)(0xff & v)

      The bytes written by this method may be read by the `readShort` method of interface `DataInput` , which will then return a `short` equal to `(short)v`.

      Parameters:
        `v` - the `short` value to be written.
      Throws:
        `IOException` - if an I/O error occurs.

    - #### writeChar

          void writeChar​(int v)
                  throws IOException

      Writes a `char` value, which is comprised of two bytes, to the output stream. The byte values to be written, in the order shown, are:

           (byte)(0xff & (v >> 8))
           (byte)(0xff & v)

      The bytes written by this method may be read by the `readChar` method of interface `DataInput` , which will then return a `char` equal to `(char)v`.

      Parameters:
        `v` - the `char` value to be written.
      Throws:
        `IOException` - if an I/O error occurs.

    - #### writeInt

          void writeInt​(int v)
                 throws IOException

      Writes an `int` value, which is comprised of four bytes, to the output stream. The byte values to be written, in the order shown, are:

           (byte)(0xff & (v >> 24))
           (byte)(0xff & (v >> 16))
           (byte)(0xff & (v >>  8))
           (byte)(0xff & v)

      The bytes written by this method may be read by the `readInt` method of interface `DataInput` , which will then return an `int` equal to `v`.

      Parameters:
        `v` - the `int` value to be written.
      Throws:
        `IOException` - if an I/O error occurs.

    - #### writeLong

          void writeLong​(long v)
                  throws IOException

      Writes a `long` value, which is comprised of eight bytes, to the output stream. The byte values to be written, in the order shown, are:

           (byte)(0xff & (v >> 56))
           (byte)(0xff & (v >> 48))
           (byte)(0xff & (v >> 40))
           (byte)(0xff & (v >> 32))
           (byte)(0xff & (v >> 24))
           (byte)(0xff & (v >> 16))
           (byte)(0xff & (v >>  8))
           (byte)(0xff & v)

      The bytes written by this method may be read by the `readLong` method of interface `DataInput` , which will then return a `long` equal to `v`.

      Parameters:
        `v` - the `long` value to be written.
      Throws:
        `IOException` - if an I/O error occurs.

    - #### writeFloat

          void writeFloat​(float v)
                   throws IOException

      Writes a `float` value, which is comprised of four bytes, to the output stream. It does this as if it first converts this `float` value to an `int` in exactly the manner of the `Float.floatToIntBits` method and then writes the `int` value in exactly the manner of the `writeInt` method. The bytes written by this method may be read by the `readFloat` method of interface `DataInput`, which will then return a `float` equal to `v`.
      Parameters:
        `v` - the `float` value to be written.
      Throws:
        `IOException` - if an I/O error occurs.

    - #### writeDouble

          void writeDouble​(double v)
                    throws IOException

      Writes a `double` value, which is comprised of eight bytes, to the output stream. It does this as if it first converts this `double` value to a `long` in exactly the manner of the `Double.doubleToLongBits` method and then writes the `long` value in exactly the manner of the `writeLong` method. The bytes written by this method may be read by the `readDouble` method of interface `DataInput`, which will then return a `double` equal to `v`.
      Parameters:
        `v` - the `double` value to be written.
      Throws:
        `IOException` - if an I/O error occurs.

    - #### writeBytes

          void writeBytes​(String s)
                   throws IOException

      Writes a string to the output stream. For every character in the string `s`, taken in order, one byte is written to the output stream. If `s` is `null`, a `NullPointerException` is thrown.

      If `s.length` is zero, then no bytes are written. Otherwise, the character `s[0]` is written first, then `s[1]`, and so on; the last character written is `s[s.length-1]`. For each character, one byte is written, the low-order byte, in exactly the manner of the `writeByte` method . The high-order eight bits of each character in the string are ignored.

      Parameters:
        `s` - the string of bytes to be written.
      Throws:
        `IOException` - if an I/O error occurs.

    - #### writeChars

          void writeChars​(String s)
                   throws IOException

      Writes every character in the string `s`, to the output stream, in order, two bytes per character. If `s` is `null`, a `NullPointerException` is thrown. If `s.length` is zero, then no characters are written. Otherwise, the character `s[0]` is written first, then `s[1]`, and so on; the last character written is `s[s.length-1]`. For each character, two bytes are actually written, high-order byte first, in exactly the manner of the `writeChar` method.
      Parameters:
        `s` - the string value to be written.
      Throws:
        `IOException` - if an I/O error occurs.

    - #### writeUTF

          void writeUTF​(String s)
                 throws IOException

      Writes two bytes of length information to the output stream, followed by the modified UTF-8 representation of every character in the string `s`. If `s` is `null`, a `NullPointerException` is thrown. Each character in the string `s` is converted to a group of one, two, or three bytes, depending on the value of the character.

      If a character `c` is in the range `\u0001` through `\u007f`, it is represented by one byte:

          (byte)c

      If a character `c` is `\u0000` or is in the range `\u0080` through `\u07ff`, then it is represented by two bytes, to be written in the order shown:

           (byte)(0xc0 | (0x1f & (c >> 6)))
           (byte)(0x80 | (0x3f & c))

      If a character `c` is in the range `\u0800` through `uffff`, then it is represented by three bytes, to be written in the order shown:

           (byte)(0xe0 | (0x0f & (c >> 12)))
           (byte)(0x80 | (0x3f & (c >>  6)))
           (byte)(0x80 | (0x3f & c))

      First, the total number of bytes needed to represent all the characters of `s` is calculated. If this number is larger than `65535`, then a `UTFDataFormatException` is thrown. Otherwise, this length is written to the output stream in exactly the manner of the `writeShort` method; after this, the one-, two-, or three-byte representation of each character in the string `s` is written.

      The bytes written by this method may be read by the `readUTF` method of interface `DataInput` , which will then return a `String` equal to `s`.

      Parameters:
        `s` - the string value to be written.
      Throws:
        `IOException` - if an I/O error occurs.